UPDATED APR 2026 · UNOFFICIAL STUDY GUIDE

For AI engineers and solution architects sitting Anthropic's CCA-F exam in the next 12 weeks.

Pass Anthropic's CCA-F exam.
Visually.

Cut your CCA-F prep from months to weeks. Every exam domain mapped to a diagram, a production scenario, and a drilled flashcard — with a 15-question mock and a printable one-page cheat sheet.

Start the 15-question mock Grab the cheat sheet
60Questions
120mTime
720Pass Score
$99Fee
By
James Buckett Product Manager
jamesbuckett jamesbuckett @jamesbuckett

Independent study resource. Not affiliated with or endorsed by Anthropic. "Claude" and "CCA-F" are trademarks of their respective owners.

27% Agentic 20% Tools · MCP 20% Claude Code 17% Prompt Eng. 16% Context START CERTIFIED
01 / Exam at a Glance

Exam at a glance: six key numbers

Study all 6 scenarios
60
Questions
Scenario-based multiple choice, proctored
120m
Total Time
≈ 2 minutes per question
720/1000
Passing Score
Scaled 100–1,000 scoring
$99
Registration Fee
USD · one attempt
6+mo
Experience Expected
Associate-level · hands-on with Claude Code and agent patterns
6 / 4
Scenarios
4 drawn randomly from 6 — study all
02 / Domain Deep-Dives

Five exam domains, ranked by weight

Click any domain to expand

27% of exam
~16 of 60 questions
Task Statements — what you must DO
  • Choose orchestration patterns (single agent · orchestrator-worker · hub-and-spoke) for a given problem.
  • Decide when to spin up a sub-agent vs. stay in the main loop.
  • Design context boundaries so sub-agents don't leak state back into the parent.
  • Manage the agentic loop: tool call → observation → next action → termination.
Concept Map
Orchestrator Research Sub Code Sub Review Sub Test Sub isolated context per worker results return as summaries
Key Terms — tap to flip
Common Traps

Don't

  • Connect every sub-agent to every other sub-agent ("mesh of agents").
  • Share the orchestrator's full context with sub-agents by default.
  • Use multi-agent for tasks that fit a single loop.
  • Skip a termination condition on the agentic loop.

Do

  • Start with a single agent; split only when tasks are independent.
  • Pass focused task briefs to sub-agents; have them return summaries.
  • Use a hub-and-spoke shape with one orchestrator.
  • Define max-iteration + success criteria on every loop.

20% of exam
~12 of 60 questions
Task Statements — what you must DO
  • Write tool descriptions that leave zero ambiguity about when to call the tool.
  • Choose the right MCP primitive: tool (action) · resource (data) · prompt (template).
  • Handle tool errors with structured messages that the model can reason about.
  • Pick the right MCP transport: stdio (local) vs. HTTP/SSE (remote).
Concept Map — MCP Triangle
Tools model-invoked actions Resources app-controlled data Prompts user-triggered templates Same server, three primitives. Who triggers matters most.
Key Terms
Common Traps

