Two days ago Gartner predicted that by 2027 more than 65% of engineering teams using agentic coding will treat IDEs as "optional." That's the responsibly-hedged version of a thing I've been telling people at work for months in stronger terms: the IDE is already dead. I haven't opened one in I don't know how long. The tools I've built this year (Personal KB, Agent GTD, the dispatch worker behind it) were written entirely in Claude Code, in a terminal. No syntax highlighting. No file tree. No project search. None of it missed.
That's strange because IDEs were one of software's most successful inventions. They became invisible because they got everything right for their era. So what changed?
The IDE is built around an operator I'm no longer being. It optimizes for a human typing into a buffer — find the file, read the code, write the code, navigate to the next file. Every feature it has makes that loop faster, and VS Code and PyCharm are genuinely good at this. They aren't broken. The work they optimize just isn't my bottleneck anymore. I'm running a control plane: deciding what to build, decomposing it into shovel-ready work, dispatching it to agents, reviewing what comes back. None of the IDE's features help with any of that. The bottleneck moved out from under the tool.
A few weeks ago I wrote It's Not the Model — the argument that when AI fails on tasks you needed it to do, the failure is almost always context or orchestration, and you can engineer around both. I said "engineer the orchestration layer." I left something implicit that I want to make explicit now: the orchestration layer is not a layer. It's a stack.
The stack
When I ship a feature in Agent GTD, here is who actually does the work:
- A lead session (me in Claude Code, with a tech-lead Claude as co-pilot) does the expensive thinking: what to build, how to decompose it, what acceptance criteria each piece needs.
- Plan agents take each ambiguous task and groom it into a dispatch-ready spec — file paths, scope boundaries, verification steps — without ever touching the lead's context window.
- Build agents implement the work, push a feature branch, and comment back. The lead never reads source files during this phase.
- A manage agent handles the part of shipping that nobody loves: squash, merge, push, advance the rollout. It only escalates when something is actually wrong. The lead never types
git push origin mainon the happy path. - Personal KB is the memory layer everything reads from — so a decision made in one session is available to every agent in every session that comes after.
Each layer's whole job is protecting the layer above it from toil. The lead's tokens are the scarcest resource in the entire stack — every minute the lead spends reading files or writing merge commits is a minute the control plane can't spend on the next decision. So the layers below absorb the toil. They burn their own tokens so the layer above doesn't have to burn its.
That's why I'm fast. It isn't that Opus is fast. It's that the model doing strategy never has to also do the merge dance. The expensive cognition stays expensive; the cheap cognition gets dispatched.
Simple, not easy
The pattern is conceptually obvious once you see it: separate planning from execution; dispatch the shovel-ready stuff; protect the layer that thinks. Almost anything you'd describe as wisdom in life is shaped like this. Eat less, move more. Listen more than you talk. Show up for the people who showed up for you. The instructions are simple. The work is in the building.
The same is true here. The stack looks tidy in a blog post. Building it took months of unfunny labor: a knowledge base with a graph and hybrid search, a task system with rollouts and state machines, a dispatch worker that handles auth and concurrency and retries, attribution so I can tell which agent did what when something goes wrong. None of that is what you'd reach for if you just wanted "AI in your editor." All of it is what you reach for when you decide the editor was the wrong frame.
Turtles
The harness doesn't wait. It gets built out of what you have right now, by agents, calling agents, calling agents. The plan agent is an LLM. The build agent is an LLM. The manage agent is an LLM. The KB ingestion pipeline is an LLM. The thing wrapping the model is itself made of models.
It's agents all the way down. You don't get smarter models to fix orchestration. You compose what you have, recursively, until the stack does the work.
The IDE wasn't killed by a better IDE. It was outgrown — a single human typing into a buffer is no longer the unit of work that matters.