Claude Code Plan Mode: How to Use It and When It's Enough

Claude Code’s plan mode makes it read your code and write a plan without changing a file. Press Shift+Tab until the status bar says plan mode on, or start a prompt with /plan. When the plan looks right, you approve it and Claude starts editing.

That is the whole idea, and it is still in the product. But the way you reach it changed. Interactive terminal sessions now start in auto mode, so the first Shift+Tab does not land on plan mode, which may be why people ask whether plan mode is gone. It is not. This guide follows Anthropic’s own docs, read on October 27, 2026.

Plan mode has one limit worth knowing before you lean on it. The plan lives in the session you made it in. Once a build spreads over several sessions, or over Claude Code and Codex, the plan has nowhere to live. We make Context Board, which has a plan board for exactly that job, and the last section covers it. Context Board is ours, so weigh the bias.

What plan mode is today

Anthropic’s permission modes page describes it in two sentences. 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.”

It is one of the permission modes, next to manual, accept edits and auto. A permission mode sets what Claude can do without asking you first, so plan mode is less a feature and more a setting for how careful Claude is allowed to be. The docs list it as best for “exploring a codebase before changing it.”

Two things changed recently that most older guides miss.

Terminal sessions start in auto mode. On Claude Code v2.1.283 or later, a session you start in a terminal or through the VS Code extension begins in auto mode, where a classifier reviews risky actions instead of asking you each time. Plan mode is now something you switch into, not the mode you land in after one tap.

/ultraplan is gone. The command reference lists it as removed and says to use plan mode instead. It used to send a planning task to a cloud session. If a tutorial tells you to run it, the tutorial is out of date.

How to enter plan mode

There are three ways in from the terminal, and the docs give each one.

1. Shift+Tab. Press it to cycle permission modes. The status bar shows which one is active, and plan mode reads ⏸ plan mode on.
2. /plan. The command reference says it enters plan mode directly from the prompt, with an optional description. /plan fix the auth bug switches modes and starts on that task in one go.
3. A launch flag. claude --permission-mode plan starts the session in plan mode. The same flag works with -p for non-interactive runs.

Why Shift+Tab seems to skip it

If your session started in auto mode, the first press does not go to plan mode. The docs say the cycle runs from auto to default, then accept edits, then plan. Default shows in the status bar as manual mode. Optional modes slot in after plan, so a session with auto available loops back to auto on the next press.

So in a fresh terminal session you press Shift+Tab a few times and watch the status bar. Stop when it says plan mode on. If you would rather not count, type /plan.

Make plan mode the default

To start every terminal session in a project in plan mode, set defaultMode in .claude/settings.json:

{
  "permissions": {
    "defaultMode": "plan"
  }
}

The docs say a plan value applies from any settings file. Only auto and bypassPermissions are ignored in the project files.

Other places it works

What Claude can and cannot do in plan mode

It can read files, run shell commands to explore, and write a plan. It can also write its own plan files. The docs name “the current session’s own plan files in ~/.claude/plans/” (or the folder you set with plansDirectory) as exempt from the protection on the .claude folder.

It cannot edit your source. Edits stay blocked until you approve the plan.

What happens to a shell command depends on your setup, and the docs give the cases in order:

• Auto mode is available and useAutoModeDuringPlan is on, which is the default. The classifier reviews shell commands instead of asking you. Approved commands run and rejected ones are blocked.
• Auto mode is not available, or useAutoModeDuringPlan is off. Commands outside the built-in read-only set prompt you for approval.

Plan mode keeps its blocks in non-interactive -p runs, in Agent SDK sessions and in the VS Code chat panel.

The bypass exception

One case catches people out. In an interactive terminal session started with bypass permissions available, Claude Code does not enforce plan mode’s blocks. The docs say Claude “is still instructed to plan without editing, but a file edit or shell command it attempts during planning runs without prompting.”

So plan mode is a hard stop in most setups, and an instruction in that one. If you run with bypass permissions, treat plan mode as a request, not a lock.

Read, edit and approve the plan

When the plan is ready, Claude presents it and asks how to proceed. These are the choices the docs list:

• Yes, and use auto mode. Approve and start in auto mode. If auto mode is not available to your session, for example because your organization turned it off, this option reads Yes, auto-accept edits instead. If you started with bypass permissions enabled, it offers to switch to bypass permissions for the session.
• Yes, manually approve edits. Approve, then review each edit one by one.
• No, keep planning. Stay in plan mode and tell Claude what to change.

Approving a plan exits plan mode and moves the session into the mode you chose, so Claude starts editing at once.

Edit the plan before Claude starts

Press Ctrl+G to open the proposed plan in your default text editor and change it directly. This is the fastest way to cut a step you do not want or fix an assumption, and it beats arguing with Claude about wording.

Clear the context on approval

If you turn on showClearContextOnPlanAccept, the list gains a first option that approves the plan and clears the planning context. That gives the build a clean start. The exploration is behind you and only the plan comes with you.

Accepting a plan also gives the session a generated title based on the plan, unless you already named the session. That helps later when you hunt for it in /resume.

Leave plan mode without approving

Press Shift+Tab again and you move to the next mode in the cycle with no plan approved. To plan again, cycle back or start your next prompt with /plan.

Plan mode and opusplan

Anthropic’s model configuration page has a model alias built around plan mode. With opusplan:

• In plan mode Claude Code uses opus for complex reasoning and architecture decisions.
• In execution mode it switches to sonnet for code generation and implementation.

On the Anthropic API, opus is Opus 5.5 and sonnet is Sonnet 5.5. Set it like any model, with /model opusplan inside a session, claude --model opusplan at launch, or the model setting. The docs also describe opusplan[1m] for a 1M context window in both phases.

Is it worth it? On Pro, Max, Team and Enterprise plans the default model is already Opus 5.5, so a normal session plans and builds on Opus. opusplan moves the build half to Sonnet. Anthropic’s cost guide says Sonnet “handles most coding tasks well and costs less than Opus,” and suggests keeping Opus for complex architectural decisions. That is the split opusplan automates. Whether it saves enough to notice depends on your work, so watch /usage for a week before you decide.

When plan mode is enough

Plan mode is the right tool when the whole job fits in one sitting and one conversation. Some signs:

• The change touches a few files and you can hold it in your head. A plan is a page, and one session will build it.
• You are not sure of the approach. Reading first and committing second is what plan mode is for. The cost guide says it is for “preventing expensive re-work when the initial direction is wrong.”
• You want to read before it edits. In a repo you do not know, a plan is a cheap way to find out what Claude thinks it is looking at.

It also helps with limits, with one honest caveat. Planning is not free: exploring a codebase reads files, and reading spends the same plan allowance as editing. What you save is the work thrown away when Claude builds the wrong thing. Our guide to Claude usage limits explains how the two windows work, and how to check Claude Code usage shows where to watch them.

For a change you could describe in one sentence, skip it. Planning a typo fix costs more than the typo.

Where plan mode stops: a plan lives in one session

Here is the limit. A plan made in plan mode belongs to the session it was made in.

The docs describe it that way without saying it outright. Claude presents the plan inside the conversation. Accepting it titles that session. The plan files sit under “the current session’s own” folder. And resuming restores the conversation: a terminal session that ended in plan mode resumes in plan mode.

A fresh session starts with an empty context. Anthropic’s best practices page says what to do about it. For work you have not fully thought through, ask Claude to interview you and write a spec to a file such as SPEC.md. Then, in its words, “start a fresh session to build from it, so the build begins with a clean context and a written definition of done.”

That works, and a Markdown file is a fine plan. It starts to strain when the build is big:

• The five-hour window runs out halfway. The plan is in a conversation that is now stuck waiting. The next session needs the plan and also needs to know which steps are done.
• Step status is a guess. A file says what to build. It does not say what was built, what was dropped, or which step stopped half done, unless someone updates it by hand.
• A second agent starts blind. If you move a step to Codex, it has the file but none of the conversation. Our Claude Code vs Codex guide covers why people end up using both.
• Questions wait inside the session that asked them. Answering one means going back to that session.

None of this is a flaw in plan mode. It plans one session’s work well. The gap is a plan that outlasts one session.

For a build that spans many sessions: a plan board

A Context Board plan board is a plan that sits outside any one session. You write it with your agent before anything is built, hand it to Claude Code or Codex, and it stays up to date as the agent builds.

Here is what is on one, from the board’s own description of the plan kind:

• An Overview page. The goal, who it is for, what done looks like, and a diagram of how the steps fit together.
• One page per step. What it does, how it works, its tasks as to-dos, and the files it touches.
• Questions you answer with a click. Instead of a chat thread, the agent puts its questions on the board. You pick an option or answer in your own words.

An example outline, with made-up content, looks like this:

Booking widget (example plan)
  Overview: goal, who it is for, what done looks like, a diagram
  Step 1  Embed script
    - [ ] Loads on any page
    - [ ] Works inside a site builder
  Step 2  Calendar sync
    - [ ] Reads the owner's free times
  Step 3  Payments
    Question: take payment when they book, or at the class?

When the plan is ready, you press Hand off. It gives you the words to paste into Claude Code or Codex, so the build starts from the plan. The agent needs the board added by its address first, which any app that speaks MCP over HTTP can do with a sign-in on an Allow page. The board’s own chat plans and does not build. The building happens in your coding agent, on your own plan.

As it builds, the agent keeps each step’s status current: planned, building, built with what proves it, or blocked. It ticks off tasks and sends pictures of what changed, and you see them on the board. If it cannot go on without an answer, it waits for one and gets it the moment you answer, in the same session.

The part that fixes the one-session problem is Hand off again. Once some steps are built, the next Hand off says which are built, which were dropped, which was left half done and which step to carry on from. A new session, or Codex instead of Claude Code, starts where the plan stands instead of from nothing. With the small program on your computer set up once, the plan also shows whether the session building it is working or waiting for you.

Plan mode and a plan board do different jobs, so use both. Plan mode is how you think through the step in front of you inside a session. The plan board is where the whole build lives while sessions come and go.

It costs the same as the rest of the board: free for 3 days, then $12 a month, with every board type included. If you want to try it, open Context Board and start a plan. To see how it fits beside your usage and sessions, the Claude Code dashboard guide covers the rest of the board.

Plan mode, quick reference

Plan mode is a small switch with a good habit behind it: look before you edit. Use it for the work in front of you. When the work outgrows one session, put the plan somewhere that outlives it. Try Context Board free for 3 days, then $12 a month, and keep the plan where every session can read it.