Plan Mode vs Direct Execution

Official Exam Guide Objectives

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)

What You Need to Know

Claude Code offers two ways into a task: plan first, or start changing things. The exam asks you to choose between them on the evidence in the scenario, and the criteria are firm enough that it is not a judgement call about personal style.

Plan Mode: When to Use It

Plan mode buys you exploration and design before anything is written to disk. Reach for it when:

• Large-scale changes are involved. Splitting a monolith, reorganising how modules relate, or replacing a core abstraction all depend on understanding what exists before touching it.
• Multiple valid approaches exist. Where several designs would work and differ in what they demand of the infrastructure, choosing between them is itself the task.
• Architectural decisions are required. Service boundaries, dependency direction, API contracts — decisions that later work is built on top of, so getting them wrong is expensive to unwind.
• Multi-file modifications are needed. A migration touching 45+ files needs one strategy applied uniformly; without it the first ten files and the last ten diverge.
• Codebase exploration is necessary. Where dependencies, data flow or existing structure have to be established before a change can be designed sensibly.

Throughout, nothing is modified. Claude reads, traces dependencies and proposes — which is what makes exploration safe enough to do thoroughly.

Direct Execution: When to Use It

Direct execution goes straight to the change. Reach for it when:

• The change is well-scoped. A bug with a stack trace pointing at one function. A date validation to add. A configuration value to update.
• The correct approach is already known. The what, the where and the how are all settled, and no design decision remains.
• The scope is limited. One function, one file, one modification whose consequences are contained.

There is nothing to plan in these cases, so planning is pure overhead — a phase that produces a document nobody needed before making the change everyone already agreed on.

The Explore Subagent

Discovery is verbose. Mapping a codebase produces file listings, dependency graphs, excerpts and working notes, and all of it is valuable for about as long as it takes to reach a conclusion. Left in the main conversation, it occupies the context that implementation is going to need.

The Explore subagent:

1. Runs the exploration in isolation
2. Produces summaries of its findings
3. Returns those summaries to the main conversation
4. Keeps the main context window clean for the actual implementation work

The pattern fits any multi-phase task where discovery is noisy and the phase after it needs room to think.

The Hybrid Approach: Plan Then Execute

Most substantial work uses both, in sequence, and the exam tests whether you recognise it:

1. Plan phase: Use plan mode to explore the codebase, understand dependencies, evaluate approaches, and design the implementation strategy.
2. Execute phase: Switch to direct execution to implement the planned approach, file by file, with the strategy already decided.

Take swapping one logging library for another across 30 files:

• Plan: find every file importing the old library, work out where the two APIs differ, settle on the shape of the migration, and identify the calls that will not translate cleanly.
• Execute: apply that shape file by file, with no decisions left to make.

The point is the ordering. Options offering plan mode or direct execution as alternatives are missing the pattern — for work like this the answer uses both, in that order.

Decision Framework Summary

Recognising Complexity Upfront

One trap recurs: beginning in direct execution and reaching for plan mode once the work turns out to be complicated. Where the requirement already announces the complexity — "restructure the monolith into microservices" leaves nothing to discover about scale — the decision was available before any file was opened. Switching later means the exploration happens after some changes have already landed, which is the expensive order to do it in.

Deep Dive

Three ways to enter plan mode

Plan mode is entered by pressing Shift+Tab, by prefixing a single prompt with /plan, or by starting the CLI directly in plan mode with claude --permission-mode plan. Shift+Tab actually cycles through all enabled permission modes — default (labelled "Manual" in the mode indicator), acceptEdits, plan, and any optional modes you've enabled such as auto or bypassPermissions. While plan mode is active, the status bar shows a ⏸ plan mode on indicator.

Sourcecode.claude.com › permission-modesfetched 2026-07-30

What plan mode actually restricts

Plan mode has Claude research and propose changes without making them: it reads files and runs read-only shell commands to explore, then writes a plan — but does not edit source. Except in sessions where bypass permissions is available, edits stay blocked until the plan is approved.

Sourcecode.claude.com › permission-modesfetched 2026-07-30

The approval flow

