The CCA Exam — Domains, Scenarios, and Strategy

Anthropic does not publish a certification exam for people who can read documentation. They publish one for people who have built systems that break in production and know why.

The Claude Certified Architect — Foundations exam is the first official credential for practitioners building production applications with Claude. It is not a knowledge check. It is a judgment test. Every question is anchored to a realistic scenario — a customer support agent that needs to escalate, a CI/CD pipeline that generates false positives, a multi-agent research system where subagents need isolated context. The exam asks what you would do in production, not what the docs say in theory.

If you have been following this academy from the beginning, you have already built most of what this exam tests. But there are gaps, and this track exists to close them systematically.

The Exam Format

Sixty questions. Multiple choice. One correct answer per question. Four scenarios selected at random from a pool of six. Scaled scoring from 100 to 1000, with 720 as the passing threshold. Unanswered questions count as incorrect — there is no penalty for guessing, so answer everything.

The scenario-based format is the key differentiator. You are not answering abstract questions about API parameters. You are dropped into a production context — "you are building a customer support agent with these tools and this target resolution rate" — and asked to make architectural decisions within that context. The distractors are designed to look reasonable to someone with surface-level knowledge. The correct answer is the one that reflects how these systems actually behave in production.

The Five Domains

Domain 1: Agentic Architecture & Orchestration (27%). This is the single largest domain. It covers the agentic loop lifecycle, multi-agent coordination, subagent spawning, hooks, task decomposition, and session management. If you cannot explain what stop_reason: "tool_use" means versus stop_reason: "end_turn", you will lose points on more than a quarter of the exam. This domain is tested across four of the six scenarios.

Domain 2: Tool Design & MCP Integration (18%). How you design tool interfaces, write tool descriptions that prevent misrouting, implement structured error responses, distribute tools across agents, and build MCP servers with proper resource and prompt exposure. The exam tests whether you understand that giving an agent 18 tools degrades selection reliability, and that tool descriptions are the primary mechanism LLMs use for tool selection.

Domain 3: Claude Code Configuration & Workflows (20%). CLAUDE.md hierarchy and configuration layering. Slash commands and Agent Skills. MCP server integration within Claude Code. Plan mode versus direct execution. Permission modes — allowedTools restrictions, --dangerously-skip-permissions. CI/CD integration patterns. This domain is where teams that use Claude Code daily have an advantage.

Domain 4: Prompt Engineering & Structured Output (20%). System prompts, few-shot examples, chain-of-thought, prefilling, JSON mode enforcement, extraction patterns, and temperature/parameter tuning. This is not "write a good prompt" — it is "design a prompt architecture that produces reliable structured output in production with validation and fallback."

Domain 5: Context Management & Reliability (15%). Context window optimization, summarization strategies, multi-turn conversation management, error handling, self-evaluation, human-in-the-loop escalation, and monitoring. The smallest domain by weight, but it appears in four of six scenarios because every production system has context and reliability constraints.

The Six Scenarios

Every exam question is framed within one of these six production scenarios. You will see four of them on your exam, selected at random. This means you cannot skip any scenario in your preparation — you do not know which four you will get.

Scenario 1: Customer Support Resolution Agent. An Agent SDK build with MCP tools for customer data, order lookup, refund processing, and human escalation. Target: 80%+ first-contact resolution. Tests D1, D2, D5. The exam will ask about prerequisite enforcement (verify customer before processing refund), structured error handling, and escalation handoff protocols.

Scenario 2: Code Generation with Claude Code. Using Claude Code for development workflows — slash commands, CLAUDE.md configuration, plan mode decisions. Tests D3, D5. Expect questions about when to use plan mode versus direct execution, how CLAUDE.md files layer across project/user/enterprise scopes, and permission model tradeoffs.

Scenario 3: Multi-Agent Research System. Coordinator agent with specialized subagents for web search, document analysis, synthesis, and report generation. Tests D1, D2, D5. This scenario tests whether you understand that subagents do not inherit coordinator context, that the coordinator manages all inter-agent communication, and that parallel subagent spawning requires multiple Task tool calls in a single turn.

Scenario 4: Developer Productivity Tools. Agent SDK build for codebase exploration with built-in tools (Read, Write, Bash, Grep, Glob) plus MCP integrations. Tests D2, D3, D1. Expect questions about tool distribution, when to use built-in tools versus custom MCP tools, and how to scope tool access per agent role.

Scenario 5: CI/CD Pipeline Integration. Claude Code in automated pipelines for code review, test generation, and PR feedback. Tests D3, D4. This scenario focuses on prompt design for actionable feedback, minimizing false positives, and headless operation with --print and --output-format.

Scenario 6: Structured Data Extraction. Extracting structured data from unstructured documents with JSON schema validation. Tests D4, D5. Expect questions about schema design, few-shot examples for extraction accuracy, confidence scores, and handling edge cases gracefully.

What This Academy Already Covers

If you have completed the academy up through the Agent Trust track, you already have strong coverage of D1 (multi-agent architecture, agentic loops, orchestration) and D4 (prompt engineering mastery). The Claude Code Basics and Advanced Claude Code tracks give you solid D3 coverage.

