I've been using the planning mode for a while now. It's actually very very good. I now use it almost exclusively when I start working on a new feature.

Here's my workflow:

• Shift + Tab twice to enter the planning mode

• Brainstorming the implementation with Claude, provide feedback on the solution, iterate until I am happy with the solution.

• I use @ reference to help Claude with additional context so it doesn't spend a lot time exploring

• For convenience, I also connect CC to VS Code by using the `/ide` slash command. I open a file in VS, select the lines, and ask CC about the lines.

• I iterate with Claude until I am happy with the solution. After that, Shift + Tab twice to enter auto edit mode. CC will complete the implementation with very little intervention.

I find that with this approach, I don't even need to create PLAN.md anymore. I try to keep the feature iterations small, and commit the changes as soon as the code is working.

Do you have similar experience?

Addendum:

To use the /IDE command, see https://docs.anthropic.com/en/docs/claude-code/ide-integrations

https://cuong.io/blog/2025/06/23-claude-code-ide-vs-code

The key for this to be effective is to keep the scope small. Plan what you will do in the next 30 minutes or less.

The workflow It should be

plan > code > debug > commit

plan > code > debug > commit

plan > code > debug > commit

...

This works really well with small and incremental changes.

Pro tip: while waiting for Claude, you can open another terminal and start another Claude. You can have multiple planning sessions at the same time.

For long discussions, you may use the normal mode and just Claude not to make any changes.

Better yet, use the repomix cli to create a dump of your project.

https://github.com/yamadashy/repomix

You then can upload it to ChatGPT or Claude Web UI for long discussions. Chatgpt's project + canvas feature is super neat for this kind of long planning.

Maybe you miss it:

Plan mode is a special operating mode in Claude Code that allows you to research, analyze, and create implementation plans without making any actual changes to your system or codebase.

What Plan Mode Does:

Research & Analysis Only:

• Read files and examine code

• Search through codebases

• Analyze project structure

• Gather information from web sources

• Review documentation

No System Changes:

• Cannot edit files

• Cannot run bash commands that modify anything

• Cannot create/delete files

• Cannot make git commits

• Cannot install packages or change configurations

When Plan Mode Activates:

Plan mode is typically activated when:

• You ask for planning or analysis before implementation

• You want to understand a codebase before making changes

• You request a detailed implementation strategy

• The system detects you want to plan before executing

How It Works:

1. Research Phase: I gather all necessary information using read-only tools

2. Plan Creation: I develop a comprehensive implementation plan

3. Plan Presentation: I use the exit_plan_mode tool to present the plan

4. User Approval: You review and approve the plan

5. Execution Phase: After approval, I can proceed with actual implementation

Benefits:

• Safety: Prevents accidental changes during exploration

• Thorough Planning: Ensures comprehensive analysis before implementation

• User Control: You approve exactly what will be done before it happens

• Better Outcomes: Well-planned implementations tend to be more successful

Maybe you missed:

To activate PLAN MODE hit Shift + TAB and again Shift + TAB

Plan mode is a special operating mode in Claude Code that allows you to research, analyze, and create implementation plans without making any actual changes to your system or codebase.

What Plan Mode Does:

Research & Analysis Only:

• Read files and examine code

• Search through codebases

• Analyze project structure

• Gather information from web sources

• Review documentation

No System Changes:

• Cannot edit files

• Cannot run bash commands that modify anything

• Cannot create/delete files

• Cannot make git commits

• Cannot install packages or change configurations

When Plan Mode Activates:

Plan mode is typically activated when:

• You ask for planning or analysis before implementation

• You want to understand a codebase before making changes

• You request a detailed implementation strategy

• The system detects you want to plan before executing

How It Works:

1. Research Phase: I gather all necessary information using read-only tools

2. Plan Creation: I develop a comprehensive implementation plan

3. Plan Presentation: I use the exit_plan_mode tool to present the plan

4. User Approval: You review and approve the plan

5. Execution Phase: After approval, I can proceed with actual implementation

Benefits:

• Safety: Prevents accidental changes during exploration

