Claude Certified Architect (Foundations): Complete Course

The Claude Certified Architect — Foundations (CCA-F) certification validates that you can design and implement production-grade systems with Claude, and make sound tradeoff decisions across the Claude API, the Claude Agent SDK, Claude Code, and the Model Context Protocol (MCP).

This is a complete prep course: overview, the five exam domains, a full curriculum with code, a four-week plan, eight hands-on exercises, tips, and a curated resource list. Use the "On this page" outline to jump between sections.

📚 This is Page 1 of an 8-page course. Mark each page complete (button at the bottom of every page) and your progress fills in on the Courses page. The pages: 1. Overview (this page) · 2. Domain 1 — Agentic Architecture · 3. Domain 2 — Tool Design & MCP · 4. Domain 3 — Claude Code · 5. Domain 4 — Prompt & Structured Output · 6. Domain 5 — Context & Reliability · 7. The 6 Exam Scenarios · 8. Exam Cheat-Sheet.

A note on sources and policy. This is an independent study course. It links only to publicly available Anthropic documentation and third-party study resources and summarizes the exam at a high level. It deliberately does not reproduce Anthropic's confidential exam materials (the official exam guide is marked Confidential — Need to Know), nor any verbatim sample questions or answer keys. Treat it as a study companion to the official docs and your own hands-on practice. Where you have access to official practice material through the partner portal, make that your primary reference.

Overview

The certification is not a memorization test. Questions are grounded in realistic production scenarios and reward practical judgment — given a situation, which architecture or configuration is the right tradeoff?

Who should take this

• Solution architects and senior/backend engineers building AI systems with Claude
• DevOps/SRE engineers integrating Claude into pipelines
• Tech leads evaluating Claude for production

What you'll be able to do

• Design autonomous agentic loops and multi-agent orchestration
• Build MCP servers with well-designed tools, resources, and structured errors
• Enforce reliable structured output with JSON schemas and validation
• Configure Claude Code for teams and CI/CD
• Manage context windows and design for reliability and escalation

Prerequisites

Roughly 6+ months of hands-on experience with the Claude API, Claude Agent SDK, Claude Code, and MCP. If you're newer, work the curriculum and exercises below before booking the exam.

Exam format at a glance

• Question type: multiple choice — one correct answer, three distractors
• Scoring: scaled 100–1,000; passing score 720; pass/fail result
• Style: scenario-based — a subset of realistic scenarios is drawn from a larger pool, each framing several questions
• No penalty for guessing — answer every question
• Commonly cited logistics: ~60 questions in ~120 minutes (confirm current details on the official registration page)

Exam Domains

Approximate weightings (largest first). Domain 1 is the heaviest — start there.

Scenario types

The exam frames questions around realistic production contexts. Be ready to reason about each:

• A customer-support resolution agent with backend tools and an escalation path
• Code generation with Claude Code — slash commands, CLAUDE.md, plan vs direct execution
• A multi-agent research pipeline — coordinator + search / analysis / synthesis subagents
• Developer-productivity tooling over a codebase using built-in + MCP tools
• Claude Code in CI/CD — automated review and test generation with low false positives
• Structured data extraction from unstructured documents with JSON-schema validation

⚠️ Key insight. Domain 1 (Agentic Architecture) is the largest slice. Master the agentic loop and hub-and-spoke orchestration first — almost everything else builds on them.

Curriculum

Module 1 — Agentic Architecture Fundamentals

The agentic loop. Send a request, inspect stop_reason, execute the requested tool, append the result, repeat until done.

while True:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    messages.append({"role": "assistant", "content": response.content})

    if response.stop_reason != "tool_use":
        break  # end_turn / max_tokens -> done

    # Run every tool the model requested this turn
    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            result = execute_tool(block.name, block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": result,
            })
    messages.append({"role": "user", "content": tool_results})

Key points:

