Plan mode is dead

I find it interesting that what the author arrives at is the OODA loop.

The final form became: understand → act → inspect → clarify → adjust → act again

But he says that "understand" isn't really fitting (or something like that), so we are at: act → inspect → clarify → adjust → act again

That can be understood as "observe, orient, adjust, act" - but with other words.

That is the method to use when you are IN the sh*t rather than removed from it and making some theoretical plan.

I thoroughly enjoyed the read <3

A bit late to this party but what the heck.

I too have started using plan mode less, mainly for two reasons: 1. I plan my prompt more carefully and think about architecture up front 2. I found with more recent powerful models, the clarifying questions were generally not useful because it was pointing out issues it obviously knew the answer to and would have resolved in implementation anyway. So essentially they became time-wasting and anxiety inducing for no good reason

The mental shift I made was to not accept poor understanding of a code base on my part when writing the prompt - if I don’t understand it, I can’t predict what assumptions the model will make even on a basic level.

I used to tell myself that plan mode mitigated that, but I usually ended up mentally glossing over the generated plans anyway.

That just resulted in pure anxiety-driven engineering, where I’d often spend extra cycles verifying what was built and worrying about the design.

So invest the time understanding the system, at an appropriate level. That level will change over time as models get better.

Yes, a conversation can be the plan. It helps if you ask it what the commits will be and then tell it to use subagents to implement them.

Also, since sometimes an AI can be a busy beaver, I added instructions to not edit any checked-in files if the prompt contains a question.

I also noticed this personally. Consider when an agent says

"Should I start with the spec, or go straight to building it?

Unless you're working on a super crucial piece of engineering, you can probably get away with going straight to building it. Even if something doesn't go the way you intended, I find that it's usually faster to correct the agent later, once the initial implementation is in place. It's more of an iterative approach to building and I feel that it is less cognitively demanding.

Plan mode is not dead, it just moved to OpenSpec and other similar tools.

If you’re not using those either… I pray for your codebase.

I have rules.md read on every start of the session, in which some of the rules are:

Never start coding befire I say codenow, and add datetime. Before patch explain in plain English what it does. Each file has datetime added to the top of the file, and updated if exist. Each file has a backup copy, created with name.datetime and checked after patch vs backup file, and again with new .backup file for logic vs new backup

I haven't used plan mode for a long time. I do still plan, I usually ask claude to make a plan with me first an explain how it will work, then I iterate with it until I am satisfied and then just let it go. So far it has not started implementing on it's own before I told it to.

I only really used it because the harness was way too trigger happy to start making changes. Even if I just asked a question some times I would come back and it refactored the whole codebase. Now it doesn't seem to do that any more.

I still would appreciate a "read-only" mode. It's not uncommon that I start a harness ONLY to explore and understand the code and I don't really want one typo to have it off building something, or even to save a plan document.

I think Plan mode is very useful when building something that needs step by step validation, but also needs a broad strategy before starting.

For instance, in games where I work, we often need to manually test work out by playing or by using tools in ways that aren't feasible for the AI to do. In that case, getting the human in the loop between steps is an organized process when it's following a staged plan.

My problem with planning and having the models ask the user questions is that the questions the models ask are still often irrelevant: you’ll find yourself answering a bunch of questions like “Should I use the existing system or create a whole new one in a different language?” - yet it will then make assumptions about other things that were actually ambiguous.

I find a lot of value in using plan mode to get the LLM out of dead ends. If it's in Act and starting to spiral (evidence of looking for something or trying to better understand something), I'll kick into Plan and tell it to think a bit harder—also avoids it wasting tokens retrying the same techniques—which results in a much more considered, and more often than not, correct approach.

I still use plan mode, but during plan mode I will spin out sub agents to implement the current draft in a tmp dir and bring back lessons. I feel this keeps me grounded in my original starting point, rather than ending up with a implemention that meanders through the agents own discovery process. It also lets me ask concrete questions about (possible) implementation

I’m curious if anyone has used automations for any kind of regular refactoring and cleanup tasks? Most agent guis support it.

Still working on and with this but had to move it private because marketplace installed plugins loose capability

https://github.com/samelie/claude-plugin-pnpm/tree/main/skil...

Switched from opencode to pi and I do kinda miss planning mode. I like spending a bit more time in that phase and having multiple providers LLM look at the spec doc etc

That’s very much coming from a desire for improved quality than understanding though

I have noticed this in practice the past month. It’s interesting because goals and plans are obsolete. Skills too.

Much of what distinguished a knowledgeable AI dev a year ago is now an anti pattern.

The second I discovered the plan start hook I hijacked it and replaced the built-in planner with my own. The built-in planner is useless.

It's been a while (well, 8 months) since I used Claude Code, but what I can say is that I greatly enjoy using the plan mode that comes baked into omp (oh my pi), especially for tasks around firmware development. I recognize that has a very different workflow than webapps though.

I dont know about Claude Code, but I'm using Amp Code since November 2025 and it don't need the mode at all, just conversation.

The Planning vs Plan is the core of the post.

“Plans are of little importance, but planning is essential” - Churchill

I'd like a brainstorming mode, with limited side effects.