• Thorough Planning: Ensures comprehensive analysis before implementation

• User Control: You approve exactly what will be done before it happens

• Better Outcomes: Well-planned implementations tend to be more successful

Hey guys!

I used Claude a lot these past days and as I noticed many users having issues with performance. I tried different variations on performing same tasks since I was also one of them ( I created a post here too )

After my "research" I concluded 1 simple rule:

ALWAYS BE IN PLAN MODE WHEN SENDING A MESSAGE TO CLAUDE.

Let Claude respond and create TODO checkboxes after you send it a prompt. Literally don't send messages to it if you are not in the Plan mode. It will get confused, lose track of whats doing if you send it a message on the fly. It is where everything collapses. It is when it starts to rush the solution...plan mode is the ultimate antidote that fixes almost all the problems.

I don't think it was like this a few weeks back, but then again I think most of started using Claude with planning and then accepting the changes after a detailed plan. We thought "WOW CRAZY". Then we stepped over the line and just kept adding commands while Claude was working midway on the fly to throw in the changes. This is the ultimate breaking point.

Even if you are in "Bypassing permissions" and you tell it to plan but don't code, it won't perform good...it gets lazy.

It sounds very simple, but PLAN MODE is truly magical.

EDIT: Forget what I said. With some new update, CC just became fully unusable. Can't do shit no matter the planning. I apologize.

I've been watching so many devs complain about Claude Code because they follow this workflow:

- ask for code

- get something back

- shift+tab (let it rip)

Then they wonder why they have garbage code or Sonnet "pukes" out a bad result.

I've been getting absolutely amazing results toggling on plan mode + Opus.

And I don't just use it for a couple minutes. I'll routinely spend 15-20 min in plan mode before I have it write any a single line of code.

Sometimes I'll even have multiple planning sessions before I define on an architecture that looks good to me.

Even before plan mode (for larger features) I'll write out the entire spec in a requirements doc, throw it back in plan mode, and define the implementation plan in chunks. THEN I will take each chunk and have CC work through it, bit by bit, finalizing it before moving onto the next feature chunk.

Why is no one else doing this? Have we lost all of our agency as developers, and just expect the AI to write everything for us right out of the gate, perfectly?

The workflow that's been working for me may seem more tedious, but the code quality difference is insane.

I then review every single line that comes out, for a while, to ensure I'm vibing with it's vibe. Only when it starts to "get" what I want it to do will I toggle on auto-edit mode (and a lot of the times, I won't even get to this point because I want to ensure all of the code it writes is 👌).

Maybe I'm being slightly overly cautious here, but I don't think I am. The difference in code quality is night and day.

When I just let Claude run wild, I get code that may or may not work, and even if it works it is written technically "wrong" and becomes a maintenance nightmare.

When I use my plan approach, I get code that I'd actually approve in a PR.

Anyone else spending this much time in plan mode?

Sometimes I wonder if I'm overthinking it, but then I see the code other people are shipping with AI and... yeah. Curious if others have found a sweet spot between speed and quality.

Hi there!

Anyone else experiencing this with CC plan mode?

Start: "Let's plan feature X"
CC: "Here's the plan"

Me: "Refine the plan"
CC: "Here's some implementation details with plan"

Me: "Refine the plan"
CC: "Here's mostly implementation with some plan details"

Me: "Refine the plan"
CC: "Here's implementation ready to copy-paste"

(cf. screenshots taken right now that led me to ask here)

I want iterative planning refinement, not premature implementation. Each refinement should improve the plan, not drift toward code. Keeping plans abstract helps maintain a better overview of what we're going to build.

Workarounds? Best practices to keep it abstract?

EDIT: It might be necessary to point out that I'm not using "Refine the plan" as my intermediate prompt, but instead I'm listing the changes to be made to the plan (often adding or removing steps, or asking for naming changes).

Before I knew about Planning Mode, it was obvious to me that complex features needed planning—breaking them into smaller tasks, even if the prompt seemed detailed enough.

From the start, I’ve been using Claude Code by simply asking it to create a Markdown plan and help me figure out what I might be forgetting before we begin coding. It works really well, and here’s why:

• I get a clear, easy to read plan saved as a file, I can revisit it anytime, even deep into coding

• The plan doesn't get lost or altered by auto-compact (and honestly, I don't have a single complex feature that ever fit into one context before auto-compact)

