Plan Mode & Adaptive Thinking

Think of Claude Code as a car with a gear selector. Most of the time you're in default — Claude can read, but it asks before it edits a file or runs a command. acceptEdits is a faster gear: it auto-applies edits and only stops for riskier commands. Plan mode is the opposite of fast: it is a read-only gear. In plan mode Claude can explore your repository — open files, search code, trace how things connect — but it cannot edit anything, run mutating commands, or make changes. Its only output is a proposed plan for you to review.

That constraint is the whole point. The most expensive mistakes with an agentic tool happen when it confidently edits ten files in a direction you didn't intend. Plan mode moves that decision before any change exists: Claude does the research, lays out exactly what it intends to do, and hands you a stop-and-think moment. You read the plan, fix what's wrong, and only then let it act.

This maps onto Claude Code's recommended Explore → Plan → Implement → Commit workflow. Plan mode owns the first two phases — Explore (read files, gather context) and Plan (Claude drafts a detailed plan) — keeping research cleanly separated from execution. You approve, Claude drops back into an editing gear, and then it implements.

There are three entry points, and they suit different moments.

All three land in the same read-only mode. Pick whichever fits: cycling with Shift+Tab is the muscle-memory default, --permission-mode plan is best when you want the session to begin safe, and /plan is handy when you already know the task you want planned.

# Start a session that's read-only from the first keystroke
claude --permission-mode plan

# Or, already inside a session, jump in with a task
/plan refactor the auth middleware to use the new token helper

Shift+Tab is the same key you'll use to leave (more on that below). The permission mode you're in is always shown in the interface, so you're never guessing whether Claude can edit.

Plan mode's payoff is the plan, and the most common beginner mistake is to skim it and hit approve. Don't rubber-stamp it. The plan is a draft you are meant to shape.

Press Ctrl+G (or Ctrl+X Ctrl+E) to open the proposed plan in your external text editor — your real $EDITOR, with full editing power. Tighten the scope, delete steps you don't want, add a constraint Claude missed, fix an assumption about your architecture. Save and close, and your edited version becomes the plan Claude executes.

This is where plan mode earns its keep. Claude's first draft is usually good but rarely perfect: it might plan to touch a file you'd rather leave alone, or pick an approach you have a reason to avoid. Editing the plan is far cheaper than letting Claude implement the wrong thing and then unwinding it.

When the plan reads the way you want, approve it deliberately. Approval is the moment Claude transitions from proposing to doing — treat it as a real decision, not a reflex.

To leave plan mode, press Shift+Tab twice. Because Shift+Tab cycles through modes, two presses from plan moves you out of read-only and back into an editing gear, where Claude can actually carry out the approved plan.

Put together, the round trip looks like this:

1. Enter plan mode (Shift+Tab, --permission-mode plan, or /plan).
2. Claude explores read-only and drafts a plan.
3. You review and edit the plan with Ctrl+G.
4. You approve the plan deliberately.
5. Exit with Shift+Tab twice so Claude can implement.
6. Verify and commit — let tests, a build, or a diff confirm the work.

That last step matters: Claude tends to stop when work looks done, so giving it a verifier (a test command, a build, a screenshot) lets it close its own loop instead of leaving you as the checker. Plan mode handles the front of the workflow; verification handles the back.

Here's the part that's changed and that a lot of older tutorials get wrong. For years, Claude Code had a tiered set of magic keywords you'd drop into a prompt to buy more reasoning budget — think, think hard, think harder, and ultrathink, in escalating order. They were a Claude Code prompt feature you typed inline.

ultrathink is still a current keyword — type it in a prompt for a one-off deep-reasoning boost when you want Claude to chew on something hard. What changed is the tiered escalation: with Opus and Sonnet 4.6+ reasoning adaptively (the model decides how much to reason based on the difficulty of the task), the older think / think hard / think harder ladder was streamlined — you rarely need to hand-tune reasoning depth, because a 4.6+ model already scales its own. So don't treat ultrathink as gone; treat the micro-managing of think tiers as no longer necessary.

There's also a manual toggle for turning extended thinking on or off explicitly — see the interactive-mode keyboard shortcuts in the docs for the current key. But for everyday work on 4.6+ models, the right mental model is: reach for ultrathink when you want an extra push, and otherwise let the model adapt on its own rather than sprinkling think-tier keywords.

Plan mode is not free. Reading, proposing, reviewing, and approving adds a round trip before any code is written. For the right tasks that's the best money you'll spend; for the wrong ones it's friction.

Use plan mode when the work is uncertain or far-reaching:

• Multi-file changes — refactors, renames that ripple, anything spanning modules.
• Unfamiliar code — a repo or area you don't know well, where you want to see Claude's understanding before it acts.
• High-stakes or ambiguous tasks — where a wrong approach is expensive to undo and you want to lock the direction first.

Skip plan mode for small, clear fixes:

• Fixing a typo, adding a log line, a one-file rename, a trivial tweak. Here the plan-and-approve dance costs more than the change itself — just let Claude do it in default mode.

The rule of thumb: the more uncertain or multi-file the work, the more plan mode pays off. The more trivial and obvious the change, the more it just gets in your way. Match the ceremony to the stakes.