Plan mode — default gate for every non-trivial change

Scorecard question: How often do you use Plan mode? Max‑score answer: Default for every non‑trivial change; only exit on approval.

Why this matters in 2026

Plan mode is the cheapest, highest‑leverage safety belt in a 2026 agent‑first setup, and the gap between “I use it when I remember” and “it’s my default” is the single largest predictor of throughput on hard tasks. The mechanic is simple — the agent enters a hard read‑only sandbox, reads files, runs lookups, and writes back a plan you have to explicitly approve before any side effect lands — but the second‑order effects compound. It gates side effects (no rogue rm -rf, no half‑applied migration, no premature file rewrite mid‑exploration). It forces explicit research, which means the agent has actually read the call sites and the tests before it proposes a diff instead of inventing one from a vibe. And it kills the most expensive failure mode of unconstrained agents in 2026: the “wrong direction” rework loop where the model commits 30 minutes of edits in a direction the user would have rejected in the first 60 seconds if they had seen the plan. Boris Cherny, the creator of Claude Code, said publicly in early 2026 that most of his sessions begin in Plan mode and the workflow he uses himself is “start in Plan, go back and forth until the plan is right, then switch to Auto‑Accept and let Claude execute.” That is the max‑score Q6 workflow in one sentence. The 80/20 rule that top AI‑assisted developers cite — 80% of time on planning, 20% on supervising execution — only works if the planning step is structurally enforced by the tool, not left to discipline. Plan mode is what makes it structural.

What “max score” actually looks like — daily workflow with Plan mode default

A max‑score Q6 setup looks identical day to day: every non‑trivial agent session begins in Plan mode by reflex, not by intention. You don’t decide whether to plan — the tool boots into Plan, and you have to actively decide to skip it (which, for non‑trivial work, you don’t). Concretely: you open Claude Code, hit Shift+Tab twice (or type /plan since January 2026) before describing the task, and the bottom‑bar status reads “plan mode on” in cyan. You describe the task in 2–4 sentences. The agent reads the relevant files, runs rg or grep over the codebase, asks one or two clarifying questions if the task is ambiguous, and writes a plan — a numbered list of file changes, test plan, and risks. You read the plan carefully. If it’s wrong, you iterate inside Plan mode: “no, the auth check should live in the middleware, not the route handler,” or “skip step 4 — that’s already done in #1842.” When the plan looks right, you approve it via the ExitPlanMode prompt, and only then does the agent flip into Auto‑Accept (or normal edit mode) and execute. For trivial work — a typo fix, a one‑line config change, a comment update — you exit Plan mode deliberately, but those are a clear minority. The discipline you’re scoring on is not “plan everything” — it’s “plan by default, exit consciously.”

The lower tiers are easy to spot. 0 pts: never use it — every session is direct edit‑mode, you routinely watch the agent commit edits you want to undo. 1 pt: occasional, only for scary tasks; you still get bitten by wrong‑direction rework on medium work. 2 pts: often, for complex tasks, but trivial‑adjacent work slips through. 3 pts (max): Plan mode is the default. The decision tree inverted — you decide whether to skip, not whether to use. Across a full week, Plan mode covers >70% of your sessions, and the cases you skip are genuinely trivial.

Current landscape (web‑search‑verified)

Plan mode in 2026 is a feature with three different implementations across the three Tier 1 tools — Claude Code, Cursor Agents, and Codex — and as of 2026 all three ship a native planning gate (Codex CLI was the last to get one, and it’s now on by default). Knowing the differences is the difference between making Plan mode your default and stumbling over a tool’s quirks every other session.

Claude Code Plan mode (Shift+Tab, ExitPlanMode tool, plan file in ~/.claude/plans/)

