The IDE Is Dead, Long Live Vi: What Eight Months of Agent-First Development Actually Looks Like

You’re probably reading this on your second monitor while Cursor or Claude Code runs in the background, autocompleting your thoughts before you finish them. But what if I told you the IDE—that thing you’ve spent years configuring, extending, and defending—might already be obsolete?

David Crawshaw, who’s been building coding agents at the frontier, just dropped a bomb: He doesn’t use an IDE anymore. In 2026, he’s back on Vi.

Vi is turning 50 this year. Let that sink in.

The Core Insight

Crawshaw’s latest update on agent-first development reveals something counterintuitive: the more powerful AI assistants become, the less you need the traditional IDE infrastructure. His evolution tells the story:

• 2021: Copilot made IDEs feel inevitable. Autocomplete was too powerful to ignore.
• 2024: Agents started writing substantial portions of code
• 2026: The latest Opus model now writes nine-tenths of his code

His time allocation has flipped completely. At big companies, it used to be 80% reading code, 20% writing. At startups, closer to 50-50. Now? 95-5—almost entirely reading and reviewing what the agent produces.

When the agent does most of the writing, you don’t need VS Code’s fancy autocomplete. You don’t need IntelliSense. You need go-to-def—and neovim handles that just fine.

Why This Matters

This isn’t just a personal workflow preference. It’s a signal about where development tooling is headed.

The Built-in Sandbox Problem: Crawshaw points out that agent sandboxes don’t work. The constant “may I run cat foo.txt?” prompts from Claude Code, or Codex’s sandbox failures, are productivity killers. His recommendation? Fresh VMs with unconstrained agents. Turn off the safety rails, but in an isolated environment.

Frontier Models or Nothing: Here’s the uncomfortable truth—using anything other than frontier models is “actively harmful.” Not just less effective. Harmful. Because you learn the wrong lessons about what’s possible. You calibrate your expectations to an inferior tool.

“I know local models will win. At some point frontier models will face diminishing returns, local models will catch up, and we will be done being beholden to frontier models. That will be a wonderful day, but until then, you will not know what models will be capable of unless you use the best.”

Software Shape is Wrong: Most software is “the wrong shape” for an agent-first world. Crawshaw’s example with Stripe Sigma is perfect: Stripe built a fancy UI with an integrated LLM helper. Instead, he typed three sentences and had his agent build ETL-from-scratch using the standard APIs—and it solved his problem better than their product.

Key Takeaways

• The IDE had won in 2021. By 2026, it’s optional. The only IDE feature Crawshaw still uses is go-to-def, which any editor can handle.

• Pay for frontier models. Opus, GPT-7.9-xhigh-with-cheese, whatever’s at the edge. It’s temporary, but critical for understanding what’s actually possible.

• Fresh VMs are the real sandbox. Built-in agent sandboxes create more friction than protection. Isolation at the VM level works better.

• Build for programmers, customers will follow. Every customer now has an agent that can write code against your product. The best software for agents is whatever’s best for programmers.

• More programs than ever before. Agent-assisted development means the TODO notes actually become working software. The barrier between “wish I had time to build this” and “it exists” has collapsed.

Looking Ahead

We’re in a strange inversion. For decades, the trend was toward more sophisticated development environments—richer IDEs, better tooling, more integration. Now the pendulum might be swinging back toward simplicity. Not because we don’t need sophistication, but because the sophistication has moved into the model itself.

The implications for tooling vendors, for IDE makers, for anyone building developer products: your competition isn’t other tools. It’s the possibility that three sentences to Claude Code replaces your entire product.

And maybe the strangest part? The 50-year-old text editor was ready for this moment all along.

Based on analysis of Eight more months of agents by David Crawshaw