The gaps are in the specifics. The CCA exam tests precise knowledge of the Agent SDK API — stop_reason values, allowedTools configuration, the Task tool for subagent spawning, hook patterns like PostToolUse. It tests MCP protocol details — isError flags, resource versus tool versus prompt exposure, structured error metadata. It tests Claude Code configuration details — CLAUDE.md inheritance chains, settings.json permission scopes, --print mode for CI/CD.

This track fills those gaps. Every lesson in this track maps directly to CCA exam domains and task statements.

Study Strategy

Priority 1: Master Domain 1. It is 27% of the exam and appears in four scenarios. The agentic loop, stop_reason handling, multi-agent orchestration, subagent context passing, hooks — this is the core. Lesson 123 in this track covers the agentic loop in depth. Do not skip it.

Priority 2: Tool Design & MCP (D2) and Claude Code Config (D3). These are the two domains with the weakest coverage in earlier academy tracks. D2 covers MCP protocol specifics — tool descriptions, error handling, tool distribution, tool_choice configuration. D3 covers Claude Code operational details you might not know even if you use Claude Code daily.

Priority 3: Practice scenario-based thinking. The exam does not ask "what is stop_reason?" It asks "your customer support agent is in a loop and the model returns a response with both text and tool_use blocks — what should your code do?" Practice translating knowledge into decisions within context.

Priority 4: Know the anti-patterns. The CCA exam guide explicitly lists anti-patterns for each domain. These are the distractors in exam questions. Knowing what is wrong is as important as knowing what is right. Common traps: parsing natural language to detect loop completion, giving agents too many tools, relying on prompt instructions for deterministic compliance, uniform error messages that prevent recovery.

How This Track Maps to the Exam

Each lesson in this track targets specific CCA task statements. Here is the mapping so you can study with precision:

Lesson 122 (this one): Exam overview, domain weights, scenario mapping, study strategy. No specific task statement — this is your strategic foundation.

Lesson 123: The Agent SDK Loop. Task Statement 1.1 — agentic loop lifecycle, stop_reason handling, tool result appending. This is the single most testable concept in the exam.

Lesson 124: Multi-Agent Orchestration. Task Statements 1.2 and 1.3 — coordinator-subagent patterns, context isolation, the Task tool, allowedTools, parallel subagent spawning.

Lesson 125: Tool Design & MCP Deep Dive. Task Statements 2.1, 2.2, and 2.3 — tool descriptions, structured errors, tool distribution, tool_choice configuration.

Lesson 126: Claude Code Configuration Mastery. Task Statements 3.1 through 3.5 — CLAUDE.md hierarchy, slash commands, Agent Skills, MCP in Claude Code, plan mode, permissions.

Lesson 127: Prompt Engineering for Structured Output. Task Statements 4.1 through 4.4 — system prompts, few-shot examples, JSON mode, extraction patterns, confidence scoring.

Lesson 128: Context Management & Reliability. Task Statements 5.1 through 5.4 — context window optimization, summarization, error handling, self-evaluation, human-in-the-loop.

Lesson 129: CCA Exam Simulation. A full-length practice exam with 60 scenario-based questions covering all five domains.

The Distractors Are the Real Test

The CCA exam has four answer options per question. One is correct. Three are distractors. The distractors are not random — they are specifically designed to trap candidates with incomplete understanding.

A typical distractor pattern: the answer that would work in a simple demo but fails in production. For example, a question about how to enforce that a customer support agent verifies identity before processing a refund. The distractor says "add an instruction to the system prompt telling the agent to always verify identity first." The correct answer says "implement a programmatic prerequisite hook that blocks process_refund until get_customer has returned a verified ID." Both approaches attempt the same goal. The first fails at a non-zero rate because prompt instructions are probabilistic. The second is deterministic. The exam rewards the candidate who knows the difference.

Another pattern: the answer that confuses configuration scope. A question about where to put team-wide coding standards for Claude Code. One distractor says "in the user-level ~/.claude/CLAUDE.md." The correct answer says "in the project-level CLAUDE.md committed to the repository." Both are valid CLAUDE.md locations. The exam tests whether you know which scope applies to shared team configuration versus personal preferences.

Lesson 122 Drill

Before proceeding to the next lesson, complete this readiness assessment:

1. Write down the five CCA domains and their weights from memory — do not look at the diagram above
2. For each domain, list three concepts you are confident about and one you need to study
3. Pick one scenario you have never built anything similar to — that is your weakest area
4. Review the anti-patterns list in the CCA exam guide for D1 and D2 specifically
5. Build a minimal agentic loop in TypeScript or Python using the Claude API — not from a template, from scratch
6. Time yourself: if you cannot explain the agentic loop lifecycle in under 60 seconds, you are not ready for D1

Bottom Line

The CCA exam is Anthropic's way of separating practitioners from passengers. It tests the judgment you build by shipping real systems — not the knowledge you accumulate by reading docs. The five domains are weighted unevenly because some things matter more in production than others. Agentic architecture is 27% because if you get the loop wrong, everything downstream fails.

You have eight lessons in this track. Each one maps to specific CCA domains and task statements. By the end, you will have covered every concept the exam tests, with the depth required to choose the correct answer when two options both sound reasonable.

The exam does not reward confidence. It rewards calibrated judgment. That is what this track builds.

Start with Lesson 123. The agentic loop is where everything begins — and where most candidates fail.