This article was written with the help of AI, based on the author's original notes and ideas.
I recently told my engineers to ditch their IDEs. PyCharm, VS Code, Cursor, all of it. Just use Claude Code in a terminal.
Sounds extreme. Let me explain how I got here.
It started with my own setup
A few months ago I dropped my IDE and went all-in on Claude Code and later Claude Cowork. The difference was hard to ignore. I was shipping features in hours that used to take me days, and it didn't feel like I was cutting corners.
I wasn't the only one. Other founders and power users were reporting the same thing. You could see it in their commit histories: output that looked like their early startup days. People were genuinely excited about coding again.
Then I heard Boris Cherny, Head of Claude Code at Anthropic, on Lenny's Podcast saying he hadn't touched an IDE or written code by hand in months. His take was that coding is basically solved. That was back in February, and it's only gotten more true since then.
The team wasn't convinced
When I told the team they should make the same switch, the concerns were predictable: How do we keep track of what's happening without a file tree and tabs? How do we navigate a codebase without the IDE's tooling? And if an agent is writing everything, who's actually reviewing the code?
Fair questions, but I think they point in the wrong direction. The instinct is to manually review every line an agent writes, but that's just recreating the old workflow with extra steps. The better move is to invest in tests, CI, and clear acceptance criteria. Focus on whether the output is correct, not on watching it get typed.
If your test coverage is solid, your linting is strict, and your requirements are specific, code quality tends to follow. You don't need to babysit the agent. You need systems that catch problems before they ship.
Where the terminal workflow breaks down
More engineers are working from terminals now. They spin up agents, review pull requests when needed, and spend most of their energy on what to build instead of how to build it. But once you're running 5 to 10 agent terminals at once, you quickly realize that you're the weak link.
You lose track of what each agent is doing. Agents step on each other's toes with overlapping file edits. Large contexts get muddled. You end up spending more time managing the agents than actually thinking about the product.
Beyond just code
The other thing that changed my perspective: when I connected all my tools through Claude Cowork (Linear, Slack, docs, code, everything in one place) it was a noticeable level-up. No more tab switching, no more losing my train of thought bouncing between apps.
Which made me wonder: why doesn't the development environment itself work this way? Why are we still splitting our attention across five different apps to do what is fundamentally one job?
So I built the thing I needed
That frustration is what led to Lanes. I decided to tackle the most immediate problem first: myself. Five AI coding CLIs across eight terminal tabs. One waiting for input I didn't notice. One finished ten minutes ago. Two doing overlapping work. My short-term memory just wasn't cutting it.
So I built Lanes as an issue board for AI sessions. Every AI session lives on a card that you drag through Planning, Implementation, Review, and Done. You can see what's running, what's blocked, what's waiting for input, and what shipped, all in one window. Each card has a live terminal running Claude, Codex, or whatever AI CLI you use, in your actual shell with your dotfiles and config. No sandboxed imitation.
It also handles the git side of things: auto-creating worktrees with generated branch names per issue, showing uncommitted and unmerged state at a glance, and cleaning up when you're done. The kind of stuff you'd otherwise be juggling in a dozen terminal tabs.
It's not the full ADE vision yet. But it's the layer that was missing between me and my fleet of AI coding CLIs, and it's already changed how I work day to day.
Long live the ADE
The IDE was designed for a world where humans type code. That world is winding down.
What replaces it is the agentic development environment: a single workspace where you think, delegate, and ship. Where your working memory doesn't limit how much you can build. Where agents handle the execution and you focus on direction.
The IDE is dead. Long live the ADE.