# Claude Code plan mode: turn it on with Shift+Tab, then approve a plan

> Plan mode lets Claude read and explore but blocks edits until you approve its plan. Here is how to enter it, approve or edit the plan, and how it differs from the other five modes.

URL: https://claudegpt.si/news/claude-code-plan-mode-explained  
Published: 2026-11-21T07:00:32.990Z  
Author: ClaudeGPT Si Newsroom  
Section: Guides  
Topics: Claude Code, Anthropic, Claude, Permission modes  
Publisher: ClaudeGPT Si

## Key takeaways

- Plan mode lets Claude read files, explore and write a plan, but blocks edits to your source until you approve it.
- Enter it with Shift+Tab until the status bar shows plan mode on, with /plan before a prompt, or with claude --permission-mode plan.
- Approving switches the session to auto mode or manual edit approval; press Esc first to leave without approving.

Claude Code plan mode is a permission mode in which Claude reads your code, explores and writes a plan, but does not edit your source until you approve that plan. To turn it on, press Shift+Tab in the terminal until the status bar reads `⏸ plan mode on`, type `/plan` before a prompt, or start with `claude --permission-mode plan`, as Anthropic's [permission modes documentation](https://code.claude.com/docs/en/permission-modes) describes as of November 21, 2026.

Plan mode is one of six permission modes. Each sets what Claude may do without asking you first. Plan mode is the one for the moment before a large change, when you want to see the approach before any file changes.

## What plan mode does, and what it blocks

In plan mode, Claude can read files, run shell commands to explore the project, and write a plan. Edits to your source stay blocked until you approve. The docs make one exception: in interactive terminal sessions where bypass permissions are available, planning-time blocks aren't enforced.

What happens to a shell command during planning depends on your setup. The docs list three cases, and the first that matches applies:

- **Bypass permissions available, interactive terminal:** planning commands run with no classifier and no prompt.
- **Auto mode available and `useAutoModeDuringPlan` on, which is the default:** a background classifier, a separate model that checks each action against your request, reviews shell commands. Approved ones run and rejected ones are blocked. Critical-path removals, such as `rm -rf` on your home directory, are handled as in auto mode: a prompt in the terminal, a denial elsewhere.
- **Auto mode unavailable, or `useAutoModeDuringPlan` off:** any command outside Claude Code's built-in read-only set asks for your approval.

So plan mode is not a strict read-only sandbox. It stops edits to your files. Whether exploratory commands prompt you depends on which of those three cases you are in.

## How to turn on plan mode in Claude Code

There are four ways, all from the docs.

