Plan Mode Is Dead: When AI Coding Tools Stopped Asking Permission

Aymann Nadeem had a conviction so strong he built an entire product around it. Planning, he believed, was going to become the most important part of building software with AI. His desktop coding app, Nuanced, was designed to give plans a home — a persistent, living document that would guide AI agents from intent through implementation. This month, he shut it down.

In a detailed post-mortem published this week, Nadeem explains why plan mode — the beloved feature in tools like Claude Code, Cursor, and Codex — is dying. And his reasoning isn't what you'd expect.

The Promise of Plan Mode

Plan mode emerged from a real problem. When AI coding agents first arrived, they could generate thousands of lines of code in minutes, but the interfaces to manage that output hadn't caught up. Developers found themselves inheriting massive maintenance burdens before they'd even thought through what they were building.

The solution seemed obvious: slow down. Force the AI to plan first, let the human review the plan, then execute. The workflow was clean:

• Plan what to build
• Get human approval
• Execute the plan

Tools like Claude Code, Cursor, and Codex all adopted some version of this. Nuanced went further, making the plan a first-class persistent artifact — a living document that would guide the entire development lifecycle.

Three Things That Killed It

Nadeem identified three core reasons why plan mode failed — and why it's failing everywhere, not just in his product.

1. Models Got Too Good

This is the most uncomfortable truth. As models improved at understanding large codebases through context and memory, they got better at making reasonable assumptions on their own. Each decision a model can reliably make by itself is one fewer decision that needs to be surfaced to the human.

Nadeem hadn't originally thought of model capability as being in competition with planning interfaces. But it was. The smarter the models got, the less they needed humans to spell out every detail — and the less value the planning artifact provided.

2. Nobody Wants to Read AI-Generated Specs

This one stings for anyone who's built planning tools. Nuanced's specs were thorough, structured, and comprehensive. They were also nearly unreadable. There's something about the pacing and overly structured nature of AI-generated text that makes it genuinely difficult to absorb.

The team tried building a Spec Tour — an interactive walkthrough of the important parts. That just added another layer of complexity, more text demanding attention. If you need a shorter representation to make the spec usable, what's the point of the full document?

3. Planning and Building Don't Actually Separate

Real thinking doesn't happen in a linear waterfall. You understand part of the problem, try something, learn from the result, change your mind, try again. Planning and building are interleaved. They emerge organically.

Plan modes force you to prematurely finish thinking so you can start building. Once implementation begins, going back to planning feels like moving backward. The artificial boundary between the two phases creates more friction than it removes.

The New Loop

What's replacing plan mode? A tighter, more continuous loop:

• Understand the context
• Act — make a change
• Inspect the result
• Clarify if something's wrong
• Adjust and act again

There's still an enormous amount of planning happening inside that loop. But it doesn't need to appear as a document called the plan. The plan has become a process, not an artifact.

The Unsolved Problem

Nadeem is careful to point out that the underlying problem plan mode tried to solve hasn't gone away. Humans still need to maintain a coherent mental model of a software system while machines change it faster than they can inspect the changes. That problem gets harder as you go from five agents to hundreds.

Keeping up can't mean reading every conversation and trying to prompt an explanation for each code change. Agents need to identify the fewest places where human attention can have the greatest impact and surface enough context to make that attention useful.

Nobody has solved this yet. The deeper problem — how humans understand complex systems and navigate powerful tools — is enduring. Interfaces will keep changing alongside the technology that powers them. The need to make complexity comprehensible won't.

What This Means for Developers

If you're using AI coding tools and still religiously writing out plans before every task, this should be a wake-up call. The most effective workflow isn't plan-then-build — it's a continuous conversation where you and the agent iterate together. You don't need to finish thinking before you start building. You think while building, and the building teaches you what to think about next.

The tools are catching up to this reality. Codex already collapses the boundary between planning and execution. Claude Code's newer features blur the line. The plan mode toggle is becoming a relic of a time when models needed more hand-holding.

That doesn't mean planning is dead. It means planning has been liberated from the artifact. The thinking still matters. The document doesn't.

Nadeem's final reflection is perhaps the most honest part of the entire piece. He admits the biggest mistake wasn't building the wrong tool — it was turning the plan into an artifact instead of designing a process for improved human understanding. The plan was never the point. The understanding was.