The five CCAR-F domains and what each one tests

Here is the whole blueprint, heaviest first, with what each domain actually rewards.

Agentic Architecture & Orchestration · 27%

Sixteen questions, and the heaviest single domain in the entire Claude certification program — heavier than any domain on the Associate, Developer or Professional blueprints. If you prepare for one thing, prepare for this.

Seven sub-objectives, and they are more specific than the domain name suggests: designing agentic loops for autonomous execution; orchestrating coordinator-and-subagent systems; configuring how subagents get spawned and what context they are handed; multi-step workflows with enforcement and handoff points; Agent SDK hooks used to intercept tool calls and normalize data; task decomposition for work too large for one pass; and session state — resumption and forking included.

The recurring judgment is restraint about autonomy and precision about boundaries. Questions rarely ask whether an agent loop is a good idea in the abstract. They hand you a system that is already agentic and ask where the control point belongs: which step gets enforced rather than suggested, what a subagent should be given and what it should return, where a hook belongs versus where a prompt instruction belongs. An answer that keeps everything in one context and hopes the model holds it together tends to lose to one that moves a decision into structure.

Claude Code Configuration & Workflows · 20%

About twelve questions, and this is the domain that most separates the Architect – Foundations exam from the other credentials. It is not a tour of the CLI. It covers CLAUDE.md hierarchy, scoping and modular organization; custom slash commands and skills; path-specific rules that load conventions conditionally; deciding between plan mode and direct execution; iterative refinement as a working technique; and CI/CD integration.

The judgment being tested is where a piece of guidance lives. A convention that applies to one directory does not belong in a repo-wide file; a repeated multi-step procedure does not belong pasted into a prompt each time. Plan mode questions turn on whether the work is reversible and whether the path is known before you start — the same restraint judgment that runs through the agentic domain, applied to a smaller unit of work.

Prompt Engineering & Structured Output · 20%

Another twelve. Six sub-objectives: prompts with explicit criteria that improve precision and cut false positives; few-shot prompting for consistency; enforcing structured output through tool use and JSON schemas; validation, retry and feedback loops for extraction quality; batch processing strategy; and multi-instance or multi-pass review architectures.

The through-line is that output shape is an engineering problem, not a wording problem. When a downstream system consumes the output, the credited answer enforces the contract mechanically — schema-constrained output, validation at the boundary, a retry that feeds the specific failure back in — rather than asking for the format more firmly. Instructions lower an error rate; schemas remove a class of error. Few-shot examples are the right answer for a different problem: output that is correct but the wrong shape, where showing beats telling.

Tool Design & MCP Integration · 18%

About eleven questions. Tool interfaces with clear descriptions and boundaries; structured error responses from MCP tools; distributing tools across agents and configuring tool choice; integrating MCP servers into Claude Code and agent workflows; and choosing correctly among the built-in tools.

Two ideas carry most of this domain. First, a tool description is a prompt — it is the only thing the model reads when deciding whether to call the tool, so vague or overlapping descriptions produce wrong calls that no amount of system-prompt instruction reliably fixes. Second, an error a tool returns is also input to the model. A structured error saying what failed and what would succeed lets the agent recover; a raw stack trace or a bare failure string leaves it guessing, and guessing is what produces the loops the questions describe.

Context Management & Reliability · 15%

About nine questions, the lightest domain, and still too many to skip. It covers preserving critical information across long interactions; escalation and ambiguity resolution; error propagation across multi-agent systems; context management during large codebase exploration; human review workflows and confidence calibration; and provenance and uncertainty when synthesising multiple sources.

The confidence-calibration material is worth deliberate attention because it is where the exam is most willing to reject an intuitive answer. A model's own stated confidence is output, not oversight, so a review workflow gated on self-reported certainty is weaker than one gated on a property you can check. Provenance is the same instinct applied to synthesis: when several sources feed one answer, the credited design keeps track of which claim came from where rather than blending them into prose nobody can audit.

What the weights mean for a study plan

The two heaviest domains, agentic architecture and Claude Code, are 47% of the exam between them. Add prompt engineering and you have 67% in three domains.

But the flatness matters more than the ranking. On most certification blueprints there is a 3% domain you can rationally ignore; here the smallest is 15%. A candidate who is genuinely strong in four domains and blank in the fifth is starting from 85% of the paper and needs almost all of it. Breadth is the cheaper investment on this exam than depth.

One structural warning that no weight table shows: every item on this exam sits inside one of four scenarios, and the scenarios are drawn from a published bank of six. That determines which domains you actually get asked about, because each scenario naturally carries some domains and not others. The six scenarios, and what each one pulls from →

Practice forms should carry the same proportions the exam does, and should group items into scenarios rather than shuffling them. Sixty loose questions train the wrong skill.