Source: https://claudetutorial.com/guides/en-us/claude-code-permission-modes-and-plan-mode-explained

[Back to Guides](https://claudetutorial.com/guides/en-us)

Builders

# Claude Code Permission Modes and Plan Mode, Explained

October 27, 2026 11 min read

---

The first time Claude Code asks "Do you want to proceed?" for the fifth time in a row, people do one of two things. Some click Yes without reading. Others give up on Claude Code because it keeps interrupting them. Both are the same mistake: they treat permission as a fixed setting instead of a choice you make for each kind of work.

> A permission mode answers one question: what may Claude do without asking me first?

This guide explains every mode, shows how to switch between them in one keystroke, and gives you a simple rule for picking the right one. It also covers plan mode, the most useful and least used feature for beginners.

## What a permission mode controls

When Claude Code wants to do something that could change your computer, such as edit a file or run a command, one of two things happens. It does it immediately, or it stops and asks you. The permission mode of your session decides which.

The mode applies to the session you are in. It does not change your account or your other projects. You can switch at any time without losing the conversation.

## The modes at a glance

Claude Code has six modes. You will use three of them most days.

| Mode | Status line shows | What runs without asking |
| --- | --- | --- |
| **Manual** (called `default`) | manual mode on | Reads only. It asks before edits and commands. |
| **Accept edits** | accept edits on | Reads, file edits, and common file commands such as `mkdir`, `mv`, `cp` and `rm`, inside your project folder. |
| **Plan** | plan mode on | Reads. It explores and writes a plan, and edits stay blocked until you approve. |
| **Auto** | auto mode on | Almost everything, with a separate model reviewing each action in the background. |
| **Don't ask** | don't ask on | Reads and pre-approved tools only. Anything that would ask is refused instead. |
| **Bypass permissions** | bypass permissions on | Everything. No checks. |

Writes to protected places, such as the `.git` folder, `.claude`, your shell startup file and `.mcp.json`, are treated more strictly in every mode except bypass.

## Switch modes with Shift+Tab

You do not have to remember any of this by name. Press `Shift+Tab` inside a session and the mode changes. The status line at the bottom shows where you landed.

Each press moves to the next mode. If auto or bypass are enabled for your session, they come after Plan. Don't ask never appears in the cycle.

You can also choose a mode when you start Claude Code, which is how you reach the ones not in the cycle:

Terminal

```
$ claude --permission-mode plan$ claude --permission-mode acceptEdits$ claude --permission-mode dontAsk
```

The mode names are default, acceptEdits, plan, auto, dontAsk and bypassPermissions.

To make a mode your standard, set `permissions.defaultMode` in a settings file. Two of the values, `auto` and `bypassPermissions`, are ignored when they are set in a project's own settings files.

## Which mode does a session start in?

It depends on how you run Claude Code and which version you have.

| How you run it | Starts in |
| --- | --- |
| Terminal or VS Code, Claude Code 2.1.283 or later | Auto |
| An earlier version | Manual (auto only on some plans, in some sessions) |
| `claude -p` for one-off questions in scripts | Manual, and anything needing approval is denied unless allowed |
| Auto turned off by your organization | Manual |

If a session selects auto but auto is not available to you, it starts in Manual. The point is to check the status line rather than assume. If it does not say what you expect, press `Shift+Tab`.

## Manual: you approve every step

In Manual mode Claude can read your files freely, and asks before it edits a file or runs a command. This is the right mode when you are new, when the code is sensitive, or when you do not know the project well.

The cost is interruptions. The benefit is that nothing happens that you did not see. For a first session, start here and watch what Claude asks for. You learn quickly which requests are routine.

## Accept edits: fast iteration on code you will review

Accept edits lets Claude change files in your project folder and run common file commands without asking. It still asks for other commands and for anything outside your folder.

This is the mode for working on code you plan to read afterward. You describe a change, Claude makes it, and you review the diff in your editor or with git. It saves the most clicks for the least risk.

## Plan mode: think first, change later

In plan mode, Claude reads your files and explores the project, then writes a plan. It cannot edit your source files until you approve that plan.

1. Turn it on

   Press `Shift+Tab` until the status line says plan mode, or start a single request with `/plan` in front of it, or launch with `--permission-mode plan`.
2. Describe the goal, not the steps

   Say what should be true when the work is finished, and what must not change. Claude explores and asks you questions where it is unsure.
3. Read the plan like a proposal

   Check which files it will touch, in what order, and what it will not do. Press `Ctrl+G` to open the plan in your editor if you want to change it.
4. Approve or push back

   When Claude presents the plan you can approve it and let it edit with auto mode, approve it but keep manual approval of edits, or say no and keep planning.

Prompt

> I want to move our date formatting into one shared helper. Read how dates are formatted across src/, list every place that formats one, and propose a plan in order of risk. Do not change any file yet. Tell me which places you are least sure about.

Plan mode shines whenever a change touches many files, when you do not yet understand the code, or when a mistake would be costly. Five minutes of reading a plan often saves an hour of undoing a wrong edit.

Not every task needs a plan

If you can describe the change in one sentence, such as fixing a typo or renaming a variable, skip planning and ask for it directly. Plan when the diff would be large or surprising.

## Auto mode: fewer interruptions, with a safety check

Auto mode is for long tasks you do not want to babysit. Instead of asking you about every action, a separate model reviews each action in the background and blocks the risky ones.

The order is simple. Rules you set are applied first. Reading and editing files in your project are approved automatically. Everything else goes to the reviewing model, and if it blocks something, Claude is told why and tries another way.

- **Blocked by default:** downloading and running a script from the internet, sending sensitive data to outside addresses, deploying to production or running migrations, force pushes, hard resets that throw away work, and merging a pull request nobody approved.
- **Allowed by default:** local file work in your project, installing dependencies listed in your lock files, read-only web requests, and pushing to branches of the current repository (except branches named as deploy targets).

If the reviewer blocks three actions in a row, or twenty in total, auto mode pauses and Claude goes back to asking you. Approving the action it asks about resumes auto mode. Blocked actions are listed under `/permissions`, in the **Recently denied** tab.

Reduces prompts, does not guarantee safety

Auto mode makes mistakes less likely to slip through, but it is not a guarantee. For work that could damage something you cannot get back, use a mode where you approve each step, and keep your project in git.

Auto mode needs a supported model, and it can be turned off by an administrator on Team and Enterprise plans. That is why you check the status line.

## Don't ask and bypass: for scripts and isolated machines

Two modes exist for automation, and they are not for everyday work.

**Don't ask** refuses anything that would normally ask. The session never waits for you, and it only runs what you pre-approved. It suits locked-down scripts and CI, where you list exactly what is allowed:

Terminal

```
$ claude -p 'run the test suite' --permission-mode dontAsk --allowedTools 'Bash(npm test)' 'Read'
```

Runs one question, allows only the test command and reading files, and denies everything else.

**Bypass permissions** skips every check, including the protection of sensitive folders. Deny rules still apply, and a few critical actions still ask. It exists for isolated environments such as a container or a virtual machine without internet access, because it offers no protection against a malicious instruction hidden in a file or web page. You cannot switch into it from a session that did not start with it enabled, and on first start Claude Code asks you to accept responsibility.

Do not use bypass on your own laptop

If you are unsure whether you need it, you do not. Use accept edits for speed and auto for long tasks.

## Rules sit on top of modes

A mode sets the baseline. You can add rules for exact commands, and they apply in every mode that checks permissions:

- **Allow** rules pre-approve a tool or command, for example `Bash(npm test)`.
- **Ask** rules force a prompt, even in auto mode.
- **Deny** rules block an action in every mode, including bypass.

Rules live in settings files: `~/.claude/settings.json` for you, `.claude/settings.json` for the project, and `.claude/settings.local.json` for private overrides. A narrow allow rule such as `Bash(npm test)` is the best first one to add, because you will run your tests constantly.

Inside Claude Tutorial

Deciding how much to delegate is a skill

Choosing what to hand over and what to keep reviewing is the judgment the app builds across many tasks, and it applies far beyond code.

[GET IT ON Google Play](https://play.google.com/store/apps/details?id=com.claudetutorial.mobile)

## Which mode should I use?

Match the mode to the situation, not to a habit.

| Situation | Mode |
| --- | --- |
| You are new, or the code is sensitive | Manual |
| You want to understand a project before changing it | Plan |
| You are iterating on code you will review in git | Accept edits |
| A long task you do not want to watch | Auto |
| A script or CI job with an exact allowlist | Don't ask |
| A disposable container with no internet | Bypass |

A good default rhythm for a real change: plan first, approve the plan, let Claude work in accept edits or auto, then review the diff yourself. Treat what comes out like a colleague's pull request.

## Frequently asked questions

### How do I switch permission modes in Claude Code?

Press `Shift+Tab` inside a session to cycle between modes. Start with a specific one using `claude --permission-mode <name>`, or set a default with `permissions.defaultMode` in your settings.

### What is plan mode in Claude Code?

A mode where Claude reads and explores your project and writes a plan, but cannot edit your files until you approve the plan. Enter it with `Shift+Tab`, `/plan` before a request, or `--permission-mode plan`.

### Is auto mode safe?

It is safer than approving blindly, because a separate model checks each action and blocks risky ones such as production deploys and force pushes. It is not a guarantee. Keep your work in git and review the result.

### What does accept edits mode do?

It lets Claude edit files and run common file commands such as `mkdir`, `mv` and `cp` inside your project without asking. Other commands still ask.

### Why does Claude Code keep asking for permission?

You are most likely in Manual mode, or Claude is touching something outside your project or a protected folder. Check the status line, and add an allow rule for commands you trust, like your test command.

### What is `--dangerously-skip-permissions`?

The same as bypass permissions mode. It skips all prompts and checks and should only be used inside isolated environments.

## Your permissions checklist

- You can read the status line and say which mode you are in
- You know that `Shift+Tab` changes the mode and `Esc` stops Claude
- You use plan mode before any change that touches many files
- Your project is in git, so every change is easy to review or revert
- You have an allow rule for the commands you approve every day, like your tests

## Continue reading

- [Claude Code for Beginners: Install, Sign In and Run Your First Task](https://claudetutorial.com/guides/en-us/claude-code-for-beginners-install-sign-in-and-your-first-task) if this is your first session.
- [CLAUDE.md Explained: Teach Claude Code Your Project Once](https://claudetutorial.com/guides/en-us/claude-md-explained-teach-claude-code-your-project-once) to stop repeating the same instructions.
- [Claude Code Best Practices: Habits That Get Better Results](https://claudetutorial.com/guides/en-us/claude-code-best-practices-habits-that-get-better-results) for prompts, checks and context management.
- [How to Make Multi-File Changes With Claude Code](https://claudetutorial.com/guides/en-us/making-a-multi-file-change-with-claude-code) for a plan-first change in practice.