I want it to go and read stuff but also invoke some commands and generate reports and discuss on the results. Latest GPTs in codex plan mode always go.. write a plan. Shocking, i know, but thats not what i want on every turn when im in that mode.

Use instead:

   npx skills add mattpocock/skills --skill=grill-me

   npx skills add imbue-ai/blueprint

Maybe we need to figure out how humans should communicate with AI

> how do humans maintain a coherent mental model of a software system

This is the core question and it is wrong. Because it focuses on the software system rather than the problem you are trying to solve. A better version would be:

  How do humans maintain a coherent mental model of the solution they want to create?

It seems people will never tire of finding out that writing code isn't the hard part of making useful software.

>We still haven’t solved how to help people stay oriented as hundreds of increasingly capable agents change a system at once.

Engineer, meet business school.

I disagree I want a proper read only mode, a lot of times models are still trigger happy.

i disagree, i think it is very useful to have the ability to ask anything about the code and have the confidence that it WONT execute supid stuff

I generally only work with the default claude auto and see that it does pretty well for my needs

I would have assumed plan modes make use of tools to keep the goal/plan persistent across compaction etc. Is that not the case?

Ironically enough Google Antigravity added plan mode this week.

I totally disagree. This perspective only works if you don't care about token cost.

I'm using Astra for some homelab work and I tell it I want to do something and then it burns through a giant percentage of my 5-hour allowance (on the £20/mo subscription) doing that in a really weird way. I've had to tell it to stop zooming off and doing things, calling loads of tools and looking up websites, and just have a quick conversation first. It's much better now, but I've basically just reimplemented plan mode via AGENTS.md.

In other news, Antigravity (the one that isn't the IDE or CLI) just added plan mode: https://x.com/antigravity/status/2103611698800140697

> While the ease of generating code this way triggered a greater dopamine reward

I get zero dopamine rush from this. I get a dopamine rush from building something or figuring something out myself. I don't get a dopamine rush for generating thousands of lines of code that I then have to try to understand.

Cool article from a cool founder. Her other posts are great.

Why is a plan "mode" needed? I really hate reading plans in conversation UI. One line in AGENTS.md is always better, and you can customize it to fit your document convention. From the communication perspective, the planning process is most about creating clarity and alignment, on things like scope, constraints and decisions, among people (and agents now), often requiring multiple rounds. The planning tool built in Codex or Claude Code is not persisted, version-controlled, nor well accessible. In practice, My AGENTS.md contains an instruction about writing a document before starting implementation. Usually I won't read that document, because I don't want to micromanage agents. That document mostly serves a historical purpose like ADR, helping me find out what agents missed, made mistakes on or misaligned on, if needed.

yeah plan mode never was really alive to begin with

i find astra's every other message is a small plan, and i have to confirm for it to go

I don’t think it’s dead at all. I use it as a phase transition to let the agent decide when discovery is sufficient, as an intermediate phase between that and implementation. Even as a human dev you rarely go tinkering with files all over without first forming a plan.

why do you even need plan mode?

“discuss your plan with me before implementing anything”

theres your plan mode

Plan mode isn’t that useful but planning is, I never used it much, but in the agent build mode, I lay down the specs, the architecture, and everything I can think of, and I ask the agent to make the blueprint with the specs that will be used throughout the project, I review them, make the needed edits and revisions, then code and review follow. This is good because you can use the blueprint in any other model or agent, even humans can read it and understand it, sure, sometimes it gets overly verbose but it’s better than nothing.

I can't speak for Claude, but in Codex, plan mode is very useful for finding serious issues with one's spec. I use it to improve my spec. I keep rerunning plan mode over my updated spec until it stops finding issues. It is only then that I execute the spec.

> This cut-and-paste workflow felt clunky and made it arduous to work through an idea while keeping track of the current plan.

I mean, it is, and if that were the workflow I’d be very fed up of it by now, but the plan mode in Claude’s VS Code extension has supported select and annotate directly since at the very least early 2026.

Waterfall is dead. Agile iteration is the future.

That’s the amazing realization?

"AI-generated text is painful to read"

We experienced another step function in model quality over the summer. Models are now one-shotting medium sized tasks that require significant engineering judgement. We're moving into an era where the production of software will be done entirely by machine, requiring only an abstract description of the need the system is to fulfill in business language. This has been the goal since the 1970s. "Plan mode" isn't necessary when the model can suss out what you need from a few sentences of prompt and make competent engineering decisions to fulfill that need.

Brooks was wrong. We have a silver bullet now.

Maybe, I always say "let's write a plan and refine it" which ends up being a nice rubber duck session to keep claude and friends from going off the rails implementing things like privacy or encryption or some other rabbit hole when I just need it to do a few features at a time so I can review while it starts the next few things. Maybe this is slower to deliver, but I don't spend a lot of time unwinding commits.

I don't necessarily use plan mode explicitly for this, but I might turn it on if I think something destructive is coming up, like a schema change or some other devops thing where claude may decide "oh we copied it all over so I can delete it from source" "oh I'm sorry I didn't catch that error code and assumed success, your data is now gone" lol. This happens a lot less but I've been bit right on the face by it before.

Are plans the wrong abstraction? You can use a big enough plan to spam tickets into linear and have claude burn them down. I find it increases subagent accuracy.