Plan mode vs direct execution: CCAR-F task statement 3.4

CCAR-F · Claude Code Configuration & Workflows (20% of the exam)

Task statement 3.4 sits in Claude Code Configuration & Workflows, 20% of the CCAR-F exam. It tests one judgement: does this task need exploration and a design before any edit, or is the scope clear enough for Claude to make the change directly?

What the official guide covers

The Claude Certified Architect Foundations exam guide (version 1.0, effective July 2026) lists this under task statement 3.4, "Determine when to use plan mode vs direct execution":

Knowledge of	Skills in
Plan mode is for complex work: large-scale changes, several valid approaches, architectural decisions, edits across many files	Choosing plan mode for work with architectural impact, such as restructuring services, a library migration touching dozens of files, or picking between integrations with different infrastructure
Direct execution suits simple, well-scoped changes, such as one validation check in one function	Choosing direct execution for clear changes, such as a single-file bug fix with a stack trace
Plan mode lets Claude explore the code and design safely before committing to changes, which avoids rework	Using the Explore subagent for verbose discovery so the context window does not run out during multi-phase tasks
The Explore subagent isolates verbose discovery output and returns a summary	Planning an approach in plan mode, then implementing it with direct execution

What plan mode does

Plan mode is a permission mode. Claude reads files, runs shell commands to explore, and writes a plan, but it does not edit your source. Edits stay blocked until you approve the plan (the exception is an interactive session started with bypass permissions available).

Ways to enter it:

Press Shift+Tab to cycle modes until the status bar shows plan mode.
Start a single prompt with /plan.
Start the session in it: claude --permission-mode plan.
Make it the project default in .claude/settings.json:

{
  "permissions": {
    "defaultMode": "plan"
  }
}

When the plan is ready, Claude asks how to proceed. You can approve and let Claude edit (in auto mode, or with auto-accepted edits where auto mode is not available), approve and review each edit yourself, or choose "No, keep planning" and say what to change. Press Ctrl+G to open the plan in your text editor and change it before Claude starts. Approving exits plan mode and Claude begins editing in the same session. That is the "plan, then execute" pattern the guide describes: no new session and no copy and paste.

While it plans, Claude can hand codebase research to the built-in Plan subagent, so exploration output stays in a separate context window.

What the Explore subagent does

Explore is a built-in subagent for searching and analysing a codebase. It is read-only: Write and Edit are denied. It runs in its own context window, reads as many files as it needs, and returns its findings to the main conversation. The file contents it read stay in its context, not yours. Claude picks a thoroughness level when it calls Explore: quick, medium or very thorough.

Use it whenever discovery would flood the main session: tracing every caller of a function, mapping imports before a migration, or reading a legacy module you do not know. You can ask for it in plain words, for example "use subagents to investigate how token refresh works".

What Explore and Plan do not read

To stay fast, the built-in Explore and Plan subagents skip your CLAUDE.md files and the git status snapshot. Your project rules are not in their context while they research. Most of the time that is fine, because they only read. If the research itself must respect a project rule (for example "ignore everything under vendor/"), put the rule in the request, or hand it to a custom subagent or the general-purpose one, both of which load CLAUDE.md.

A worked session: plan the migration, then execute it

$ claude --permission-mode plan

> We are replacing moment.js with date-fns across the web app.
  Use the Explore subagent to find every import of moment, including
  through wrapper modules, and group the call sites by the functions used.
  Then propose a migration plan: the order of changes, behaviour that
  differs between the libraries, and how we test each step.

  (Claude explores, writes the plan and asks how to proceed.)
  Choose "No, keep planning": "Migrate the date formatting helpers first."
  Press Ctrl+G, remove a step you do not want, save.
  Approve with "Yes, manually approve edits".

> Implement step 1 of the plan. Run the unit tests after each file.

The discovery output stays in Explore's context. The main session holds the plan, which is short, and has room for the implementation.

Before you approve a high-risk plan

Read the plan in full; do not skim it. Changing a step now costs a sentence, and changing it after twenty edits costs a cleanup. For a migration or other large change to unfamiliar code, answer three questions before you approve:

Blast radius. What relies on the code you are changing, and what fails further along if an edit goes wrong? Check that the plan names every file it will touch and nothing you did not expect.
Audit. How will you see what the agent touched? A PostToolUse hook that logs each tool call gives reviewers a record.
Approval per phase. Who signs off before the next phase starts? Plan mode separates exploring from editing, but you decide and write down who approves each step.

Approving a plan sets the permission mode for every step that follows. If one step writes a file that is hard to undo, such as a deployment config several production services read, approve with "Yes, manually approve edits" or add an ask permission rule for that path (deny if Claude must never write it). A person then sees that one write before it runs, instead of reading it in a pull request after it has landed.

If a direct change goes wrong

