Mode de planification ou exécution directe

In Claude Code you constantly make one judgment call: plan first, or execute now?

Plan Mode lets Claude explore, read files, and propose a written plan that you approve before any edits land. Direct execution skips straight to making changes.

The skill isn't picking one forever. It's matching the mode to the size and clarity of the task. Big or ambiguous? Plan. Small and clear? Execute.

Plan Mode gives you four concrete benefits:

• Safe exploration — Claude reads and investigates without touching files.
• Approval gate — you review the proposed plan before edits happen.
• Approach comparison — when multiple solutions exist, you see them laid out.
• Architectural framing — design decisions surface early, not mid-edit.

Use it for large changes, multiple possible approaches, and architectural decisions where a wrong turn is expensive to unwind.

Plan Mode has overhead: you read a plan, you approve it. For trivial work that overhead is pure friction.

Go straight to direct execution when the change is:

• A single-file fix with an obvious edit.
• Driven by a clear stack trace that points at the exact line.
• Small, well-scoped, and low-risk to get wrong.

If you already know the file, the line, and the fix, planning just slows you down.

Reduce it to two questions:

• Is the change big? Many files, new modules, refactors, migrations.
• Is the change ambiguous? Unclear requirements, several valid designs, unknown blast radius.

If either is true, plan first. If both are false — small and clear — execute directly.

This mirrors the exam principle: reserve heavier process for where uncertainty and impact are high; keep light paths light.

Here a stack trace names the file and the cause. There's one correct fix and no design choice. Planning adds nothing.

You'd simply ask Claude to apply the fix, letting it Read the file and make a precise Edit on the unique matching line.

Now contrast a request like "add multi-tenant support to the API." That touches auth, the data layer, routing, and migrations. There are several valid designs and a large blast radius.

This is textbook Plan Mode: let Claude explore the codebase read-only, then propose a plan you approve before a single edit lands.

Planning large changes means reading lots of files, and that discovery output is verbose. Dumping it all into the main context causes lost-in-the-middle attention loss and burns tokens.

Use an Explore subagent to isolate discovery. It investigates and returns a tight summary; the planning context stays clean. Skills can do the same with context: fork to isolate verbose output.

The approval step is the whole point. A plan you can read lets you catch a bad assumption before it becomes 15 edited files.

This is deterministic, human-in-the-loop control. It pairs naturally with the architect mindset: where impact is high, you want a hard checkpoint, not a hope that the model guessed your intent. Prompts are ~90% probabilistic; an approval gate is 100% under your control.

Sometimes you can't tell if a task is small until you look. Don't guess — investigate incrementally, then choose the mode.

The built-in pattern: Grep the entry points, Read the key files, Grep the usages, Read the consumers. If the blast radius turns out large, switch to Plan Mode; if it's one isolated spot, just fix it.

Plan Mode doesn't work alone — it sits inside your Claude Code workflow.

• A shared ./CLAUDE.md (in VCS) gives the plan your standards and conventions up front.
• TDD: have the plan write failing tests first, then implement to green.
• Slash commands / skills in .claude/ can encode a repeatable "plan this feature" flow shared with the team.

The plan becomes the contract; tests prove it was met.

Both extremes cost you:

• Over-planning a one-line, stack-trace-obvious fix wastes time and adds an approval step nobody needed.
• Under-planning a sprawling refactor means edits land before anyone validates the approach — exactly the expensive mistake the approval gate exists to prevent.

Calibrate to size and clarity. When genuinely unsure, lean toward planning for big or ambiguous work, and toward executing for small clear work after a quick look.

Apply the decision heuristic to a realistic request.

Key takeaways:

• Plan Mode for big or ambiguous work: large changes, multiple approaches, architectural decisions, and safe exploration with approval before edits.
• Direct execution for small clear work: single-file fixes and clear stack traces.
• Decision rule: if the change is big OR ambiguous, plan; if small AND clear, execute.
• Investigate incrementally (Grep -> Read -> Grep -> Read) when you can't size it up front, then choose.
• Isolate verbose discovery with an Explore subagent (or a skill with context: fork) to protect the planning context.
• The approval gate is deterministic human control — don't trade it away on high-impact changes.