• Drive the loop off stop_reason (tool_use vs end_turn) — never parse the model's prose or rely on arbitrary iteration caps as the primary stop
• Tool results go back as a user message so the model can reason about the next step
• This is model-driven control flow, not a hard-coded decision tree

Multi-agent orchestration (hub-and-spoke). A coordinator decomposes the task, delegates to specialized subagents, and routes all communication.

• Subagents have isolated context — they do not inherit the coordinator's history. Pass what they need explicitly in the prompt
• The coordinator decides which subagents to invoke based on the query — don't always run the full pipeline
• Watch for overly narrow task decomposition (e.g., breaking "creative industries" into only visual-arts subtopics) that silently drops coverage

Lifecycle hooks & enforcement.

• PreToolUse / PostToolUse hooks intercept calls and results — for logging, data normalization, or blocking policy-violating actions
• When a step must happen (e.g., verify identity before a refund), use programmatic enforcement / prerequisite gates — prompt instructions alone have a non-zero failure rate
• Compile structured handoff summaries (key facts + root cause + recommended action) when escalating to a human

Spawning subagents & passing context.

• Subagents are spawned via the Task tool — a coordinator's allowedTools must include "Task" to delegate
• Each subagent is configured with an AgentDefinition (description, system prompt, tool restrictions)
• Context is not inherited — pass prior findings explicitly in the subagent's prompt; use structured formats to preserve source attribution
• Spawn subagents in parallel by emitting multiple Task calls in a single response (faster than separate turns)

Task decomposition.

• Prompt chaining (fixed sequential passes) for predictable, multi-aspect work — e.g., analyze each file, then a cross-file integration pass
• Dynamic adaptive decomposition for open-ended investigation — generate subtasks from what each step discovers
• Avoid attention dilution by splitting large jobs into focused passes

Session state, resumption & forking.

• --resume <session-name> continues a specific prior conversation
• fork_session branches from a shared baseline to explore divergent approaches in parallel
• Prefer starting fresh with a structured summary over resuming with stale tool results; when you do resume, tell the agent which files changed

📖 Go deeper: Claude Agent SDK docs (agentic loops, subagents, hooks) and Claude Code memory & sessions.

Module 2 — Prompt Engineering & Structured Output

Enforce structure with tool use + JSON schemas (the most reliable approach — eliminates JSON syntax errors).

{
  "type": "object",
  "properties": {
    "sentiment": { "type": "string", "enum": ["positive", "negative", "neutral"] },
    "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
  },
  "required": ["sentiment", "confidence"]
}

