How should you route effort inside one Claude Code build (CCA-F D3)?

What changed

Claude Code exposes effort levels, from a fast, shallow pass to a high effort mode that reasons longer before and during the work (🟢 first-hand: Claude Code supports configurable effort, including a fast mode and a high-effort mode for harder tasks). That makes effort a per-build decision, and it makes one-setting-for-everything a mistake in both directions.

A real build is not uniform. It has a hard core (the part that needs judgment) and a lot of routine around it (the part that does not). Running the whole thing on the high effort mode pays for slow, careful reasoning on boilerplate. Running the whole thing fast under-thinks the part that breaks.

One effort level vs. effort routing

How effort routing actually works

Split the build first, then assign effort.

• Find the hard core. The part with real judgment: complex logic, a cross-cutting migration, a security path, a structural or design decision.
• Route high effort there. Let it reason longer where a wrong turn is expensive.
• Route the rest fast. Boilerplate, formatting, simple CRUD, and mechanical edits run on the cheap setting.

Worked example - "build a feature with a tricky core."

1. Plan first and label which parts are hard versus routine (this is a plan mode decision).
2. High effort on the core: the algorithm, the data migration, the interaction design.
3. Fast mode on the shell: routes, layout, imports, scaffolding.
4. Verify the core, because that is where the effort, and the risk, was concentrated.

That is effort routing: slow and careful on the part that can break, fast on the part that cannot.

A name for it: Effort Routing

Effort Routing - assigning effort levels to the parts of a single build: the high effort mode for the hard, judgment-heavy core, the fast mode for routine scaffolding. It is the within-a-build sibling of a thinking-budget policy: same principle (spend depth where it changes the outcome), applied to one job's parts instead of across task classes.

Why it matters for CCA-F

This sits in D3 - Claude Code Configuration and Workflows, which is 20% of the exam, and connects to plan mode, CLAUDE.md hierarchy, and hooks.

The proprietary read: D3 questions reward configuring effort to the part of the job, the operational form of the same right-sizing logic behind model-tier routing and thinking budgets.

• Old instinct: turn the effort up for the whole build to be safe.
• D3 instinct: turn it up for the hard core and leave the routine fast.

The distractor pattern to memorize. On D3 scenarios about a slow or costly Claude Code build, the trap answer is "use the highest effort mode for the whole task." The architecturally correct move is one of:

1. Route high effort to the hard core and fast mode to the routine parts, or
2. Plan the split first so effort follows the judgment, not the line count, or
3. Gate the expensive path (for example with hooks) so high effort runs only where a check says it is the core.

See code generation with Claude Code for a mixed-effort build in practice.

How to apply it

1. Split before you build. Separate the hard core from the routine in plan mode.
2. Default to fast. Start the routine parts on the cheap setting.
3. Escalate the core. Reserve the high effort mode for judgment-heavy work.
4. Put defaults in config. Encode when-to-escalate in your CLAUDE.md so it is consistent.
5. Verify where you spent. Concentrate review on the high-effort core, not the boilerplate.

The meta-skill, and the D3 exam skill, is the same: effort is a dial per part of the build, and the win comes from spending it on the core, not the whole.