Claude Code has the deepest, best‑documented Plan mode of the three. Activate it with Shift+Tab pressed twice to cycle through modes (default → auto‑accept → plan), or — since January 2026 — by typing /plan directly. /plan is the most discoverable entry point and is what you should teach team members. Plan mode is a hard read‑only sandbox: Claude physically cannot make edits or run side‑effecting tools, which is exactly why it’s safe to use on production code or in unfamiliar repos. The agent uses Plan mode to read files (Read, Grep, Glob), ask questions, and write back a plan file under ~/.claude/plans/. When you approve the plan via the ExitPlanMode tool prompt, Claude transitions out of Plan mode and executes — typically straight into Auto‑Accept if you came from there, or back to default mode otherwise. Known quirks: if you start Claude Code with --dangerously-skip-permissions and then toggle into Plan via Shift+Tab, the ExitPlanMode confirmation flow can fail to transition back to act mode (GitHub issue #32934, fixed in recent releases — update if you hit it). A separate sharp edge is that Claude occasionally makes edits while still flagged in Plan mode if it confuses itself about the mode state; update Claude Code monthly to stay ahead of these. Power move: hit Ctrl+G to open the plan file in your $EDITOR and edit it directly — faster and more precise than describing edits through chat. Since Claude Fable 5 shipped on June 9, 2026, there’s a model dimension to the gate too: when budget matters, switch to Fable 5 for the plan itself (/model fable, then Shift+Tab into Plan mode), execute on Opus 4.8 or Sonnet 4.6, and bring Fable 5 back for the final review pass. It’s the same idea as the opusplan alias pattern, one tier up — the plan and the verification get the strongest model while the bulk of the token spend doesn’t.

Cursor Agent Modes

Cursor’s Plan mode lives inside the Agents window (recent Cursor; the Agents panel is centered on Composer 2.5). The shortcut is the same — Shift+Tab in the agent input — and the mechanic is the same: the agent researches the codebase, asks clarifying questions, and produces a reviewable plan before any edit lands. Cursor’s twist is that each agent tab holds its own mode, model, and worktree, so you can park a Plan‑mode Opus 4.8 agent sketching a refactor in one tab while a second Agent‑mode Composer 2.5 agent implements a different ticket in parallel. The recommended Cursor workflow for complex tasks is Plan → Ask → Agent: plan for the shape, Ask for clarifying questions and investigation, then hand off to Agent for execution. Strengths: smoothest UX, in‑editor diff review while planning. Weaknesses: the plan output isn’t a persisted file like Claude’s ~/.claude/plans/, so cross‑session plan continuity takes more effort. Bias: use Cursor Plan mode for feature development inside the IDE; use Claude Code Plan mode for cross‑cutting refactors that benefit from terminal‑native research.

Codex Plan mode (Shift+Tab, /plan, web /plan-mode)

Codex CLI now has a native Plan mode too — and it’s on by default. Cycle into it with Shift+Tab (Codex CLI cycles through collaboration modes — Plan / Pair / Execute — with Plan mode enabled by default since recent releases), or jump straight in with the /plan [description] slash command in the TUI. The mechanic mirrors Claude Code: Codex reads files and proposes a plan without writing, streams the plan into a dedicated view, and you approve before it switches to execution. The /plan-mode toggle in the Codex web app (the ChatGPT‑hosted surface) is the same feature on the hosted side. Pair it with --ask-for-approval on-request (or untrusted) so file edits and shell commands still require an explicit tap — that’s your gate even after the plan is approved. If you’re running an old Codex CLI build that predates collaboration modes, fall back to the two‑step prompt: first prompt “produce a detailed implementation plan only — do not write or edit any files,” iterate until the plan is right, then prompt “now execute this plan.” On any current Codex CLI, reach for /plan or Shift+Tab instead — the gate is built in.

Step-by-step: making Plan mode default

Inventory your last 10 agent sessions. Open your shell history, scrollback, or session logs for Claude Code / Cursor / Codex. For each session, mark whether you started in Plan mode or jumped straight into edit mode. If fewer than 6 out of 10 started in Plan, your current Q6 score is 0–1 pts and the rest of this guide is the fix. Be honest — the score is for the default, not the intent.
Set the trigger you cannot ignore. The single biggest unlock is making “Shift+Tab twice” or “/plan” the first thing your hands do after launching Claude Code, before you type the task. Treat it like seatbelts: not a choice, a reflex. For one week, post a sticky note on your monitor that says “Plan first.” Most people internalize it inside 3–4 days.
Wire it into your slash commands and skills. Write a /explore-then-plan slash command (Claude Code: .claude/commands/explore-then-plan.md) that drops into Plan mode and instructs the agent to “first read the relevant files and tests, then write a plan with file paths, test plan, and risks.” Now Plan mode is one keystroke instead of two, and it ships with the right initial prompt every time. For Cursor, the equivalent is a saved Composer prompt; for Codex CLI, a shell alias that prepends the plan‑only prompt scaffold.
Master plan iteration, not plan acceptance. The amateur move is “agent wrote a plan, plan looks fine, approve.” The expert move is iterating inside Plan mode 2–5 times before approval. Push back on assumptions, demand specifics (“which file, which function, which test”), reject steps that are already done, ask for the rollback story. Each iteration costs ~20 seconds and saves minutes of wrong‑direction edits. In Claude Code, Ctrl+G opens the plan file in your $EDITOR — use it for surgical edits the model can’t get to via chat.
Decide your “skip plan” rule and stick to it. You will skip Plan mode sometimes — typo fixes, one‑line config changes, comment updates, regenerating a snapshot. Write the rule down (a one‑line note in your CLAUDE.md is fine): something like “skip plan only when: ≤1 file, ≤5 lines, no public API change, no migration, no auth, no money.” Anything outside that envelope, plan it. The point of the rule is to make “skip” a conscious decision, not a habit.
Use Codex CLI’s native Plan mode if you run it. If Codex CLI is in your toolbelt, make /plan (or Shift+Tab into Plan mode) your reflex there too — it’s enabled by default. Run Codex with --ask-for-approval on-request (or stricter) so file edits still require a tap even after you approve the plan, and document the convention in your AGENTS.md. On an old build that predates collaboration modes, fall back to the two‑step plan‑only prompt — but don’t let that be an excuse to skip planning.
Pair Plan mode with Auto‑Accept for the execution phase. Plan mode and Auto‑Accept are designed to work together. Plan mode is the gate; Auto‑Accept is the throughput multiplier once the plan is approved. The Cherny workflow is: plan in Plan mode, approve, drop into Auto‑Accept, walk away. If you’re hand‑approving every diff post‑plan, you’re paying the cognitive cost of planning and the cognitive cost of supervising — pick a lane.
Audit weekly for two weeks. At the end of each week, look back at your sessions and tally Plan‑mode usage. Target: >70% of non‑trivial sessions started in Plan, with iterative refinement before approval. If you’re below 70%, the trigger from step 2 isn’t sticking — make it more visible, slash‑commandify it harder, or pair‑program with someone who already has the habit. After two weeks of >70% you can drop the audit; the habit will be self‑sustaining.

Common pitfalls

Exiting Plan mode too early. Symptom: you read the plan in 5 seconds, approve, then watch the agent commit edits you want to undo. Fix: force at least one iteration cycle — ask one critical question before approving (“what’s the rollback?”, “which test catches this?”). The 20 seconds of friction is the whole point.
Accepting bad plans because the agent sounds confident. Symptom: the plan references files or functions that don’t exist, or proposes a change to a system already refactored away. Fix: scan for concrete references — file paths, function names, test names. If the plan is all abstractions (“update the auth flow”), demand specifics.
Plan mode as theater. Symptom: long plans, fast approvals, same rework rate as before. Fix: the plan exists to be challenged, not filed. If you’re approving without comments or changes >80% of the time, you’re rubber‑stamping.
Skipping Plan mode for “small” tasks that aren’t. Symptom: trivial‑sounding ticket spirals into a 90‑minute mess. Fix: re‑read your skip rule from step 5. If the change doesn’t fit inside it, plan it.
Plan mode without Auto‑Accept on execution. Symptom: feels exhausting, throughput barely improved. Fix: trust the approved plan. If you can’t trust it enough to Auto‑Accept, iterate more in Plan mode — not less in execution.
Assuming Codex CLI has no Plan mode (it does now). Symptom: you fall back to ad‑hoc prompting because you “remember” Codex CLI can’t gate. Fix: hit Shift+Tab or type /plan — Plan mode is enabled by default. Only an old build that predates collaboration modes needs the two‑step prompt workaround from step 6.

How to verify you’re there

Across a full week of agent sessions, >70% of non‑trivial tasks started in Plan mode by default — not as a conscious “this looks scary, plan it” decision.
You iterate inside Plan mode 2–5 times before approving on a typical task; pure first‑draft approvals are rare.
You have an explicit skip rule (size, files, area) written somewhere you can point to — and you follow it.
For Claude Code: /plan or Shift+Tab twice is muscle memory; you’ve used Ctrl+G to edit a plan file at least once.
For Cursor Agents: Plan → Ask → Agent is your default flow for complex tickets in the Agents window.
For Codex CLI: /plan (or Shift+Tab into Plan mode) is muscle memory, and you run with --ask-for-approval on-request (or stricter) so edits still need a tap.
Post‑approval, you drop into Auto‑Accept (or equivalent) and let execution run mostly hands‑off — the plan is the contract.
Wrong‑direction rework — sessions where the agent commits a substantial chunk of edits in a direction you immediately undo — is measurably rarer than it was a month ago.