1. **Shift+Tab during a session.** Each press moves to the next mode. The basic cycle is `default` (shown as Manual), then `acceptEdits`, then `plan`. If your session started in auto mode, the first press goes to Manual. On Windows, when the Node or Bun runtime doesn't enable VT input mode, the [interactive mode reference](https://code.claude.com/docs/en/interactive-mode) gives `Alt+M` as the key instead.
2. **`/plan` for one prompt.** Type `/plan` at the start of a message. The [commands reference](https://code.claude.com/docs/en/commands) says you can pass the task with it:

   ```text
   /plan fix the auth bug
   ```

3. **A flag at startup.**

   ```bash
   claude --permission-mode plan
   ```

4. **A default in settings.** See the section on making plan mode the default below.

Check the status bar to confirm. It shows `⏸ plan mode on`.

On a test machine running Claude Code 2.1.330, `claude --help` lists the accepted values for `--permission-mode` as `acceptEdits`, `auto`, `bypassPermissions`, `manual`, `dontAsk` and `plan`. The commands run for this guide were `claude --version` and `claude --help`, with no account signed in.

## How to approve a plan, or keep planning

When the plan is ready, Claude shows it and asks how to proceed. The docs list three options:

| Option | What it does |
| --- | --- |
| **Yes, and use auto mode** | Approves the plan and switches the session to auto mode. If auto mode isn't available, this reads **Yes, auto-accept edits**. If the session started with bypass permissions, it reads **Yes, and switch to BYPASS PERMISSIONS (no further prompts) for this session**. |
| **Yes, manually approve edits** | Approves the plan, and you review each edit. |
| **No, keep planning** | Stays in plan mode so you can tell Claude what to change. |

Approving ends plan mode. The session switches to the mode the option names and Claude starts editing. To plan again, press Shift+Tab back to plan mode or start your next prompt with `/plan`.

Two more controls help at this step:

- **Edit the plan yourself.** Press `Ctrl+G` to open the proposed plan in your default text editor and change it before Claude proceeds.
- **Clear context on approval.** Planning can fill a lot of the context window. With `showClearContextOnPlanAccept` set to `true`, the menu gains a first option, **Yes, clear context and …**, that approves the plan, clears the conversation and starts implementing from the plan alone. The setting is `false` by default, according to the [settings reference](https://code.claude.com/docs/en/settings-reference). For what fills that window, see [how the Claude Code context window works](https://claudegpt.si/news/claude-code-context-window-explained).

Accepting a plan also names the session after the plan, unless you named it already.

## How to leave plan mode without a plan

With no approval prompt on screen, press Shift+Tab again to move to the next mode. At the approval prompt, press `Esc` first. The docs warn that Shift+Tab at that prompt approves the plan.

## The six Claude Code permission modes explained

These are the modes as the docs describe them on November 21, 2026:

| Mode (config value) | Status bar | Runs without asking | Best for, per the docs |
| --- | --- | --- | --- |
| `default`, also `manual` | `⏸ manual mode on` | File reads in your working directories and actions that need no approval, such as starting a subagent | Sensitive work, unfamiliar code |
| `acceptEdits` | `⏵⏵ accept edits on` | Reads, file edits and common filesystem commands like `mkdir`, `touch`, `mv`, `cp` | Iterating on code you're reviewing |
| `plan` | `⏸ plan mode on` | Reads, plus classifier-approved commands when auto mode is available | Exploring a codebase before changing it |
| `auto` | `⏵⏵ auto mode on` | Everything, with background safety checks | Long tasks, fewer prompts |
| `dontAsk` | `⏵⏵ don't ask on` | Reads and pre-approved tools; anything that would prompt is denied | Locked-down CI and scripts |
| `bypassPermissions` | `⏵⏵ bypass permissions on` | Everything | Isolated containers and VMs only |

Not every mode is in the Shift+Tab cycle. `auto` appears only when it is available to you. `bypassPermissions` appears only after you start with a bypass flag or set it as your default in user, `--settings` or managed settings. `dontAsk` never appears; you set it with `--permission-mode dontAsk`. When optional modes are on, they come after `plan`, with `bypassPermissions` first and `auto` last.

Deny rules in your settings block actions in every mode, including `bypassPermissions`. Some things are never auto-approved in any mode, such as tools matched by an `ask` rule and recognized `rm` commands on critical paths.

Auto mode has its own requirements on plan, model and provider. Those are covered in [how to turn on Claude Code auto mode](https://claudegpt.si/news/claude-code-auto-mode-turn-on).

## Plan mode vs accept edits vs auto mode

The difference is what happens to file edits. In `acceptEdits`, Claude edits files without asking, and you review the result. In `auto`, Claude runs nearly everything and a classifier checks each action. In `plan`, edits wait until you approve a written plan.

A common pattern follows from the approval menu itself: plan first, then pick **Yes, and use auto mode** or **Yes, manually approve edits** depending on how closely you want to watch the edits.

## How to make plan mode the default

To make plan mode the default for a project's terminal sessions, set `defaultMode` in the project's `.claude/settings.json`:

```json
{
  "permissions": {
    "defaultMode": "plan"
  }
}
```

The same key works in `~/.claude/settings.json` for every project on your machine. The [settings docs](https://code.claude.com/docs/en/settings) rank the files: managed settings first, then `--settings` on the command line, then `.claude/settings.local.json`, then `.claude/settings.json`, then your user file. The `--permission-mode` flag overrides `defaultMode` for one session.

Unlike `auto` and `bypassPermissions`, which the docs say don't take effect from project or local settings files, `plan` works from any settings file.

Claude Code writes plan files to `~/.claude/plans` by default. The `plansDirectory` setting changes that to a path relative to the project root, such as `"./plans"`.

## Plan mode in the IDE extensions, desktop app and web

- **VS Code:** click the mode indicator at the bottom of the prompt box and pick **Plan**. The extension doesn't read project settings for the starting mode. To start in plan mode, set `claudeCode.initialPermissionMode` to `plan` in your VS Code user settings. Picking Plan from the indicator applies to that conversation only.
- **JetBrains:** the plugin runs Claude Code in the IDE terminal, so Shift+Tab and `--permission-mode` work as in the CLI.
- **Desktop app, Code tab:** use the mode selector under the prompt box. Picking Plan applies to that session only.
- **claude.ai/code:** use the mode dropdown under the prompt box. Cloud sessions offer Accept edits, Plan and Auto.
- **Mobile app:** tap **+** in the prompt box, then **Permission**.

## Using a different model for planning

The [model configuration docs](https://code.claude.com/docs/en/model-config) describe an `opusplan` alias. It uses Opus while you are in plan mode and switches to Sonnet for execution. Set it with `/model` or the `--model` flag, for example `claude --model opusplan`.

## Common problems

- **Shift+Tab doesn't reach plan mode on Windows.** Try `Alt+M`, which the docs list for terminals where the runtime doesn't enable VT input mode.
- **Plan mode keeps asking before commands.** Auto mode isn't available to the session, or `useAutoModeDuringPlan` is `false`. Commands outside the read-only set then prompt by design.
- **Pressing Shift+Tab started the edits.** At the approval prompt, Shift+Tab approves. Press `Esc` first to leave without approving.
- **A project `defaultMode` of `plan` is ignored in VS Code.** The extension reads only `claudeCode.initialPermissionMode`, the mode you last picked, and user or managed settings for the starting mode.

The [permission modes page](https://code.claude.com/docs/en/permission-modes) is the place to check when a mode behaves differently from this guide, since Claude Code ships new versions often and the docs tie many details to version numbers.

## Frequently asked questions

### What is the shortcut for plan mode in Claude Code?

Press Shift+Tab to cycle permission modes until the status bar shows plan mode on. On Windows terminals where the runtime doesn't enable VT input mode, the docs list Alt+M instead.

### What is the difference between plan mode and accept edits in Claude Code?

In accept edits mode, Claude edits files and runs common filesystem commands without asking. In plan mode, Claude reads and explores but cannot edit your source until you approve a written plan.

### Can I clear context when I accept a plan in Claude Code?

Yes. Set showClearContextOnPlanAccept to true in your settings, and the approval menu gains a first option that approves the plan, clears the conversation and starts from the plan alone. It is off by default.

### How do I use plan mode in VS Code?

Click the mode indicator at the bottom of the prompt box and pick Plan. To start every conversation in plan mode, set claudeCode.initialPermissionMode to plan in your VS Code user settings.

## Sources

- [Choose a permission mode](https://code.claude.com/docs/en/permission-modes), Anthropic
- [Interactive mode](https://code.claude.com/docs/en/interactive-mode), Anthropic
- [Commands](https://code.claude.com/docs/en/commands), Anthropic
- [Settings files and precedence](https://code.claude.com/docs/en/settings), Anthropic
- [All settings](https://code.claude.com/docs/en/settings-reference), Anthropic
- [Model configuration](https://code.claude.com/docs/en/model-config), Anthropic
