How I Passed the Claude Certified Architect – Foundations Exam: My Preparation Guide

I built AI systems with Claude for months before I sat the exam. Tool-calling agents, RAG pipelines, multi-agent orchestrators — the code was there. What I didn't have was a structured, validated understanding of the architectural patterns and terminology Anthropic uses to describe these systems. The Claude Certified Architect – Foundations exam gave me that, and the process of preparing for it sharpened my thinking in ways that have already changed how I design systems.

This post is the guide I wish I'd had when I started preparing. It covers the five exam domains with their weights, what actually appears on the test (not just what the syllabus says), my study approach, and the resources that made the biggest difference. Whether you're brand new to the Claude ecosystem or already shipping Claude-powered features in production, this will tell you where to focus.

The 5 Exam Domains

Anthropic · CCA Foundations — Domain Weights

The weights matter. Domain 1 at 27% is not slightly ahead of the others — it is the exam. Everything else is the support act.

Domain 1: Agentic Architecture & Orchestration (27%)

This is where the exam spends the most time and where preparation pays the highest return.

What it tests: The mechanics of how Claude executes multi-step work using tools. Not the concept — the exact sequence of events: how the model decides to call a tool, what the response looks like, how the result gets injected back into the conversation, and how the loop terminates.

The key concept — the tool-use loop:

1. You send a message with available tool definitions
2. Claude responds with stop_reason: "tool_use" + a tool_use content block
3. You execute the tool and get a result
4. You add a "tool_result" message to the conversation
5. You call the API again — Claude continues reasoning
6. Loop repeats until stop_reason: "end_turn"

stop_reason is the primary termination signal. Know its values cold: end_turn (done), tool_use (expects a result), max_tokens (truncated), stop_sequence (custom stop hit).

Multi-agent patterns tested:

• Coordinator/subagent: A top-level orchestrator breaks work into tasks and delegates to specialised subagents. Each subagent has its own context — they don't share conversation history with each other.
• Hub-and-spoke: One coordinator routes to multiple domain-specific agents. The coordinator synthesises results.
• When to use a subagent vs a tool call: If the task needs its own reasoning loop and context — subagent. If it's a deterministic operation (DB query, API call, calculation) — tool call.

Domain 2: Claude Code Configuration & Workflows (20%)

What it tests: How Claude Code is configured and how it behaves in practice — not just what the features are, but when they apply.

Key areas:

CLAUDE.md — the project instruction file. The exam tests: where it lives (repo root, ~/.claude/, .claude/), how multiple files are merged, and what kind of guidance belongs there (architecture conventions, project-specific commands, tool allowlists).

Skills / slash commands — packaged task definitions. Know that a skill is invoked with /skill-name and that the runtime loads its instructions before Claude acts, not as general memory.

Plan mode — Claude outlines an approach before executing. Exam questions test when plan mode is appropriate (large refactors, destructive operations) versus when it adds friction unnecessarily.

CI/CD integration — headless Claude Code in automated pipelines. Know the --print flag for non-interactive output, how to scope permissions in CI, and the difference between a hook and a permission.

Domain 3: Prompt Engineering & Structured Output (20%)

What it tests: Writing prompts that reliably produce consistent, parseable output — not prompt tips, but the engineering discipline of prompt design.

Explicit evaluation criteria: The exam is strong on prompts that tell the model how to judge its own output. "Be concise" is weak. "Respond in under 3 sentences, include a concrete example, and avoid jargon" is testable.

Few-shot examples: Use them when output format is non-trivial or when zero-shot produces inconsistent quality. 3–5 examples is the sweet spot. Include at least one edge-case example.

Structured output and JSON schemas: Know how to instruct Claude to return a specific JSON schema and why you validate the output with a parser rather than trusting it unconditionally. response_format: json_object removes markdown wrapping but doesn't guarantee schema compliance — validation is still required.

Batch processing: For high-volume, asynchronous workloads where latency isn't critical, the Anthropic Batch API offers significant cost savings. The exam tests when to reach for it.

For a deeper treatment of this domain, see Prompt Engineering Best Practices for Enterprise Teams.

Domain 4: Tool Design & MCP Integration (18%)

What it tests: How to design tools Claude will use effectively — the description is the interface, and a vague description produces vague use.

Tool descriptions: The model uses the description to decide whether and when to call a tool. Be specific about what the tool does, what its parameters mean, and what it returns. The exam distinguishes between a useful description and one that's either too vague or too long.

Structured error handling: When a tool fails, return a structured error in the tool_result content block — not a thrown exception. Include enough context for Claude to decide whether to retry, escalate, or use a fallback.

{
  "type": "tool_result",
  "tool_use_id": "...",
  "content": [{ "type": "text", "text": "ERROR: Order ABC not found. Check the order ID and retry." }],
  "is_error": true
}

Model Context Protocol (MCP): MCP is Anthropic's open standard for exposing tools and resources to models. The exam tests: what MCP is, how a client connects to an MCP server, and the difference between MCP tools, resources, and prompts.

Domain 5: Context Management & Reliability (15%)

