I haven't been writing code myself for a few months. Not a line. No scripts, no patches, no hand-rolled refactors.
Instead, I write tickets. Goals, expected outcomes, acceptance criteria. The way a Product Owner would in Jira — except the one picking up the ticket isn't a human. It's an AI. It restates what it understood, opens a branch, delivers the work, reports back. We iterate until the task is properly done.
And we don't move one ticket at a time. We move five, ten, fifteen, sometimes twenty in parallel.
What is an Agentic Development Environment?
An Agentic Development Environment (ADE) is not an IDE with AI bolted on. It is an environment designed so AI agents do the work for you, with you as the arbiter rather than the executor.
In a classical IDE you sit at the center: you edit, you test, you commit. AI suggests. In an ADE you write the intent — AI does the rest, and you validate the result. The unit of work shifts radically: it's no longer the file, it's the ticket.
Why a kanban and not a chat?
Most AI products for developers are chats. They feel fine for individual use, but they collapse the moment you try to run several tasks in parallel:
- A chat is linear; a project is tree-shaped.
- A chat forgets context between sessions; a ticket carries it.
- A chat cannot say "this task is blocked by that one"; a kanban can.
- A chat doesn't re-read itself; a ticket doubles as a spec, an execution log, and the project's long-term memory.
The kanban is the native format of this way of working. One card = one intent. One status = one state of the world (To do, In progress, Pending review, Failed, Done). An "In progress" column holding fifteen cards isn't a degraded mode anymore — it's the normal mode.
How fifteen tickets can move forward in parallel
The piece that makes it technically possible is Git worktrees. Each ticket runs in its own worktree — an isolated copy of the repo, on its own branch, without interfering with the others. Fifteen tickets, fifteen worktrees, fifteen branches. No state conflict during execution.
At the end, every ticket is rebased onto the base branch before being reintegrated. If the base moved while an agent was working, we replay the tests on the rebased version — it's the only way to prevent two tickets that pass in isolation from producing a broken integration.
Git hooks as a safety net
When AI is producing code at scale, you need automated safety nets. Git hooks become central: lint, formatting, typecheck, unit tests — everything runs at pre-commit. If a hook fails, the commit fails, the agent diagnoses, fixes, retries.
No --no-verify. Ever. The hook isn't a suggestion, it's the contract with the branch.
What happens when something breaks anyway?
No system is infallible. When an agent gets it wrong, when a test passes locally but fails in CI, when a deploy derails — we don't fix it by hand. We open a ticket. A ticket that asks another agent to hunt the root cause down the pipeline. The ADE becomes its own safety net: it can self-diagnose.
It sounds counter-intuitive, but that's what makes orchestration sustainable. Without that loop, you fall back into the classic trap of "I'll just fix this quickly by hand" — and lose the orchestration benefit in fifteen minutes.
Two months in production
This system has been running for two months. Two months that I've been building Singularity with Singularity. The product is using itself daily, in production, on a real project with real users.
The honest speed-up is around 50× on the work I used to do by hand. And I'm aware I'm still well below the ceiling. The limit is no longer my typing speed or my ability to hold five subjects in my head at once — it's the quality of my specs. That's the one thing that stays 100% human.
FAQ
Does an ADE fully replace an IDE?
No. Singularity exposes a native terminal and code editor — you can step in by hand at any moment. The point isn't to forbid human code; it's to make it optional. Most of the time, you no longer need to.
How does the AI handle a poorly written ticket?
Poorly. That's exactly why ticket quality matters. A well-orchestrated AI agent restates what it understood before going off to code, and you arbitrate the contract. If the restatement is off, you correct it before launching execution.
What happens when two tickets touch the same files?
Each ticket runs in its own worktree, so execution itself never conflicts. At reintegration, the second ticket rebases onto the result of the first. If a conflict arises, the AI proposes a reasoned resolution and you arbitrate.
How much can you trust the generated code?
As much as you trust your hooks and your tests. The code doesn't get a free pass because an AI wrote it — it passes through the same safety nets as any other code. If your test suite is weak, orchestration will expose it fast.
Does this work on any project?
The better-tested the project, the more effective orchestration is. On an untested project, AI will ship fast but you'll arbitrate more. On a well-tooled project (hooks, CI, tests), the human/AI ratio tilts toward speed very quickly.
Singularity is shipping soon
Singularity is the application we build to run this ADE day to day. Native client for macOS, Windows and Linux.
To understand the product philosophy behind all this, read the manifesto.