Plan Mode

Most permission controls gate individual actions — this specific edit, this specific command. Plan mode gates the approach itself: Claude investigates, proposes how it intends to solve the problem, and waits for explicit approval before making any change at all.

What happens differently

In plan mode, the agent can still read files, search the codebase, and run read-only commands to understand the problem — it just can't edit, write, or run anything with a side effect until the plan is approved. The output is a concrete proposal: what will change, roughly how, and what the tradeoffs or open questions are, if any. You can accept it as-is, push back on a specific part, or redirect the approach entirely — all before a single file has been touched.

When this earns its overhead

Plan mode adds a step, so it's worth reserving for situations where reviewing the approach matters more than reviewing the diff:

• Ambiguous requirements, where more than one reasonable interpretation exists and getting it wrong means redoing real work, not just tweaking a line.
• Multi-step refactors that touch many files, where catching a flawed strategy before step one saves far more time than catching it after step thirty.
• Anything risky or hard to reverse — schema migrations, changes near production-critical paths, deletions of anything not trivially recoverable.
• Unfamiliar codebases, where Claude's read of "how this should be done here" is worth confirming against your own knowledge of conventions that might not be obvious from the code alone.

When it's unnecessary friction

For a small, clear, low-risk task — fix this specific failing test, add a null check here — there's rarely a meaningful "approach" to review separately from the change itself; the diff is the plan. Forcing a plan step on every trivial task just slows things down without buying any real safety.

How it relates to permission modes

Permission modes and plan mode solve different problems and stack cleanly: plan mode is a one-time checkpoint on the overall direction, after which a permissive allowlist can let the individual steps execute quickly without re-litigating the approach at every single edit. Used together, you get one deliberate decision point instead of either no oversight or oversight on every action.

Next: packaging a repeatable instruction as a slash command.