• It’s easy to reference specific parts of the plan (Cmd+Alt+K)

• I can iterate with CC as much as I want, refine sections or add details to the plan, even when the coding has already started

• The task list turns into [x] checkboxes that Claude can check

• Even if you’re not using Zen MCP (probably most people aren’t), you can still take the .md plan and get a second opinion from ChatGPT o3 or Gemini 2.5 Pro

Now, everyone is advising to use Planning Mode. I’ve tried it a few times. But honestly? I still don’t really see how it’s better than my simpler Markdown-based approach.

So, when and why is Planning Mode actually better than just asking to create Markdown plan?

Hi everyone,

I saw a comment in a recent thread that was a good one, and I had a similar question.

Is plan mode enough for you all, or do you prefer to explicitly create plans in markdown? If you swap between the two, what hybrid workflow do you find most useful?

I'm used to having Claude write out implementation plans and document granular steps in a markdown doc, but I've considered using plan mode too. Gonna try it myself, but thought may as well ask the community.

Thanks!

EDIT: thank you to everyone who has responded! Y'all have given me a lot to think about and try :)

Claude Code has just stealthily integrated a plan mode by hitting shift+tab once more after enabling auto-updates. No files editable, purely read & think. No documentation or release notes anywhere yet, as far as I can see.

Likely based on this GitHub issue (and other demand) https://github.com/anthropics/claude-code/issues/982

I was today's year old when I came to know that he plan document survives /compact because it's stored separately from your conversation.

Note: This is based on observing Claude Code's behavior and system prompt structure, not official docs. Happy to be corrected if anyone has more info.

Hey guys,

I'm just interested in your method for implementing these modes.

It's not very well documented. As far as I can see, it goes more with the vibe of your prompt to decide when to go into plan mode, when to engage ultrathink.

I personally use +ultrathink +opus as a suffix on many of my prompts, and sometimes (but not often) use +plan or /plan

Any thoughts? Any way to reliably force the issue, or is it more a case of Claude going "Hmmm, user posted '++++ULTRATHINK ULTRATHINK ULTRATHINK, suggesting they want me to think carefully about this task..."

When kicking off a session on Claude Code in a browser, is it possible to enter plan mode? I tried the shift+tab method that works in the CLI, but that doesn't seem to work? Any help would be much appreciated!

Share your methods and tips!

After a few months using Claude Code, I ended up developing a somewhat different workflow that’s been working really well. The basic idea is to use two separate Claudes - one to think and another to execute.

Here’s how it works:

Claude Desktop App: acts as supervisor. It reads all project documentation, analyzes logs when there’s a bug, investigates the code and creates very specific prompts describing what needs to be done. But it never modifies anything directly.

Claude Code CLI in VS Code: receives these prompts and does the implementations. Has full access to the project and executes the code changes.

My role: is basically copying prompts from one Claude to the other, running tests and reporting what happened.

The flow in practice goes something like this: I start the session having Claude Desktop read the CLAUDE.md (complete documentation) and the database schema. When I have a bug or new feature, I describe it to Claude Desktop. It investigates, reads the relevant files and creates a surgical prompt. I copy that prompt to Claude Code which implements it. Then Claude Desktop validates by reading each modified file - it checks security, performance, whether it followed project standards, etc. If there’s an error in tests, Claude Desktop analyzes the logs and generates a new correction prompt.

What makes this viable: I had to create some automations because Claude Code doesn’t have native access to certain things:

1. CLAUDE.md - Maintains complete project documentation. I have a script that automatically updates this file whenever I modify code. This way Claude Desktop always has the current context.

2. EstruturaBanco.txt - Since Claude Code doesn’t access the database directly, this file has the entire structure: tables, columns, relationships. Also has an update script I run when I change the schema.