What it tests: What to do when conversations get long, when tools fail, and when outputs need to be traceable.

Context window management: Claude has a fixed context window. When you approach it in a long-running agent, your options are: summarise earlier turns and replace them, use a sliding window, or split into a new session. Know the trade-offs — summarisation loses detail; splitting loses continuity.

Escalation strategies: When a subagent hits an unresolvable state (tool error, ambiguous instruction, blocked action), it should escalate to the coordinator rather than guess. The exam has scenario questions: given this situation, what should the agent do?

Error propagation: In a multi-agent pipeline, a failure in one subagent should not silently corrupt downstream results. Know how to surface errors across the boundary — structured error responses and provenance tagging.

Provenance: Track which tool result or source document contributed to which part of the output. This is essential for RAG systems (cite your sources) and for debugging complex agent chains.

My Study Approach: 4 Phases

Phase 1 — Read the docs end to end (Week 1)

The Anthropic documentation is the primary source of truth and is genuinely well-written. Read:

• Anthropic Model Spec — understand how Claude reasons and what it prioritises
• API Reference — Messages API, tool use, batch, vision
• Tool use guide — essential for Domain 1 and 4
• Claude Code documentation — covers Domains 2 and 3
• MCP specification — enough for Domain 4

Don't try to memorise — read for understanding. You're building a mental model, not flashcards.

Phase 2 — Build something real (Week 2)

Reading is necessary but not sufficient. Build:

1. A tool-calling agent — even a simple one that calls a weather API or a DB query. Trace through the tool-use loop yourself.
2. A RAG pipeline — retrieve documents, inject as context, get a grounded answer. This covers Domain 5 (context management, provenance, retrieval quality).
3. A CLAUDE.md-driven workflow — configure Claude Code for a project, add a custom skill, and use plan mode on a non-trivial task.

The questions that tripped up people I've spoken to were the ones that required operational intuition — you can't get that from reading alone.

Phase 3 — Practice questions (Week 2–3)

I built CCA practice quiz pages on this site specifically for this purpose:

• CCA Foundations Practice Quiz — covers all 5 domains
• CCA Domain-Specific Quiz — lets you drill each domain individually

Use the domain-specific quiz to identify weak spots. If you score under 75% on a domain, go back to the docs and re-read before continuing.

Phase 4 — Review weak areas and revisit Domain 1 (Final days)

Whatever your quiz results show, always spend your last study session on Domain 1. It is 27% of the exam. A strong Domain 1 score gives you a buffer across the others.

What Surprised Me on the Exam

Domain 1 was more implementation-specific than I expected. Questions didn't just ask "what is an agentic loop?" — they gave you a specific scenario and asked what happens next. Know the exact shape of a tool_use response, what stop_reason values mean, and when a coordinator should and shouldn't pass its full context to a subagent.

Domain 2 (Claude Code) was detailed. Knowing that CLAUDE.md exists wasn't enough — you need to know the merge order of multiple files, what a hook does vs a permission, and how plan mode behaves differently from a standard agentic session.

Domain 5 scenario questions were the toughest. They presented a multi-agent pipeline in a degraded state and asked what the right architectural response was. Practice thinking through: what fails, what gets corrupted, where should the error surface, and what's the recovery path.

No trick questions. The wrong answers were genuinely wrong — they either described the incorrect mechanism, used the wrong pattern for the scenario, or confused two related concepts. If you know the material, the right answer is clear.

Study Timeline

If you're already building with Claude APIs: 2–3 weeks is enough.

If you're new to the Claude ecosystem: Allow 4–6 weeks. Spend extra time in Phase 2 — the hands-on building phase is where the architectural intuition comes from.

Resources That Helped

Top Preparation Tips

FAQ

Is there coding on the exam? No — all questions are multiple choice or scenario-based. You read a situation and select the best architectural response. No IDE required.

How long is the credential valid? The credential renews with re-examination. Check Anthropic's official site for the current renewal period, as this may change as the program matures.

Is the Professional exam significantly harder? Yes. The Professional level expects you to design and evaluate architectural trade-offs, not just identify correct patterns. Think less "which mechanism does this use?" and more "given these constraints, which architecture would you choose and why?". I'm currently preparing for it — Claude Certified Architect – Professional is next on my list.

What's the single best resource? The Anthropic documentation, combined with actually building something. The docs are accurate, comprehensive, and clearly written. Everything else is supplementary.

Can I use Claude to study for the Claude exam? Yes — and it's surprisingly effective. Ask Claude to quiz you, explain concepts back at you, or describe the tool-use loop step by step. Testing your ability to explain a concept to the model exposes gaps in your understanding quickly.

The CCA Foundations exam is a genuine test of architectural understanding — not a trivia quiz. Prepare by building, not just by reading, and allocate your study time in proportion to domain weight. Domain 1 is where the exam is won.

If you want to test your readiness before the real exam, the CCA Foundations practice quiz and domain-specific quiz on this site are the closest preparation resource I know of. They cover all five domains with the same scenario-based question format.

View my Credly badge →

Adopting Claude in your engineering organisation and want help with architecture or team enablement? Let's talk.