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

> Do not set one effort level for a whole build. Route maximum effort to the hard, judgment-heavy core and low effort to the routine scaffolding around it. A high effort mode is for the 3D physics or the tricky migration, not for boilerplate CSS. Matching Claude Code effort to the part of the job is a CCA-F D3 configuration skill.

**Published:** 2026-06-07  
**Last reviewed:** 2026-06-07  
**Certification:** CCA-F · Claude Certified Architect - Foundations · D3 Claude Code Configuration & Workflows  
**Tags:** effort-routing, claude-code, ultracode, workflow-config, cost-control, cca-f  
**Canonical:** https://claudearchitectcertification.com/blog/claude-code-effort-routing

![Loop the orange ACP mascot as a workshop foreman routing fine-detail work to a master bench and routine work to quick jigs while building one cabinet, illustrating effort routing.](https://claudearchitectcertification.com/blog/claude-code-effort-routing/hero.webp)

> **Quick answer**
>
> Do not set one effort level for an entire Claude Code build. Route maximum effort to the hard, judgment-heavy core and low effort to the routine scaffolding. The high effort mode is for the tricky migration or the design decision, not for boilerplate. For CCA-F D3, the skill is configuring effort to the part of the job, not the whole job.

## 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

| Dimension | One effort level for the build | Effort routing |
| --- | --- | --- |
| The hard core | Under-thought if fast; fine if high | Gets the high effort mode |
| Routine scaffolding | Overpriced if high; fine if fast | Gets the fast mode |
| Cost and latency | Wrong on most of the build | High cost only where it earns it |
| Where care is visible | Uniform: invisible | Concentrated on the core |
| Config | "Set it and forget it" | Effort mapped to the part of the job |

## 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](https://claudearchitectcertification.com/concepts/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](https://claudearchitectcertification.com/exam-guide), which is 20% of the exam, and connects to [plan mode](https://claudearchitectcertification.com/concepts/plan-mode), [CLAUDE.md hierarchy](https://claudearchitectcertification.com/concepts/claude-md-hierarchy), and [hooks](https://claudearchitectcertification.com/concepts/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](https://claudearchitectcertification.com/concepts/hooks)) so high effort runs only where a check says it is the core.

See [code generation with Claude Code](https://claudearchitectcertification.com/scenarios/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.

## Related pages

- [Plan mode - split hard from routine first](https://claudearchitectcertification.com/concepts/plan-mode)
- [CLAUDE.md hierarchy - encode effort defaults](https://claudearchitectcertification.com/concepts/claude-md-hierarchy)
- [Hooks - gate the expensive path](https://claudearchitectcertification.com/concepts/hooks)
- [Code generation with Claude Code scenario](https://claudearchitectcertification.com/scenarios/code-generation-with-claude-code)
- [CCA-F exam guide (D3 is 20%)](https://claudearchitectcertification.com/exam-guide)

## Frequently asked questions

**Q: What is effort routing in Claude Code?**

Assigning different effort levels to different parts of a single build: a high effort mode for the hard, judgment-heavy core (tricky logic, a migration, design or taste decisions) and a low effort mode for routine scaffolding (boilerplate, formatting, simple CRUD). The build is mixed-effort, not one setting.

**Q: When should you use the highest effort mode?**

On the part of the job where a wrong turn is expensive or where real judgment is needed: complex algorithms, cross-cutting refactors, security-sensitive paths, and structural or design decisions. It is overkill for routine edits and slow, costly formatting.

**Q: Is effort routing the same as a thinking-budget policy?**

They are siblings. A thinking-budget policy decides how much reasoning a class of tasks gets across your work; effort routing applies the same idea inside one build, mixing high and low effort across the parts of a single job. One is strategy, the other is execution config.

**Q: Why not just run the whole build on maximum effort?**

Because the high effort mode is slower and more expensive, and most of a build is routine. Running it everywhere inflates cost and latency for boilerplate that did not need it, while making it harder to see which part actually required care.

**Q: Does the model make design and taste decisions, not just code?**

On hard creative or structural work, the high effort mode is reasoning about trade-offs and structure, not just emitting code. That is exactly the work worth paying for, and exactly the work you should not route to a fast, shallow setting.

**Q: How does this show up on the CCA-F exam (D3)?**

D3 (Claude Code Configuration and Workflows) is 20% of the exam. Expect scenarios about a slow or costly Claude Code build. The trap answer is 'use the highest effort mode for the whole task.' The correct answer is to route high effort to the hard core and low effort to the routine parts.

## Where this fits on the site

- **Plan mode** (concepts): Plan mode is where you decide which parts of a build are hard enough to deserve high effort before you spend it. — https://claudearchitectcertification.com/concepts/plan-mode
- **CLAUDE.md hierarchy** (concepts): Effort defaults and when-to-escalate guidance live in your project config. Routing effort is part of configuring Claude Code, which is D3. — https://claudearchitectcertification.com/concepts/claude-md-hierarchy
- **Hooks** (concepts): Hooks let you gate the expensive path: run the slow, high-effort step only when a check says this part is the hard core. — https://claudearchitectcertification.com/concepts/hooks
- **Code generation with Claude Code** (scenarios): A real build has a hard core and a lot of routine. This scenario is where mixed-effort routing pays off concretely. — https://claudearchitectcertification.com/scenarios/code-generation-with-claude-code
- **CCA-F exam guide** (exam-guide): D3 (Claude Code Configuration and Workflows) is 20% of the exam and rewards configuring effort to the part of the job, not the whole job. — https://claudearchitectcertification.com/exam-guide

---

Cite the canonical HTML page: https://claudearchitectcertification.com/blog/claude-code-effort-routing