Don't

  • Write tool descriptions like "gets things". The model can't guess.
  • Return raw 1MB JSON blobs from a tool call.
  • Throw on tool errors — raise them to code instead of the model.
  • Use a tool for static reference data (that's a resource).

Do

  • Describe parameters, units, side effects, and when NOT to call.
  • Return concise results with cursors/IDs for detail fetches.
  • Return structured error messages the model can interpret.
  • Pick the primitive by who initiates: model · app · user.

20% of exam
~12 of 60 questions
Task Statements — what you must DO
  • Place instructions at the right level of the CLAUDE.md hierarchy.
  • Choose between hook (deterministic event) vs. skill (capability bundle) vs. slash command (user shortcut).
  • Wire sub-agents into workflows for parallelizable or context-isolated tasks.
  • Configure settings.json for permissions, env vars, and automated behaviors.
Concept Map — CLAUDE.md Pyramid
Global · ~/.claude/CLAUDE.md Your personal defaults · every session Project · ./CLAUDE.md Team rules · checked into the repo Subdir · ./src/module/CLAUDE.md Local overrides · loaded when working in that path broad specific
Key Terms
Common Traps

Don't

  • Put user-preference "always X" into a project CLAUDE.md.
  • Try to enforce deterministic behavior through CLAUDE.md alone.
  • Confuse "slash command" (user shortcut) with "skill" (model capability).
  • Stuff the root CLAUDE.md with every rule for every subdirectory.

Do

  • Global CLAUDE.md = personal · Project = team · Subdir = local.
  • Use hooks when you need guaranteed, deterministic actions.
  • Use skills when you want the model to choose to use a capability.
  • Keep each CLAUDE.md tight — redundancy invites drift.

~17% of exam
~10 of 60 · foundation for D1, D2
Task Statements — what you must DO
  • Write system prompts that set role, constraints, and output format.
  • Use XML tags to separate instructions, examples, and data.
  • Get structured output reliably via tool-use + JSON schema (not natural-language "return JSON").
  • Design few-shot examples that match the target output distribution.
Concept Map — Prompt Anatomy
System Prompt role · constraints <instructions>, <rules> User Message task · data · examples <task>, <data>, <example> Tool Schema JSON shape contract structured output path Response (assistant turn) text content · tool_use blocks · stop_reason
Key Terms
Common Traps

Don't

  • Say "Return JSON" in prose and hope for the best.
  • Mix instructions, examples, and user data without delimiters.
  • Assume a single example covers all edge cases.
  • Put critical constraints at the very end of a long prompt.

Do

  • Use tool-use with a JSON schema for guaranteed structure.
  • Wrap sections in XML tags (<example>, <data>).
  • Include 3–5 diverse few-shot examples including edge cases.
  • Keep key instructions at the start and end of long prompts.

~16% of exam
~10 of 60 questions
Task Statements — what you must DO
  • Use prompt caching to make repeated long contexts cheap and fast.
  • Decide between context window, memory tool, and sub-agent isolation.
  • Place critical information at the start/end of context (fight "lost in the middle").
  • Design compaction + summarization for long-running agent loops.
Concept Map — Attention Curve
attention position in context START put critical info MIDDLE "lost in the middle" END repeat critical info
Key Terms
Common Traps

Don't

  • Stuff a 200K token context with everything "just in case".
  • Rebuild the same long system prompt every request (no caching).
  • Rely on the middle of the context to hold critical constraints.
  • Persist growing chat history forever without compaction.

Do

  • Mark stable prefixes with cache_control for huge cost savings.
  • Push critical rules to the start AND end of the prompt.
  • Use the memory tool for persistent state across sessions.
  • Summarize old turns once the loop gets long.
03 / Scenario Gallery

Six production scenarios (four appear on the exam)

4 appear on exam · drawn randomly
04 / Mental Models Library

Five mental models that recur across domains

Hub-and-Spoke Orchestration

One orchestrator delegates to independent workers. Each worker runs in its own context; results return as summaries. No worker-to-worker edges.

HUB W1 W2 W3 W4 W5 W6

CLAUDE.md Hierarchy Pyramid

Three levels, broad to specific. Closer to the code = higher precedence. User-level is always you; project-level is team; subdir-level overrides for scope.

~/.claude/CLAUDE.md ./CLAUDE.md ./src/x/CLAUDE.md more specific → higher precedence

MCP Primitives Triangle

Tools are model-invoked. Resources are app-controlled data. Prompts are user-invoked templates. Picking the wrong primitive is a top exam trap.

Tools model Res. app Pr. user who initiates?

JSON Schema Validation Retry Loop

Call with tool-use → parse response → validate against schema → on fail, return validator error back to the model and retry. Cap retries.

Call Parse Validate Retry w/ error msg Self-healing loop cap retries · then fail

"Lost in the Middle" Placement

Language models attend strongly to the start and end of context. Information buried in the middle has measurably lower recall.

start end middle weaker recall → repeat critical rules at both ends

The Agentic Loop

Think → Act (tool call) → Observe (tool result) → Think again. Terminates on a stop condition, a final answer, or a safety cap.

Think Act Observe Update
05 / 12-Week Study Plan

12-week study plan (progress saved locally)

State saved locally
0 / 12 weeks complete
Weighted toward Domain 1 (heaviest on exam). Reserve weeks 11–12 for full-length practice runs.
06 / Practice Quiz

15-question mock exam with instant feedback

00:00
07 / Visual Glossary

Visual glossary (filter by domain)

08 / Printable Cheat Sheet

One-page cheat sheet (print-ready)

CCA-F Cheat Sheet

v2026.03 · 60 Qs · 120 min · pass 720 · $99
D1 · 27% Agentic
D2 · 20% Tools/MCP
D3 · 20% Claude Code
D4 · ~17% Prompt Eng.
D5 · ~16% Context

D1 · Agentic Architecture

  • Hub-and-spoke beats mesh
  • Sub-agents get isolated context
  • Return summaries, not raw state
  • Every loop needs a stop condition
  • Single agent first — split only for independence

D2 · Tools & MCP

  • Tool = model-invoked action
  • Resource = app-controlled data
  • Prompt = user-triggered template
  • Describe WHEN to call, not just WHAT
  • Return structured errors, don't throw

D3 · Claude Code

  • Global → Project → Subdir precedence
  • Hook = deterministic event response
  • Skill = model-chosen capability
  • Slash command = user shortcut
  • Keep each CLAUDE.md tight

D4 · Prompt Engineering

  • Use XML tags to delimit sections
  • Structured output = tool use + JSON schema
  • 3–5 diverse few-shot examples
  • Critical rules at start + end
  • Never "please return JSON" in prose

D5 · Context & Reliability

  • Cache stable prefixes → cheap + fast
  • Lost-in-middle is real — anchor both ends
  • Memory tool for cross-session state
  • Compact old turns as the loop grows
  • Don't stuff context "just in case"

Six Scenarios

  • Customer Support Resolution
  • Code Generation (Claude Code)
  • Multi-Agent Research
  • Developer Productivity
  • Claude Code for CI/CD
  • Structured Data Extraction
09 / Frequently Asked Questions

Answers to the six questions everyone asks

Is this guide official? Is it affiliated with Anthropic?

No. This is an independent study resource written and maintained by James Buckett. It is not affiliated with, endorsed by, or reviewed by Anthropic. Always cross-check critical details against Anthropic's official exam page before sitting the exam.

How current is this guide? When was it last updated?

Last updated April 2026 (v2026.03). The guide is versioned against the CCA-F blueprint published by Anthropic. If Anthropic changes the exam blueprint, domain weights, or scoring model, the guide may lag by a few weeks — watch the GitHub repo for changelog entries.

What experience do I need before attempting the CCA-F?

Anthropic positions the CCA-F as an associate-level certification. In practice, most passers have at least 6 months of hands-on work with Claude Code, the Claude API, MCP servers, and real agent loops in production (or close to it). If you've never shipped anything with sub-agents or tools, spend a few weeks building before you study.

How is this different from reading Anthropic's official documentation?

Anthropic's docs are exhaustive but not exam-shaped. This guide is structured around the five exam domains and their relative weights, emphasises the patterns Anthropic keeps contrasting (hub-and-spoke vs mesh, tool vs resource vs prompt, hook vs skill), and gives you practice in the scenario-question format the exam actually uses. Use the official docs as the source of truth; use this guide to know where to look.

How do I actually register for the exam?

Registration runs through Anthropic's certification portal — see the "Ready to register?" section below for the official link. The exam is remotely proctored, 60 questions over 120 minutes, scored 100–1,000, with 720 to pass. Registration fee at time of writing is $99 USD.

I found an error or want to suggest an improvement. How?

Open an issue on the GitHub repo, or DM the author on the social links in the hero. Corrections and new practice questions are welcome — this guide improves fastest when readers flag what confused them.

10 / Ready to Register?

You've done the work. Book the exam.

01
Create an Anthropic account
If you don't already have one. You'll use the same login for the certification portal.
02
Pick an exam slot
Pay the $99 USD registration. Slots are remotely proctored — you'll get a system check email ahead of time.
03
Sit the exam
60 questions, 120 minutes, scored 100–1,000, pass at 720. You'll see results on-screen at the end.
Go to Anthropic certification Print cheat sheet first