• tool_choice: "auto" (model may answer in text), "any" (must call some tool), or forced {"type": "tool", "name": "..."}
• Make fields nullable/optional when the source may not contain them — prevents the model fabricating values to satisfy required
• Strict schemas remove syntax errors, not semantic ones (line items that don't sum, values in the wrong field)

Few-shot examples are the most reliable lever for consistent format and good judgment on ambiguous cases — 2–4 targeted examples that show why one choice beats a plausible alternative.

Extraction vs classification. Extraction (pull existing values) is more reliable than classification (assign a label) — prefer it when possible.

Validation, retry & feedback loops.

• On a validation failure, send a follow-up that includes the original input, the failed output, and the specific error so the model self-corrects
• Know retry's limit: it fixes format/structural errors but not missing information (info simply absent from the source)
• Distinguish semantic errors (values don't sum, wrong field) from syntax errors (tool use already eliminates syntax errors)

Batch processing (Message Batches API).

• ~50% cost savings, processing window up to 24 hours, no latency SLA → ideal for overnight/weekly jobs, not for blocking pre-merge checks
• Correlate request/response pairs with custom_id; on failure, resubmit only the failed items (e.g., chunk oversized docs)
• The batch API does not support multi-turn tool calling within a single request

Multi-pass & independent review.

• A model that generated code is biased reviewing its own work — use an independent instance (no prior reasoning context) to catch subtle issues
• Split large reviews into per-file passes + a cross-file integration pass to avoid attention dilution and contradictory findings

📖 Go deeper: Prompt engineering guide, Tool use & structured output, and the Message Batches API.

Module 3 — Model Context Protocol (MCP)

MCP defines how Claude discovers and uses external capabilities. Three building blocks:

1. Tools — callable actions (query a DB, send email, call an API)
2. Resources — readable assets (files, schemas, doc catalogs) that reduce exploratory tool calls
3. Prompts — reusable instruction templates

Tool design principles:

• One focused task per tool — too many tools (or overlapping ones) degrade selection
• Descriptions are the primary selection signal — include inputs, example queries, edge cases, and when to use this vs a similar tool
• Structured errors — category (transient / validation / business / permission), a retryable flag, and a human-readable message
• Scope tools per role and use project vs user config, with environment-variable expansion for secrets

MCP server configuration.

• Project-level (.mcp.json) for shared team tooling vs user-level (~/.claude.json) for personal/experimental servers
• Environment-variable expansion (e.g., ${GITHUB_TOKEN}) keeps secrets out of committed config
• Tools from all configured servers are discovered at connection time; prefer existing community servers over custom ones for standard integrations

Built-in tools (Read, Write, Edit, Bash, Grep, Glob).

• Grep = search file contents; Glob = find files by name/pattern; Read/Write = full-file ops; Edit = targeted change via a unique text match
• When Edit can't find a unique anchor, fall back to Read + Write
• Build understanding incrementally — Grep for entry points, then Read to follow imports — rather than reading everything upfront

📖 Go deeper: Model Context Protocol spec and Claude Code documentation.

Module 4 — Claude Code & CI/CD

• CLAUDE.md hierarchy: user → project → directory, with @import and a rules directory for modular organization
• Path-specific rules (glob patterns) for conventions that span directories (e.g., all **/*.test.tsx)
• Custom slash commands and Skills (frontmatter like context: fork, allowed-tools, argument-hint); project-scoped (shared) vs user-scoped (personal)
• Plan mode vs direct execution — plan mode for large, architectural, multi-file work; direct execution for small, well-scoped changes
• CI/CD: run non-interactively with -p / --print; use --output-format json / --json-schema for machine-parseable findings; an independent review instance catches more than self-review

Iterative refinement.

• Concrete input/output examples beat prose descriptions when results are inconsistent
• Test-driven iteration — write the tests first, then iterate by sharing failures
• Interview pattern — have Claude ask clarifying questions before implementing in an unfamiliar domain
• Fix interacting problems in one message; fix independent problems sequentially

Commands & exploration.

• /memory — inspect which memory / CLAUDE.md files are loaded (diagnose inconsistent behavior across sessions)
• /compact — reduce context usage during long sessions
• Explore subagent — isolate verbose discovery and return summaries, preserving the main context window

📖 Go deeper: Claude Code documentation (CLAUDE.md, slash commands, Skills, plan mode, GitHub Actions).

Module 5 — Context Management & Reliability

• Long context: chunk, summarize, or retrieve; beware the "lost in the middle" effect and progressive-summarization loss of numbers/dates
• Trim verbose tool output to relevant fields before it accumulates; keep a persistent "case facts" block
• Escalation: honor explicit human-agent requests immediately; escalate on policy gaps or lack of progress; sentiment and self-reported confidence are poor complexity proxies
• Error propagation: structured error context, local recovery first, distinguish access failures from valid empty results
• Provenance: preserve claim-source mappings through synthesis; annotate conflicts and dates instead of silently picking a value

Human review & confidence calibration.

• Aggregate accuracy (e.g., "97% overall") can mask poor performance on specific document types or fields — analyze accuracy by segment
• Use stratified random sampling of high-confidence outputs to catch novel error patterns
• Have the model emit field-level confidence, calibrate thresholds on a labeled set, and route low-confidence or ambiguous cases to humans

Large-codebase context.

• Use scratchpad files to persist key findings across context boundaries (counteracts degradation in long sessions)
• Delegate verbose exploration to subagents; summarize each phase before starting the next
• For crash recovery, have agents export structured state (manifests) the coordinator reloads on resume; use /compact when context fills with discovery output

📖 Go deeper: Long-context tips and context window management.

4-Week Study Plan

Plan for ~10–15 hours per week. Each week builds on the last.

Week 1 — Architecture foundations

• Read the Claude API docs on tool use and stop_reason
• Build a small agentic loop that calls a tool a few times
• Study hub-and-spoke and coordinator-subagent patterns; diagram a support system
• Implement PreToolUse / PostToolUse hooks (log calls; block a forbidden call)

Week 2 — Prompting & MCP

• JSON Schema validation; make Claude follow a strict schema via tool use
• Few-shot extraction + a validation-retry loop
• Read the MCP spec; start a simple MCP server (tools, resources)
• Practice designing tool boundaries (what's a tool vs overkill)

Week 3 — Claude Code & context

• Finish the MCP server with structured error handling; test with the Agent SDK
• Build a CLAUDE.md hierarchy; add a path-scoped rule, a custom command, and a Skill
• Integrate Claude Code into a CI step (run with -p, output JSON)
• Practice long-context strategies; take a first full practice exam

Week 4 — Practice & final prep

• Work each scenario type end-to-end: design, list tradeoffs, code key parts
• Take full-length timed practice exams; review every wrong answer
• Drill your weakest domain; skim key concepts; rest before exam day

Hands-On Exercises

Reading isn't enough — these builds are the difference between passing and failing. Ideally build one integrated system that exercises all of them rather than eight disconnected demos.

1. End-to-end agentic loop · Domain 1

Implement a full loop with tool calling, correct stop_reason handling (tool_use / end_turn / max_tokens), tool results added back to context, and graceful handling when a tool fails. Done when: the loop handles all stop reasons, multi-turn works (5+ exchanges), and tool errors don't crash it.

2. CLAUDE.md architectural rulebook · Domain 3

Write a CLAUDE.md with a real hierarchy (repo / folder / file), naming conventions, tool-design rules, and 3+ custom slash commands.

# Project Architecture & Rules

## Code Organization
- Agents: `src/agents/` (one file per agent)
- Tools: `src/tools/` (named `{service}_tools.py`)

## Tool Design Rules
- Input: must have a JSON schema
- Error: return structured error with code + message
- Timeout: 30s max; retry with exponential backoff

## Commands
- `/run-agents` - start all agents
- `/test-tools` - validate tool execution

3. MCP server from scratch · Domain 2/3

Implement a server with tools, resources, and structured errors.

from mcp.server import Server
from mcp.types import Tool

server = Server("my-database-mcp")

@server.list_tools()
async def list_tools():
    return [Tool(
        name="query_database",
        description="Run a read-only SQL query against the orders DB. "
                    "Input: a SELECT statement. Use for order/customer lookups; "
                    "not for writes.",
        inputSchema={
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"],
        },
    )]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    try:
        return [{"type": "text", "text": execute_query(arguments["query"])}]
    except Exception as e:
        return [{"type": "text", "text": f"Error: {e}", "isError": True}]

4. Structured output with validation-retry · Domain 4

Define an extraction schema (required, optional, nullable, and an enum with an "other" + detail pattern). On validation failure, send a follow-up that includes the document, the failed output, and the specific error — and know when retry won't help (info simply absent).

from pydantic import BaseModel, ValidationError

class ReviewResult(BaseModel):
    overall_score: int
    issues: list[str]
    pass_fail: bool

def review(doc: str, max_retries: int = 3):
    for attempt in range(max_retries):
        raw = call_claude_with_tool(doc)        # tool_use returns JSON
        try:
            return ReviewResult.model_validate(raw)
        except ValidationError as e:
            doc = f"{doc}\n\nPrevious output was invalid: {e}. Fix and re-emit."
    raise RuntimeError("Validation failed after retries")

5. Hub-and-spoke multi-agent system · Domain 1

A coordinator delegating to 3+ specialized subagents with isolated context and structured error propagation. Done when: subagents receive context explicitly, a failed subagent returns structured error context, and the coordinator proceeds with partial results.

6. Claude Code in CI/CD · Domain 3

Run Claude Code on pull requests and post results.

name: Claude Code Review
on: pull_request
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Review PR
        run: |
          claude -p "Review this PR for security and correctness" \
            --output-format json > review.json
          python post_review.py review.json

7. Data extraction with few-shot · Domain 4

Extract structured data from messy documents using 2–4 few-shot examples that cover varied formats and edge cases (informal values, missing fields → null).

8. Long-context document workflow · Domain 5

Process a document that exceeds the window: chunk → summarize/retrieve relevant chunks → aggregate. Done when: it handles large inputs without losing key facts and mitigates the "lost in the middle" effect.

Map exercises to the exam

• Week 1: #1 + #5 (agentic loop + hub-and-spoke) — the heaviest domain
• Week 2: #3 + #4 + #7 (MCP + structured output + extraction)
• Week 3: #2 + #6 + #8 (Claude Code + CI/CD + context)
• Week 4: review + practice exams

Readiness checklist

• Completed all 8 exercises
• Can explain the agentic loop without looking at code
• Built at least one hub-and-spoke system
• Implemented an MCP server with structured errors
• Enforced a JSON schema with a retry loop
• Created a CLAUDE.md with custom commands
• Can design an architecture for each scenario type
• Scoring comfortably above the pass mark on timed practice exams

Tips & Tricks

• Master the agentic loop first. It underpins most of the exam — know it cold.
• Build, don't just read. The exam rewards practical judgment; the 8 exercises are non-negotiable.
• Think in tradeoffs. When hub-and-spoke vs sequential? When enforce programmatically vs prompt? When tool_choice: "any"?
• Prefer the proportionate fix. Many answers favor the simplest root-cause fix (e.g., better tool descriptions) over heavy infrastructure (a new classifier/routing layer).
• Programmatic enforcement beats prompts when compliance must be guaranteed (money, identity, safety).
• JSON schema via tool use is the reliable path to structured output; nullable fields prevent fabrication.
• Independent review beats self-review; split large reviews into per-file + integration passes.
• Connect the domains — build one system that touches all five, not five silos.
• Use -p for non-interactive Claude Code in pipelines.
• Trust the process — finish the exercises and timed practice exams and you'll be ready.

Common mistakes to avoid

• Skipping the hands-on builds and relying on reading
• Not taking timed full-length practice exams
• Confusing sequential with hub-and-spoke orchestration
• Overloading agents with too many tools / vague tool descriptions
• Studying only Domain 1 and ignoring the other ~73%

Resources

Official Anthropic

• Claude API documentation — messages, tool use, models
• Claude Agent SDK — agentic loops, hooks, multi-agent patterns
• Claude Code documentation — CLAUDE.md, slash commands, Skills, GitHub Actions, context window
• Model Context Protocol specification — MCP architecture, tools, resources
• Prompt Engineering guide
• Tool use (function calling) reference
• Claude models overview & context windows
• Anthropic Cookbook (GitHub) — runnable recipes for tools, agents, and RAG
• Anthropic Academy — free courses, including Introduction to MCP, Claude Code in Action, and Building with the Claude API
• CCA — Foundations exam access & registration — official partner portal

Final advice

If you complete the hands-on exercises and can explain the tradeoffs behind each architectural choice — not just the definitions — you're in strong shape. Anchor on Domain 1, build something real that touches all five domains, and use timed practice exams to find where to study next.

Good luck. 🎯