Once the plan is ready, Claude offers a choice: "Yes, and use auto mode" approves and starts in auto mode (reading as "Yes, auto-accept edits" when auto mode isn't available); "Yes, manually approve edits" approves but reviews each edit individually; "No, keep planning" stays in plan mode so you can redirect Claude; and on Claude Code on the web there is a fourth option to refine the plan with Ultraplan. Approving a plan exits plan mode and switches the session to whichever permission mode the chosen option describes. You can also press Ctrl+G to open the proposed plan directly in your text editor before Claude proceeds, or press Shift+Tab again to leave plan mode without approving anything.

Sourcecode.claude.com › permission-modesfetched 2026-07-30

Permission modes compared

defaultMode: "plan" under permissions in .claude/settings.json makes plan mode the project default.

Sourcecode.claude.com › permission-modesfetched 2026-07-30

The Explore subagent, precisely

Explore is a built-in, fast, read-only agent optimised for searching and analysing codebases; Write and Edit are explicitly denied to it. Claude invokes it with a thoroughness level — quick, medium, or very thorough — matching the scope of the discovery task. Explore (and the built-in Plan subagent) skip your CLAUDE.md files and the parent session's git status entirely, to keep research fast and inexpensive; every other built-in and custom subagent loads both.

Sourcecode.claude.com › sub-agentsfetched 2026-07-30

Why plan mode exists: separating exploration from execution

Letting Claude jump straight to coding can produce code that solves the wrong problem — the documented rationale for plan mode is to separate exploration from execution. Planning is most useful when you're uncertain about the approach, the change touches multiple files, or you're unfamiliar with the code being modified; if you could describe the diff in one sentence, skip the plan. The recommended four-phase workflow is Explore → Plan → Implement → Commit.

Sourcecode.claude.com › best-practicesfetched 2026-07-30

Quick Reference

Exam Traps

Practice Scenario

Build Exercise

Practice Plan Mode vs Direct Execution Decision-Making

Difficulty: Intermediate (2/4)

45 minutes

1. Identify a complex multi-file task in a codebase (refactoring, migration, or restructuring) and use plan mode to explore dependencies and design an approach

Why: Plan mode is for tasks with multiple valid approaches, architectural decisions, or multi-file modifications. The exam tests whether you choose plan mode upfront when complexity is stated in the requirements rather than waiting for surprises.

You should see: Claude Code explores the codebase without modifying any files. The output includes: identified dependencies between modules, multiple possible approaches with tradeoffs, and a recommended implementation strategy. No files are changed during the planning phase.

2. Identify a simple single-file bug and use direct execution to fix it — observe the efficiency gain over planning

Why: Direct execution is correct when the problem, location, and solution are all clear. The exam tests that you do not over-plan well-understood changes. The decision is about ambiguity, not difficulty.

You should see: Claude Code makes the fix immediately without a planning phase. The change is confined to a single file or function. The total time from prompt to fix is noticeably shorter than the plan mode task above.

3. Use the hybrid approach: plan mode to design a migration strategy for a library change across multiple files, then switch to direct execution to implement the plan

Why: The plan-then-execute hybrid is a specific pattern tested on the exam. Plan mode designs the strategy; direct execution applies it consistently. This is the correct approach for tasks like library migrations affecting many files.

You should see: Phase 1 (plan): Claude identifies all files importing the old library, maps API differences, and produces a migration pattern. Phase 2 (execute): Claude applies the migration pattern file by file using the planned approach. The implementation is consistent across all files.

4. Use the Explore subagent for a verbose codebase discovery task and observe how it keeps the main conversation context clean

Why: The Explore subagent isolates verbose discovery output so the main conversation context stays focused. Without isolation, extensive file listings and analysis fill the context window and degrade subsequent responses.

You should see: The Explore subagent runs the discovery task and returns a concise summary to the main conversation. The full verbose output (file listings, dependency graphs, code excerpts) is not visible in the main conversation. Subsequent responses in the main conversation remain high quality.

5. Create a written decision framework: list your criteria for choosing plan mode vs direct execution, with examples for each

Why: Internalising the decision criteria is essential for the exam. The framework should cover the key distinction: ambiguity determines the mode, not difficulty. A difficult but well-defined fix is direct execution; a simple-sounding feature with multiple approaches is plan mode.

You should see: A clear decision framework with at least four criteria for plan mode and three for direct execution. Each criterion has a concrete example. The framework explicitly addresses the ambiguity-vs-difficulty distinction.

Sources

• Claude Code Plan Mode Documentation — Anthropic
• Claude Code Permission Modes Documentation — Anthropic
• Claude Code Subagents Documentation (Explore subagent characteristics) — Anthropic
• Claude Code Best Practices — Anthropic
• Claude Certified Architect Foundations Exam Guide — Task Statement 3.4 — Anthropic
• Claude Certified Architect Foundations Exam Guide — Sample Question 5 — Anthropic

Appendix A — Build Exercise Step Hints

Progressive hints revealed by the "Stuck? Get a nudge" control on each step.

Step 1. Identify a complex multi-file task in a codebase (refactoring, migration, or restructuring) and use plan mode to explore dependencies and design an approach

Why: Plan mode is for tasks with multiple valid approaches, architectural decisions, or multi-file modifications. The exam tests whether you choose plan mode upfront when complexity is stated in the requirements rather than waiting for surprises.

You should see: Claude Code explores the codebase without modifying any files. The output includes: identified dependencies between modules, multiple possible approaches with tradeoffs, and a recommended implementation strategy. No files are changed during the planning phase.

Start with: "In plan mode, analyse the authentication module. Map all files importing from auth/, identify the dependency chain, and propose two approaches for extracting it into a standalone service. Do not modify any files."
Expected output: a dependency map and two or more approaches with tradeoffs.

Step 2. Identify a simple single-file bug and use direct execution to fix it — observe the efficiency gain over planning

Why: Direct execution is correct when the problem, location, and solution are all clear. The exam tests that you do not over-plan well-understood changes. The decision is about ambiguity, not difficulty.

You should see: Claude Code makes the fix immediately without a planning phase. The change is confined to a single file or function. The total time from prompt to fix is noticeably shorter than the plan mode task above.

Try: "Fix the null pointer exception in src/utils/format.ts line 42 — the user object may be undefined when called from the unauthenticated route."
Claude should fix the single function immediately without exploring the broader codebase.

Step 3. Use the hybrid approach: plan mode to design a migration strategy for a library change across multiple files, then switch to direct execution to implement the plan

Why: The plan-then-execute hybrid is a specific pattern tested on the exam. Plan mode designs the strategy; direct execution applies it consistently. This is the correct approach for tasks like library migrations affecting many files.

You should see: Phase 1 (plan): Claude identifies all files importing the old library, maps API differences, and produces a migration pattern. Phase 2 (execute): Claude applies the migration pattern file by file using the planned approach. The implementation is consistent across all files.

Phase 1: "Plan a migration from moment.js to date-fns. Identify all files importing moment, map the API differences for each usage pattern, and design the migration approach. Do not modify files yet."
Phase 2: "Now execute the migration plan. Apply the date-fns replacements to each file using the patterns you identified."

Step 4. Use the Explore subagent for a verbose codebase discovery task and observe how it keeps the main conversation context clean

Why: The Explore subagent isolates verbose discovery output so the main conversation context stays focused. Without isolation, extensive file listings and analysis fill the context window and degrade subsequent responses.

You should see: The Explore subagent runs the discovery task and returns a concise summary to the main conversation. The full verbose output (file listings, dependency graphs, code excerpts) is not visible in the main conversation. Subsequent responses in the main conversation remain high quality.

Ask: "Use the Explore subagent to map the entire src/api/ module: list all files, trace the dependency graph, identify patterns and anti-patterns, and summarise the findings."
The main conversation should show a summary, not pages of file listings.

Step 5. Create a written decision framework: list your criteria for choosing plan mode vs direct execution, with examples for each

Why: Internalising the decision criteria is essential for the exam. The framework should cover the key distinction: ambiguity determines the mode, not difficulty. A difficult but well-defined fix is direct execution; a simple-sounding feature with multiple approaches is plan mode.

You should see: A clear decision framework with at least four criteria for plan mode and three for direct execution. Each criterion has a concrete example. The framework explicitly addresses the ambiguity-vs-difficulty distinction.

Your framework should include entries like:

Plan Mode When:
- Multiple valid approaches exist (e.g., monolith to microservices — where do service boundaries go?)
- Multi-file modifications needed (e.g., library migration across 30+ files)
- Codebase exploration required (e.g., understanding dependency chains before refactoring)

Direct Execution When:
- Clear stack trace points to a single function (e.g., null pointer at line 42)
- Known fix, known location (e.g., update a config value)
- Limited scope, no design decisions (e.g., add a validation check)

Appendix B — Interactive Study Prompts

Two prompts to paste into Claude. B1 drills the judgement the exam actually measures; B3 reviews the work you produced for the Build Exercise above. The exam simulator between them is the interactive quiz on this page.

B1. Concept Check — Discrimination Drill

B2. Exam Simulator

B3. Build Coach — Workflow Review

The Build Exercise and its hint ladder are already on this page. This prompt is for the one thing the page cannot do: review the work you actually produced.