3. Log System - Claude CLI and Code Desktop don’t see terminal logs, so I created two .log files (one for frontend, another for backend) that automatically record only the last execution. Avoids accumulating gigabytes of logs and Claude Desktop can read them when it needs to investigate errors.

Important: I always use Claude Code Desktop in the project’s LOCAL folder, never in the GitHub repository. Learned this the hard way - GitHub’s cache/snapshot doesn’t pick up the latest Claude CLI updates, so it becomes impossible to verify what was recently created or fixed.

About the prompts: I use XML tags to better structure the instructions like: <role>, <project_context>, <workflow_architecture>, <tools_policy>, <investigation_protocol>, <quality_expectations>. Really helps maintain consistency and Claude understands better what it can or can’t do.

Results so far: The project has 496 passing unit tests, queries running at an average of 2.80ms, and I’ve managed to keep everything well organized. The separation of responsibilities helps a lot - the Claude that plans isn’t the same one that executes, so there’s no context loss.

And you, how do you use Claude Code day-to-day? Do you go straight to implementation or do you also have a structured workflow? Does anyone else use automation systems to keep context updated? Curious to know how you solve these challenges.​​​​​​​​​​​​​​​​

Since the latest version 1.0.5 now supports windows natively. I was really happy to see this and installed it. Got it working, however I'm not sure how to get the Plan mode enabled? Shift+Tab doesn't seem to work. Does anyone know if there is another shortcut?

EDIT: Thanks to thingygeoff who responded in a anther thread. This fixed the issue! Updated my node version and it and now working. https://www.reddit.com/r/ClaudeCode/comments/1lxu1p9/comment/n36syer/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

tl;dr

Claude Code's Plan mode, contrary to almost universal opinion, does not prevent Claude from making file edits or running commands. It's been this way since day 1, and though Anthropic is aware of it and considers it a bug, they've made no visible effort to remediate it since one of the developers admitted it 2 months ago. Using tweakcc, however, you can create custom "Toolsets" which are deeply integrated with Claude Code and provide actual control over Claude's available tools.

Details

It's commonly believed that Claude Code's "Plan mode" feature blocks potentially dangerous tools such as Edit, Write, and Bash.

• "Use Plan Mode for safe code analysis [...] by analyzing the codebase with read-only operations" - https://code.claude.com/docs/en/common-workflows

• "Plan Mode provides safety for sensitive projects [...] You control when changes actually happen instead of guessing whether Claude will edit files." - https://www.claudelog.com/mechanics/plan-mode/

• "Crucially, Plan Mode is read-only. It cannot create, modify, or delete files — making it safe environment for exploration and planning." - https://medium.com/@kuntal-c/claude-code-plan-mode-revolutionizing-the-senior-engineers-workflow-21d054ee3420

• "Plan Mode lets you prime your AI assistant with relevant codebase information without worrying about accidental changes." - https://agiinprogress.substack.com/p/mastering-claude-code-plan-mode-the

• "But here’s the kicker: It cannot write a single line of code until you approve the plan." - https://www.nathanonn.com/how-i-discovered-the-claude-code-feature-that-10xd-my-development-speed-and-why-youre-probably-missing-it/

• "In this mode, Claude will only generate a plan and will not write any files or make code edits, staying in a read-only state." - https://stevekinney.com/courses/ai-development/claude-code-plan-mode

It's not true.

• [Bug] Plan Mode Incorrectly Modifies Files Without Explicit Confirmation anthropics/claude-code#8516: "This is concerning as it bypassed plan mode's safety mechanism and pushed changes directly to the main branch without user approval."

• [MODEL] Violation of plan mode: whilst in plan mode Claude code edited files anthropics/claude-code#7474: "The overall impact to my project was not significant, but the implication that plan mode is unsafe and may make edits is VERY concerning."

• Plan Mode Failure: Claude executes commands and writes files instead of creating a plan in v1.0.95 anthropics/claude-code#6716: "This is a high-severity bug as it breaks a core security and safety feature. Users rely on Plan Mode to prevent accidental modifications to their environment."

