the IDE is dead.
long live the IDE.

I've been building products too many years, and I always see the same movie: when a category of tools stops serving the real work, its industry spends a decade in denial, piling features on top of the corpse.

It's happening right now with IDEs.

To be clear: I'm not saying VS Code, JetBrains or Cursor are going to vanish tomorrow. I'm saying something I've been thinking for over a year: the category is answering a question that's no longer the question that matters.

The IDE optimizes one metric: minimize the friction between the developer's intent and code in the repo. Cursor is the culmination of that story, not its rupture. If your question is "how do I write code faster?", Cursor is the best possible answer inside the IDE category.

The problem is that's no longer the question.

When you sit down today, in 2026, and open your machine, what's in front of you isn't "I'm going to write code". It's a Claude conversation from three days ago about architecture. A ChatGPT session from yesterday with prompts now worth gold and lost. Five active branches. Docs in Notion. Tasks in Linear. Slack decisions that affect today's code. Prompts versioned by hand. Three LLM providers with different policies. Sensitive context that doesn't want to live on anyone's cloud.

And you need to coordinate all of that — not write code line by line.

Writing code has become the last step of a much longer process that no IDE understands.

The bottleneck is no longer the speed of producing lines of code. It's coherence — between intent, context, decisions and models. It's knowing which LLM to use for which task without blowing the budget. It's keeping context without leaking it to servers that change terms tomorrow.

The industry's answer is to bolt AI onto the IDE. It's the old question with new tools. The equivalent of launching "BlackBerry with a touchscreen" in 2008 to compete with the iPhone.

Three things bolting AI onto the IDE
structurally cannot solve.

Context sovereignty. Your vital context — prompts, decisions, internal dialect, institutional knowledge — lives scattered between the AI provider, the repo, Notion, Slack. ChatGPT memory and Claude Projects belong to the provider, not you. When they change terms, raise prices or disappear, your context goes with them. And good luck migrating it by hand. Ha!

Multi-model routing. Serious devs use three or four models depending on the task. Opus for architecture, GPT for fast generation, locals for repetitive work, Gemini for multimodal. The IDE doesn't orchestrate this. You do, by hand, copy-pasting, losing context with every jump.

Union of heterogeneous artifacts. What you build isn't just code. It's code + specs + decisions + AI conversations + docs + prompts. The IDE only understands code. You are the human integrator between six tabs.

These aren't features that are missing. They're architecturally external to the IDE concept. No IDE will solve them, no matter how much AI gets bolted on.

What comes next.

What comes next isn't an IDE. It lives locally. It orchestrates multiple models. It unites heterogeneous artifacts. It treats methodology as a first-class citizen.

Look at the products attracting real attention: Claude Desktop with MCP, Aider in the terminal, LLM routing tools, desktop apps that orchestrate models without going through the editor.

None of them is an IDE.

The IDE isn't going to close offices. It's going to stop being the place where the important part of the work happens. Office didn't disappear, but office work has been moving to Slack, Notion, Linear, Figma for a decade. That's categorical death, not literal.

If you're building tools for developers in 2026 and your mental model is still "IDE extension", you're competing in the wrong place. The useful question isn't "how do I make a better IDE?" It's "what do developers need that no IDE will solve well?"

If you're a developer, the inverse question: how much of your real work happens inside the IDE, and how much in five badly-connected tools around it?

The IDE is dead not as a product, but as an answer. The question it answered still matters — but it's no longer the main one.

What defines the next ten years of software is not being built inside IDEs. It's being built in a category that doesn't have a name yet.

the IDE is dead.
long live the IDE.