Is plan mode in Claude Code being removed?

Not according to the Claude Code developer who replied in the Hacker News thread on September 25, 2026. He wrote that plan mode "isn't going away", that users can always type /plan or ask Claude to enter plan mode, and that Anthropic might re-map the Shift+Tab shortcut to something else by default for people who do not use plan mode.

What does plan mode actually do in Claude Code?

Claude Code's documentation describes plan mode as telling Claude to research and propose changes without making them: Claude reads files, runs shell commands to explore, and writes a plan, but does not edit source until the plan is approved. You enter it from the CLI with claude --permission-mode plan, by pressing Shift+Tab, or by prefixing a single prompt with /plan. Approval exits plan mode and switches to the permission mode you chose.

Can you edit or save a plan before approving it?

Yes. In Claude Code, Ctrl+G opens the proposed plan in your default text editor so you can edit it before Claude proceeds, and the setting showClearContextOnPlanAccept adds an option that approves the plan and clears the planning context. In Cursor, plans are saved in your home directory by default and there is a "Save to workspace" action that moves a plan into the repository for team sharing and documentation.

Why do developers say a plan file beats plan mode?

The argument repeated in the thread is cost and context: a long plan accumulates context that then has to be carried into implementation. One commenter reported reaching 200,000 to 350,000 tokens of context by the time a plan was done and said he would rather put the plan in a file and start fresh, planning with a more expensive model and implementing with a cheaper one. Another described prompts shaped like "Propose a plan for change X and write to file Y" followed by "Execute steps M-N from file Y" as the audit-trail version of the same workflow.

Does the planning itself still matter if the mode goes away?

The essay's own conclusion is that planning matters more than ever, while the interface for it was wrong. Its author, who built a plan-first coding app called Nuanced, wrote that he conflated planning with a plan, that models got good enough to fill gaps themselves, that users had surprisingly little appetite for a long AI-generated spec, and that separating planning from building was disruptive because real work alternates between the two.

AI coding · Sept 28, 2026

Plan mode is a prompt, says a Claude Code developer. 495 developers mostly disagree.

On September 24, Ayman Nadeem — ex-senior engineer at GitHub, then founder of a plan-first coding app — published "Plan mode is dead". Two days later his essay had 575 points and 495 comments, and the most interesting reply came from a commenter who says he works on Claude Code and agrees with him: plan mode, he wrote, "has always been a prompt". The short version: the mode is being absorbed into chat, the habit of planning is not, and if you're paying plan-mode prices for a plan nobody reads, you're doing the expensive half.

Hacker News thread for the essay Plan mode is dead, showing 575 points and 495 comments — The thread as it stands on September 28, 2026: 575 points, 495 comments, plus a moderation exchange asking a commenter not to post AI-generated comments. We read the whole thing (HN 49840054).

The short version

The "X is dead" framing is the weakest part. The author is arguing from a failed product experiment, and commenters noticed: "I feel like this post is hawking for commercial reasons more than it's based in reality." The substance survives the framing, so read it for the four findings and ignore the headline.
The answer to the headline came from inside Anthropic's orbit. A commenter identifying as working on Claude Code agreed that plan mode is no longer useful to him, explained that it was never a separate toolset — just a reminder injected into prompts, kept that way to protect the prompt cache — and then said plan mode "isn't going away".
Three camps, not two. Daily users who treat the plan as a review gate; people who moved the plan out of the mode and into a file; and people who never needed it because you can just say "don't edit yet". The third group is the one the mode was built for.
The cost argument is the strongest anti-plan-mode evidence in the thread, and the counter is about who gets to skip planning: the answer keeps coming from people with the newest, most expensive models.
Our read: plan for anything touching code you can't re-clone, write the plan to a file, and treat plan mode as a 30-second flag rather than a workspace you live in.

What the essay actually argues

Nadeem's piece is a post-mortem, which is why it's worth reading even where it's wrong. He built Nuanced, a desktop coding app whose premise was that planning inside agents was becoming the most important part of the work. He now thinks the premise held and the interface didn't, and he names four reasons.

"I conflated planning with a plan." Thinking before building is valuable; preserving that thinking in a large structured artifact is a different claim, and he says the second one failed. "Early users had surprisingly little appetite for that spec."
Models got good enough to fill in the gaps. "Each decision the model could reliably make by itself was one fewer decision that needed to be surfaced." Planning didn't get worse — the number of decisions that needed a human collapsed.
Long AI-generated plans are painful to read. "There's something about the pacing and overly structured nature of AI-generated text that makes it very difficult to read. My eyes kept glazing over." His team's fix was a "Spec Tour" that walked users through the important parts, which he now recognises as an admission of failure: "If we needed to generate a shorter representation of the spec to make the spec usable, what was the point of the full document in the first place?"
Splitting planning from building distorted the work. His workflow ran chat → questions → spec → review → approve → implement, and he argues real thinking doesn't happen in a line: "You'll understand a part of the problem, try something, the initial generation teaches you something new… Planning and building are interleaved." His replacement loop is understand → act → inspect → clarify → adjust → act again.

