An independent, unofficial study guide to the Claude Certified Architect – Foundations exam (CCAR-F): the agentic loop, tools and MCP, Claude Code, prompt engineering, and context management — mapped to the exam blueprint and run against a stated package matrix.
Download as an EPUB 16 chapters — read offline on any e-reader
What the Claude Certified Architect – Foundations exam (CCAR-F) actually measures — the five weighted domains, the scenario format, the 720-to-pass bar — and how this book maps to the blueprint, built and verified against a stated, dated package matrix rather than a single pin.
What an agent really is — a model in a loop with tools — and what drives each turn and ends it: stop_reason and the full set of stop reasons, the Agent SDK's autonomous loop and its ResultMessage subtypes, model-driven control, and the three loop-termination anti-patterns to recognize on sight.
Design a delegation before configuring an agent: divide a warehouse migration decision into owned tasks, pass context explicitly, then use the Agent SDK to bound, monitor, and recover the work.
The control plane around the agent loop: enforcing multi-step workflows with clean handoff, intercepting tool calls with Agent SDK hooks (PreToolUse/PostToolUse and their decisions), and persisting session state so a run can resume and fork.
A tool is the only thing the model sees of your code — its name, schema, and description. Designing that interface so the model selects the right tool, splitting overlapping tools, and returning structured errors (categories, retryable flags, the empty-result-vs-failure distinction) so the agent can recover intelligently.
Why an agent's tool access is a design decision, not an afterthought — scoping tools so selection stays reliable, the four tool_choice modes and parallel tool use, wiring MCP servers at the right scope with env-var secrets, tool namespacing, and combining the built-in tools.
What CLAUDE.md is and why Claude Code layers it into a hierarchy — the managed, user, project, and local levels, why user-level config never reaches your team, bare @path imports and .claude/rules/ for modular organization, glob-scoped rules that load only for the files they apply to, and the settings.json precedence chain underneath all of it.
The two ways to package a workflow so you never spell it out twice — a single-file slash command versus a skill directory with progressive disclosure, the frontmatter both share (context: fork, allowed-tools, argument-hint, and the two invocation booleans), and the refinement techniques that steer Claude from a first attempt to the output you actually want.
Making Claude think before it acts, and running it where nobody is at the keyboard: what plan mode is and what it does not guarantee, the CLI flags that keep a headless run honest rather than merely quiet, the GitHub Action's two modes, and why an automated reviewer is an untrusted-input problem.
How to make a model produce trustworthy, consistent output instead of noise: why specific categorical criteria beat vague instructions (and why 'be conservative' does nothing), how one noisy category poisons trust in the accurate ones, and how a few worked examples teach the model to generalize its judgment to cases you never showed it.
Getting output a downstream system can consume without a fragile parser, then checking it's actually right: why free-form text breaks pipelines, how tool use with a JSON schema guarantees the shape, why a strict schema fixes syntax but never semantics, and the retry loop — plus knowing when a retry can't possibly help.
Two ways to match an architecture to a workload: what batch processing is for and the trade-offs that decide when it fits (cheaper, up to 24 hours, no tool loop), and why an independent reviewer and per-file/cross-file passes catch what a single self-review misses.
What an agent's context actually is, why it degrades over a long interaction, and the techniques that keep the facts that matter from being lost — the case-facts block, trimmed tool outputs, front-loaded findings, and the scratchpads, subagents, /compact, and crash-recovery manifests that carry a long codebase exploration.
How an agent should behave when it can't just proceed — handing off to a human on the right signals (and why sentiment and self-reported confidence aren't among them), asking for clarification instead of guessing, and propagating structured errors through a multi-agent system without either suppressing them or collapsing the whole workflow.
How you earn the right to trust an automated system — why an aggregate accuracy number hides per-segment failures, how stratified sampling and calibrated field-level confidence route review where the risk is, and how claim-source mappings, conflict annotations, and dates keep a multi-source synthesis honest.
The capstone: the exam draws four of six production scenarios, and the questions hang off them. For each scenario, the domains it pulls from, the design decisions that matter, and the anti-patterns the items will offer as traps — the whole series, applied the way the exam applies it.