Domain 3 · Statement 3.4 4 of 6

Determine when to use plan mode vs direct execution

What you need to know

Reach for plan mode when a wrong approach is expensive to undo — not merely when the task is long.
Direct execution is for simple, well-scoped, already-understood changes such as a single-file fix with a clear stack trace.
Plan mode allows safe exploration and design before any edit, which is how it prevents costly rework.
Explore keeps discovery output out of the main context; only its summary comes back.
The two combine naturally: plan mode for investigation, then direct execution for the agreed implementation.

Plan mode and direct execution are two ways to spend Claude Code's effort, and choosing wrongly is expensive in both directions. The exam gives you a task description and asks which one fits, so read it for signals.

Signal to choice

Signal in the task description	Correct choice	Why
A complex task: large-scale change, multiple valid approaches, architectural decisions, multi-file modifications — microservice restructuring, a library migration affecting 45+ files, integration approaches with different infrastructure requirements	Plan mode	it lets Claude explore the codebase and design a solution before committing to changes, so a bad approach is rejected on paper rather than discovered halfway through a 45-file edit — this is what prevents costly rework³⁸
A simple, well-scoped change whose work is already understood — one validation check added to a function, a date-validation conditional, a single-file bug fix with a clear stack trace	Direct execution	nothing is left to decide, so a plan costs tokens and wall-clock time and settles nothing
An unfamiliar codebase where discovery alone means reading dozens of files	Explore subagent	it isolates the verbose discovery output and returns summaries, preserving the main conversation's context³⁹
A multi-phase task — investigate, then build	Plan mode for investigation, direct execution for implementation	the guide's own combination; the decision is per phase of work, not per task

Why discovery gets its own row

Discovery is the phase that quietly exhausts a context window. Tracing how authentication flows through an unfamiliar service can mean reading dozens of files, and every one of them lands in the main conversation. Delegating that reading is what leaves room for the planning and the implementation that come after it.

Why the combination is not a compromise

Plan mode and direct execution are not exclusive, and the guide says so explicitly. Plan the library migration — inventory the call sites, decide the sequencing, choose the compatibility shim — then execute the agreed approach directly, step by step, without re-planning each file.⁴⁰

The exam's framing: complexity and irreversibility push toward planning; clarity and small blast radius push toward direct execution.

Plan mode or direct execution?

Give the learner a repeatable decision path from a task description to plan mode, direct execution, or the combined plan-then-execute pattern, including where the Explore subagent fits.

one transition at a time

Click a decision node to highlight its outgoing branches and the labels already shown on them.

Worked examples

Library migration across 45+ files: plan first, then execute

Scenario 2 · Code Generation with Claude Code

A team must replace a date library used in 45+ files. There are real decisions: migrate module by module behind a thin adapter, or do a single mechanical sweep; keep the old formatting semantics or adopt the new library's; how to handle the three files that rely on a deprecated parsing quirk.

This is textbook plan mode — multi-file, multiple valid approaches, architectural consequences. Claude explores the call sites, produces a sequenced plan with the adapter decision made explicit, and the team approves or amends it before a single file changes. Only then does the work switch to direct execution, applying the approved plan module by module. Discovering the parsing quirk after 30 files were already converted would have been the costly rework plan mode exists to prevent.

A one-line validation fix does not need a plan

Scenario 2 · Code Generation with Claude Code

A bug report includes a stack trace pointing at parseBookingDate(): an end date before the start date is accepted and blows up downstream. The change is a single conditional in a single function, with an obvious test.

Direct execution. The scope is clear, the blast radius is one function, and there is no design choice to make. Requesting a plan here produces a document nobody needs. The exam likes this pair — the same scenario offers a 45-file migration (plan) and a single validation conditional (direct) to check that you are reading scope, not reaching for the "safer-sounding" option every time.

Explore subagent for the discovery phase of a multi-phase task

Scenario 4 · Developer Productivity with Claude

An engineer must add tenant isolation to a legacy service they have never seen. Phase 1 is discovery: where are requests authenticated, which queries touch tenant-scoped tables, what middleware exists. Reading that inline would fill the context with file dumps and leave no room for phases 2 and 3.

Delegating discovery to the Explore subagent keeps the verbose reading in an isolated context and returns a summary — the list of entry points and the tables involved. The main conversation then plans the change against that summary and implements it with context to spare.

text

Phase 1  Discovery        -> Explore subagent (verbose reads, returns a summary)
Phase 2  Design           -> plan mode (multiple approaches, architectural choice)
Phase 3  Implementation   -> direct execution (apply the approved plan, file by file)

Anti-pattern: doing all three inline in one conversation and running out of
context during phase 3, after the expensive thinking is already done.

Three phases, three tools

Anti-patterns

Using plan mode for a single-file fix with a clear stack trace instead of direct execution because you pay planning overhead for work whose scope was never in question.
Jumping straight to direct execution on a multi-file architectural change instead of planning it because approaches that turn out to be wrong are discovered only after edits exist, forcing costly rework.
Running verbose codebase discovery inline instead of delegating it to the Explore subagent because file dumps exhaust the main context before the implementation phase begins.
Treating plan mode and direct execution as mutually exclusive for a whole task instead of choosing per phase because the natural pattern is planning the investigation and then executing the plan directly.

How it is examined

Count the signals in the stem: number of files, presence of alternative approaches, and architectural or infrastructure consequences. Two or more signals means plan mode.
When the stem gives a clear stack trace and a single function, the correct answer is direct execution — "use plan mode to be safe" is the designed distractor.
Any mention of context exhaustion during exploration of an unfamiliar codebase is an Explore subagent item, not a plan-mode item; watch for options that confuse the two.

References — 3 sources

Choose a permission mode Anthropic What plan mode concretely is: Claude reads files and runs shell commands to explore and writes a plan, but does not edit source, and edits stay blocked until you approve. Also the four ways in — `Shift+Tab`, `/plan`, `--permission-mode plan`, and `defaultMode`.
Create custom subagents Anthropic Explore and Plan documented as built-in subagents, including the consequence the row here does not mention: both skip your CLAUDE.md files and the parent session’s git status to stay fast and cheap.
Best practices for Claude Code Anthropic Anthropic’s own explore → plan → code sequence, which is what "the guide’s own combination" echoes, plus the test-first loop and the interview pattern as workflows performed on Claude Code itself.

All sources verified · Aug 21, 2026

Live product docs — where they differ from the exam guide, answer from the guide. All references

Exam guide, verbatim — what is measured

Knowledge of

Plan mode is designed for complex tasks involving large-scale changes, multiple valid approaches, architectural decisions, and multi-file modifications
Direct execution is appropriate for simple, well-scoped changes (e.g., adding a single validation check to one function)
Plan mode enables safe codebase exploration and design before committing to changes, preventing costly rework
The Explore subagent for isolating verbose discovery output and returning summaries to preserve main conversation context

Skills in

Selecting plan mode for tasks with architectural implications (e.g., microservice restructuring, library migrations affecting 45+ files, choosing between integration approaches with different infrastructure requirements)
Selecting direct execution for well-understood changes with clear scope (e.g., a single-file bug fix with a clear stack trace, adding a date validation conditional)
Using the Explore subagent for verbose discovery phases to prevent context window exhaustion during multi-phase tasks
Combining plan mode for investigation with direct execution for implementation (e.g., planning a library migration, then executing the planned approach)