Notice what is not in that list: that planning is over. His conclusion is the opposite — "how humans understand systems" is the unsolved problem, and the artifact was the wrong answer. That distinction is what most of the reaction missed, on both sides.

He also pre-emptively answered the accusation that showed up anyway in the thread. When a commenter called the piece "hawking for commercial reasons", the author replied in the same thread that he isn't selling anything: "I'm also not pushing this on behalf of a model lab, I don't represent one. These are lessons I learned from my own mistakes building Nuanced" (aymandfire, HN). It's a fair answer to a fair suspicion — a founder writing off the approach his product was built on is either unusually honest or unusually good marketing, and the comment thread did not settle which.

The comment that answers the headline

Halfway down the thread, a commenter who signs his posts as working on Claude Code (bcherny, HN) gives the most concrete first-party account of what plan mode even is:

"In Claude Code, all plan mode does is add a little reminder to every user message along the lines of 'you're in plan mode, please don't code yet'. It's something I came up with late on a Sunday night many months ago, when I got tired of asking Claude to plan with me first before coding in each new session. Something people might not realize is plan mode has always been a prompt — it has never changed the toolset because doing so would break the prompt cache, and so would be expensive for users."
bcherny, Hacker News, Sept 25, 2026

That one paragraph reframes the entire debate. If plan mode is a reminder and not a sandbox, then "is plan mode dead" is really "do you still need to be reminded", and the answer depends entirely on the model you're paying for. He says he stopped needing it when early Fable builds arrived, and with Opus 5.5 he thinks the same is true of that model. Then he answers the panic directly in a reply below: "plan mode isn't going away. You can always /plan or ask Claude to enter plan mode. We might re-map the shift+tab keyboard shortcut to something else by default for people that don't use plan mode" (HN). Treat that as what an employee said in a comment thread, not as a published commitment — but it is a much more useful thing to know than a headline.

It also matches the written docs, which are less philosophical about it. Claude Code's permission-modes page says plan mode "tells Claude to research and propose changes without making them… Claude reads files, runs shell commands to explore, and writes a plan, but does not edit your source", with edits staying blocked until you approve. Given the reminder-only design, the enforcement is a prompt plus an approval gate rather than a hard sandbox — which is exactly why one commenter's objection lands: "It seems unwise not to implement sandbox measures just because the chance of misuse has gotten lower" (Feathercrown).

The pushback, sorted into three camps

Camp 1: "I use it daily and it's great"

dbbk put it bluntly: "I almost always have feedback to refine the plan and I want a clean separation of planning time before writing code. I don't get what the problem is." spacedcowboy described the use case the mode was designed for: work "that would take a human a few months to a year", planned as "a living document", with "a good hour or two iterating over the plan" before implementation starts. akersten made the argument that survives every model improvement: "It's useful because it lets me see the decisions the model will make before it wastes a ton of time implementing them. The model is smarter now but that doesn't solve for underspecification if it guesses my intent wrong."

bartread added the workflow the rest of the thread keeps circling: "Claude's plan mode is great, especially when you add interviewing into the equation." Asking the agent to interrogate you first — before it writes anything — shows up in nearly every pro-plan-mode comment, and it is the part that has nothing to do with modes: a plan-first prompt run in normal chat gets you the same questions.

Camp 2: the plan moved into a file

This is where the essay and its critics actually agree. throwaway27448 described prompts shaped like "Propose a plan for change X and write to file Y" and "Execute steps M-N from file Y", and pointed out the thing plan mode has never done by default: leave a trail. esafak argued that models follow instructions well enough now not to need the mode, "however, there is still value in using a separate, smarter model for planning than execution, and persisting it for auditing on completion".

The file version also solves the cost problem the thread keeps raising. jmb99: "By the time my plan's done I'm usually between 200 and 350k context. Even if keeping that around gives a performance bump for the implementation (which I haven't noticed) it balloons the cost. I would much rather put everything in a plan file and start fresh. Plus, I usually plan with a more expensive model and guide implementation with a cheaper model." jonmagic, who says he works at GitHub, described arriving at the same place from the opposite direction: plan mode "didn't stick for me, until very recently, when I used it the way you describe… I have to do a bit of exploration and discovery on my own" and then let the agent use it to interview him about the last open questions.

