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 very different implementations across the three Tier 1 tools — Claude Code, Cursor Agents, and Codex — and one of them (Codex CLI) doesn’t have a native planning gate at all. 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 the agent confuses itself about the mode state (issue #21292); 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.

Cursor Agent Modes

Cursor’s Plan mode lives inside the Agents window (Cursor 3.0+, shipped April 2, 2026). 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 since 3.0 each agent tab holds its own mode, model, and worktree, so you can park a Plan‑mode Opus 4.7 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 (web only) and CLI workarounds

This is the gotcha. Codex’s /plan-mode (or /plan [description] per OpenAI’s April 2026 docs) exists only in the Codex web app — the ChatGPT‑hosted Codex surface. Codex CLI does not have a native planning gate. No Shift+Tab cycle, no /plan slash command, no ExitPlanMode tool prompt. If you use Codex CLI as your primary or secondary tool, you need a workaround to score max points on Q6. The standard pattern in 2026 is a two‑step prompt: first prompt asks Codex to “produce a detailed implementation plan only — do not write or edit any files,” wait for the plan, iterate by prompting changes, and only when the plan is right do you prompt “now execute this plan.” Pair this with --ask-for-approval on-request (or untrusted) so file edits and shell commands still require explicit approval — that’s your gate. A second pattern is to plan in Codex web (where /plan-mode is native), then hand the approved plan to Codex CLI for execution. Both work; both score max points on Q6 because the planning gate is enforced, even if the enforcement is in your prompt scaffolding rather than the tool. Don’t pretend Codex CLI has Plan mode — it doesn’t — but don’t let that excuse skipping planning.

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.
Handle Codex CLI explicitly if you use it. If Codex CLI is in your toolbelt, add the two‑step plan prompt to your shell aliases or a wrapper script. Run Codex with --ask-for-approval on-request (or stricter) so file edits require a tap, and document the workaround in your AGENTS.md so the agent itself knows the convention. Don’t try to use Plan mode in Codex CLI — it doesn’t exist — 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.
Forgetting Codex CLI has no native Plan mode. Symptom: you hit Shift+Tab expecting a mode switch, get nothing, silently default to edit‑mode. Fix: use the two‑step prompt workaround from step 6, or plan in Codex web (/plan-mode) and execute in Codex CLI.

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: you have a documented two‑step plan workaround and run with --ask-for-approval on-request (or stricter).
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.