• Plan Mode Violation - Agent Executes Plan After User Explicitly Selects "No, keep planning" anthropics/claude-code#5527: "Critical. This bug breaks the fundamental trust and safety model of plan mode. Users rely on this mode to review and vet the agent's proposed actions before any changes are made to their system."

• BUG: Task Tool Agents Bypass Plan Mode Write Restrictions anthropics/claude-code#5406: "This should be treated as a P0/P1 bug as it compromises the fundamental safety guarantee of Plan Mode."

• [BUG] File editing operations are not blocked in plan mode anthropics/claude-code#2467: "This defeats the purpose of plan mode, which is meant to prevent unintended modifications while planning tasks."

Plan mode does not limit the tools that Claude has access to, nor restrict the tools that can execute. It simply injects the following text into the system prompt:

That's it. There's no plan-mode-specific builtin protection against editing files or running commands. It relies purely on the model adhering to the instructions. If it gets confused, forgets, or is tricked, you're in trouble. If—

• you happen to have rm or git reset automatically allowed, for example—it's possible since it's common for Claude to run those commands for legit reasons—and

• you're in plan mode while Claude is researching (or a stupider, more dangerous model via a proxy), and

• you're focusing on something else because you assume that plan mode is protecting you, and

• it gets confused by a long struggle with a difficult issue and forgets about the instructions (or reads some malicious instructions from a web search), and

• it runs something dangerous like rm -rf <folder>, or git reset --hard HEAD, then...

• ?

This is expected

Anthropic has documented that this is a known bug. Dickson Tsai, a developer on the Claude Code team, wrote the following on September 11th, on public GH issue #7474 (anthropics/claude-code#7474 (comment)):

EVERYONE thinks that plan mode is actually technically safer, so WHY isn't this called out clearly in the docs???

As far as I can tell, it's been this way since the beginning. It's not a regression. Bug report #2467 proves that it was a problem as of June 22nd. I verified myself with 1.0.24 (the oldest working version of CC) that it was the case as of June 12th.

There IS a solution

I spent a weekend adding a new feature to Claude Code to fix this. I call it "toolsets." A toolset it just a subset of CC's builtin tools that Claude should have access to. I added a new builtin /toolset slash command that you can use to activate a toolset.

To create toolsets, as well as to patch Claude Code to support them, use tweakcc (https://github.com/Piebald-AI/tweakcc). You create toolsets interactively in tweakcc by selecting the tools you want the toolset to have, and then you use the apply menu or run npx tweakcc --apply to automatically perform all the patching required for toolsets.

Interestingly, while it filters out the disabled tools before they even go to the model, and so it's not able to call them successfully, when you remove a large number of its tools, Claude tends to hallucinate that it has them. It does tend to get the basic ones like Read/Write/Edit/Bash/TodoWrite right (presumably because they're mentioned in the system prompt in various places?), but it often makes up several additional plausible but nonsense tools pertaining to Git, editor/LSP integration, computer use, and various other extensions of existing tools like BashInteractive, TodoRead, or UrlScreenshot. Even worse, it will hallucinate calling them and getting output from them, making the entire flow up!

I found that turning on thinking will somehow force it to recognize that it can't call tools that it doesn't actually have. After wrestling with what would seem to be hidden error messages (maybe on Anthropic's end) it either finds an alternate solution or admits defeat. But in my admittedly minimal testing it's never resorted to hallucination when thinking is on.

Hi everyone! I’ve been using claude-code-cli quite a lot lately and I really like the workflow, but with a Pro account, I’m hitting the 5-hour usage limit much faster than expected. -_-

I mostly use it for:

• refactoring

• bug fixing

• planning and implementing new features

I suspect I’m wasting tokens in ways I don’t fully realize... so I wanted to ask the community:

• Do you have practical tricks or good habits to reduce unnecessary token usage?

• Any prompting strategies that work well?

• Ways to avoid re-sending too much context every time?

• CLI flags, workflows, or tooling that helped you stay within limits?

• Things you stopped doing once you noticed they were token-expensive?

Thanks in advance!