Every prompt you send creates a checkpoint. Press Esc twice on an empty prompt, or run /rewind, and pick the point to go back to. You can restore the code and the conversation together, only the conversation, or only the code. That makes direct execution cheap to try on a small change: if Claude heads the wrong way, rewind and re-prompt instead of arguing it back.

Two limits matter. Checkpoints track edits made with Claude's file editing tools, not files changed by shell commands such as rm or mv. And they are not version control: commit before any large change.

Plan or execute directly?

Anthropic's own guidance for Claude Code is short: if you could describe the diff in one sentence, skip the plan. Plan when you are unsure of the approach, when the change touches many files, or when you do not know the code.

Task	Choose	Why
Fix a null check; the stack trace points to one line in one file	Direct execution	Scope and cause are known; a plan adds overhead
Add a date validation check to one form handler	Direct execution	The diff fits in one sentence
Replace a logging library imported in 50 files	Plan mode, then execute the approved plan	One approach must be chosen and applied the same way everywhere
Choose between webhooks and a message queue that need different infrastructure	Plan mode	Several valid approaches with different costs
Split a module into separate services	Plan mode	Decisions about boundaries and dependencies come first
Understand a large unfamiliar subsystem before any change	Explore subagent	Discovery output stays out of the main context

Rules that decide exam answers

Complexity stated up front means plan first. If the task already says many files, several approaches or architectural choices, do not start directly and switch to plan mode later.
Clear and small means direct. One file, a known cause, a one-sentence diff: plan mode only adds steps.
Plan, then execute, in one flow. Approving the plan switches Claude to editing. Combining the two is a valid answer, not a compromise.
Verbose discovery goes to Explore. When the symptom is a full context window or forgotten findings during exploration, the fix is a subagent with its own context, not a longer prompt.
Plan mode is the safe way to explore. Source edits are blocked until you approve, so Claude can investigate unfamiliar code without changing it.
Explore and Plan do not see CLAUDE.md. If a project rule must shape the research, state it in the request or use a subagent that loads CLAUDE.md.

Where it appears in the exam

Claude Code Configuration & Workflows is a primary domain in three of the six exam scenarios: Code Generation with Claude Code, Developer Productivity with Claude, and Claude Code for Continuous Integration. The Code Generation scenario names the plan mode decision directly.

Two sample questions

These are original Timo practice questions. They are not official exam questions.

Question 1

A developer receives a bug report with a stack trace. It points to parseInvoiceDate() in one file, which throws when it receives an empty string. The fix is a guard clause and one new test. Which approach fits best?

A. Enter plan mode, have Claude survey every caller of parseInvoiceDate(), then approve a plan.B. Ask Claude to make the fix directly, add the test and run the existing test file.C. Ask the Explore subagent for a very thorough map of the invoicing module first.D. Have Claude interview you, write a spec to a file, then implement it in a fresh session.

Answer: B. The scope is one file and the cause is known, so direct execution with a test is the proportionate choice. A and C add exploration the task does not need. D is for larger features with open design questions.

Question 2

A team is moving from one HTTP client library to another. The old library is imported in about 70 files, some through wrapper modules. On the first attempt, Claude read files in the main session for an hour; the context filled and it began forgetting earlier findings before it made any change. What should the team do on the second attempt?

A. Stay in direct execution and ask Claude to migrate each file as soon as it finds one.B. Paste the list of 70 files into the prompt and ask Claude to change them all at once.C. Repeat the same approach with a model that has a larger context window.D. Start in plan mode, have the Explore subagent map the imports and wrappers, then approve a plan and execute it.

Answer: D. Plan mode separates design from edits, and Explore keeps the verbose discovery in its own context so the main session holds only the summary and the plan. A risks inconsistent changes and rework. B skips the discovery of the wrapper modules. C delays the same problem; discovery output still fills the main context.

Build exercise

In a repository you know, ask Claude to make a one-line fix directly. Note how long it takes and how many steps Claude shows.
Start claude --permission-mode plan and ask for a plan to replace a library used in many files. Press Ctrl+G, change one step, then approve with manual edit review.
In the same kind of task, ask Claude to use the Explore subagent for discovery. Run /context before and after and compare it with a run where Claude reads the files in the main session.
Ask for a feature with two valid designs. Have the plan compare them, choose one with "No, keep planning", then approve and let Claude implement it.

Practise this topic

Claude Certified Architect practice exam: free, 20 questions, no sign-up
Claude Certified Architect hub
CCAR-F study guide: all topics
Previous topic: 3.3 Path-specific rules
Next topic: 3.5 Iterative refinement

Sources

Claude Certified Architect Foundations Exam Guide, version 1.0, effective July 2026 (Anthropic), task statement 3.4
Claude Code documentation: Choose a permission mode
Claude Code documentation: Create custom subagents
Claude Code documentation: Best practices for Claude Code
Claude Code documentation: Checkpointing