Camp 3: the mode was never the point

tcdent: "You can just conversationally instruct the agent to not make changes to the repository… There was a time when we needed to enforce this via selected tool use, but we have surpassed that." charcircuit went further: "It's just redundant when you can just collaborate in the 'main' mode. There's never been a point to having a separate plan mode." The most useful thing about this camp is that it isolates the only real question — not whether to plan, but whether planning deserves its own screen.

The strongest evidence produced against plan mode in the entire thread sits here, and it is about money: CGamesPlay linked a write-up claiming the feature increased costs rather than reducing them (stencil.so), and bityard supplied the one-liner: "It wastes a ton of tokens as well and those are not cheap." We are citing that as a claim made in the thread with a link, not as a measured result — we did not reproduce the experiment.

The objection nobody in the thread could answer

The Claude Code developer's position — "I stopped using plan mode because the model got it" — is grounded in having the newest models. Several commenters pointed out that this is a preview of a future most people don't live in yet. "Remember: not everyone has access to unlimited usage/money to spend tokens or the most expensive models with the higher thinking settings, exceptions does not make the rules" (equasar). Joeri made the practical version of it: "Insiders have months to learn the ins and outs of new models… It would be nice if with new model releases claude code also gave a bit of a model 101."

That's the honest state of play as of this week. Plan mode is unnecessary for the people with the best models and the deepest habits, and still load-bearing for everyone else — which is a strange thing to call dead. It also means the decision is not a matter of taste: work out which group you're in by what your last three sessions cost you.

What to do with this if you write code for a living

The thread converges on a workflow that is mode-agnostic, and the tool docs make it easy to run. This is our recommendation, not a summary of what vendors promise.

Situation	What to do	Why
Hazy task, unfamiliar codebase	Ask for an interview first: "Ask me the questions you need answered before proposing anything." Then plan.	The clarification step is what people are actually protecting when they defend plan mode. It works in any chat window.
Plan you will come back to	Write it to a file in the repo, then run "Execute steps M-N from file Y". In Claude Code, `/plan` or `claude --permission-mode plan` gets you the drafting; `Ctrl+G` opens the result in your editor before you approve.	Beats a mode for auditability and for context cost. The post-approval context question is a setting, not an accident: `showClearContextOnPlanAccept` adds an "approve and clear planning context" option.
Wrong build already in progress	Revert and re-plan instead of patching through chat.	Cursor's own docs give this advice: refining the plan and running it again "is often faster than fixing an in-progress agent".
You want a cheaper planner, stronger builder	Use a model setting that runs planning on a different model from execution.	Claude Code's `opusplan` setting does exactly this; it is also the pattern jmb99 described doing by hand with two models.
Small, known change	Skip it. Say what you want.	Even the essay's critics agree here. One commenter's version of the pro-plan argument is that the workflow is common enough to "deserve a special mode" (Marha01) — that's a UI preference, and on a small task it's a preference you can skip.

Who should care, and who can ignore this

The judgement call

Care if you're paying per token. The single most transferable finding in the thread is the context bill: plan in a strong model, write the plan to a file, implement from the file with something cheaper. That is a real discount, and it doesn't require anyone to win an argument.
Care if you run a team. Once plans live in the repo, "why was this built this way" has an answer that isn't a scrollback search. That's the part of the essay's thesis worth keeping.
Don't panic about the shortcut. The only concrete roadmap signal in the thread was that Shift+Tab might be re-mapped by default; /plan and the CLI flag remain.
Don't believe either headline. "Plan mode is dead" is one founder's post-mortem of his own interface, and "planning is essential" is true without needing a dedicated screen. Both can be right, and in this thread they are.
Don't skip the approval step on anything destructive. The mode being a prompt rather than a sandbox is precisely the reason to keep the habits and not just the toggle.

How this was researched. We read the essay in full (Ayman Nadeem, "Plan mode is dead", September 24, 2026) and the whole 495-comment thread it produced on Hacker News (575 points, submitted September 25), with per-comment links for everything quoted. Vendor behaviour comes from documentation read on September 28, 2026: Anthropic's Claude Code permission-modes page (what plan mode does, entry points, the approval options, Ctrl+G, showClearContextOnPlanAccept) and common-workflows page, and Cursor's plan mode docs (Shift+Tab, clarifying questions, plans saved in the home directory by default, "Save to workspace", revert-and-re-plan advice). The cost claim about plan mode increasing spend is quoted as a thread link to a third-party experiment we did not independently reproduce, and is labelled as such. Quotes from commenters identifying as employees are attributed to what they said in the thread, not to their employers.