How to Pass the Anthropic CCA-F Certification Exam

The CCA-F exam does not test whether you can recall syntax. It tests whether you can make architectural decisions under constraints — the same decisions a senior engineer makes when designing a production system with Claude. Most candidates who fail do not fail because they studied the wrong topics. They fail because they studied in the wrong way: reading documentation passively instead of stress-testing their own judgment on scenario questions. The exam's core challenge is not obscure knowledge; it is scenario questions where two of the four options both look correct. Passing the exam means developing the habit of finding the binding constraint that separates a good answer from the right answer.

The Core Mental Shift

Every hour of effective CCA-F prep is spent answering a different question than most candidates ask. Instead of asking what a feature does, ask when you would choose it over the alternative, and what breaks in production if you choose wrong. That reframe is the difference between a candidate who scores 65% and one who scores 85%. You can pass without memorizing a single API parameter name. You cannot pass without understanding why streaming is the right default for agentic loops, why stdio transport fails in multi-client deployments, or why caching a system prompt in position zero saves meaningful latency on every turn. The domain knowledge that matters is not encyclopedic — it is causal. Know what fails, know why it fails, and know which scenario constraints make one pattern mandatory over another.

Domain Priority — Study by Weight Times Difficulty

The CCA-F has five domains, and they are not created equal. The right study sequence is not alphabetical and it is not the order they appear in the exam guide. It is weight multiplied by difficulty — the domains where a small improvement in understanding returns the most points. Here is the sequence you should follow and why.

• Domain 1: Agentic Architecture (27% of the exam) — Study this first. It carries the highest single-domain weight and, critically, agentic concepts bleed into questions nominally from other domains. A Domain 2 question about tool design often requires you to reason about how an agent orchestrates tool calls. A Domain 3 question about Claude Code workflows assumes you understand the agent loop. If your agentic architecture understanding is weak, you pay a tax on every domain.
• Domain 3: Claude Code Workflows (20% of the exam) — Study this second. Practitioners consistently underestimate it. The CLAUDE.md hierarchy — project-level versus user-level versus default behaviors, and how precedence resolves when they conflict — generates more exam questions than most candidates expect. If you use Claude Code daily but have never explicitly mapped out the override chain, you will miss questions you feel you should have gotten right.
• Domain 4: Prompt Engineering (20% of the exam) — Study this alongside Domain 3. The density in Domain 4 lives in structured output: JSON Schema constraints, validation loops, and the mechanics of getting reliable structured responses under production conditions. The conceptual side — chain-of-thought, few-shot examples, role prompting — is intuitive for most candidates. The failure mode is underestimating how specifically the exam tests the implementation details of output validation.
• Domain 2: Tool Design and MCP (18% of the exam) — Study this fourth. MCP intimidates candidates who have not built with it, but once the ownership model clicks, the domain becomes tractable. The model that binds: Tools are invoked by the model to take actions, Resources are read by the application to provide context, and Prompts are user-initiated templates. Every MCP architecture question maps back to this model. Once you can derive which primitive owns which responsibility, the scenario questions resolve cleanly.
• Domain 5: Context Management (15% of the exam) — Study this last, and cap your prep time on it at roughly 15% of your total study hours. The exam does test context management, but it tests a narrow slice: prompt caching TTLs (5 minutes for standard, 1 hour for extended), the performance impact of cache position, and the behavioral effects of where you place instructions in the context window. Do not over-invest here. It is the most approachable domain and the easiest one to over-study relative to its exam weight.

2-Week Study Schedule

Two weeks is a realistic timeline for a practicing developer who already works with LLM APIs and wants a structured sprint to exam-ready. The schedule is front-loaded with domain foundations and back-loaded with mock exams and targeted remediation. Do not skip the remediation step — it is where the actual learning happens.

Week 1 — Domain Foundations

1. Day 1: Read the official CCA-F exam guide end to end. Map each domain objective to something you have built or used. Note where you feel uncertain — those are your highest-ROI topics. Do not study yet; just calibrate.
2. Day 2: Domain 1 foundations — agentic loops, orchestration patterns, subagent delegation, error handling in multi-step pipelines. Write out the agent execution cycle from memory at the end of the day. If you cannot, re-read.
3. Day 3: Domain 1 continued — human-in-the-loop patterns, when to interrupt versus proceed, and how agent state should be managed across turns. Do 15 scenario questions on agentic architecture only.
4. Day 4: Domain 3 — Claude Code workflows. Map the CLAUDE.md hierarchy explicitly: what each level controls, how precedence resolves, and what happens when a user-level setting conflicts with a project-level setting. Do 10 scenario questions on CLAUDE.md specifically.
5. Day 5: Domain 4 — prompt engineering. Focus session on structured output: JSON Schema, output validation, retry loops when validation fails. Do 15 scenario questions mixing chain-of-thought and structured output.
6. Day 6: Domain 2 — MCP and tool design. Work through the Tools/Resources/Prompts ownership model until you can derive it from first principles rather than memory. Do 10 scenario questions on MCP transport selection and tool versus resource choice.
7. Day 7: Domain 5 — context management. Cover caching TTLs, cache position effects, and context window management strategies. Do 10 scenario questions. End the day with a timed 30-question mixed practice exam to establish your baseline score.

Week 2 — Mock Exams and Remediation

1. Day 8: Review your Day 7 practice exam. For every question you got wrong, write a one-sentence explanation of why the correct answer is correct and why your answer was wrong. Do not move on until you can articulate the distinction.
2. Day 9: Take a full 60-question timed mock exam. Simulate real conditions — no notes, no lookups. Score it immediately.
3. Day 10: Remediation day. Identify the two domains where you scored worst on the Day 9 exam. Spend the full day re-studying those domains only. Focus on the specific question types that tripped you, not the full domain.
4. Day 11: Take a second 60-question timed mock exam, different question set from Day 9. Score it and compare to your Day 9 baseline. If your score improved by less than 5 points, your remediation is not converting — you are re-reading instead of practicing. Shift to more questions.
5. Day 12: Targeted remediation on any domain still below 70% accuracy on the Day 11 exam. Also review the scenario question technique explicitly — practice identifying binding constraints on 20 hand-picked hard questions.
6. Day 13: Light review day. Do not introduce new material. Do 20 questions across domains, focusing on your highest-confidence areas to build exam-day fluency. Review the MCP ownership model and CLAUDE.md precedence rules one more time from memory.
7. Day 14: Exam day, or a final 30-question warmup if your exam is tomorrow. If you are taking the exam today, do not cram. You have done the work. Focus on reading each scenario carefully and identifying the binding constraint before evaluating options.

4-Week Schedule for Beginners

If you are new to the Claude API or have not built production LLM systems before, four weeks gives you the ramp-up time to build conceptual foundations before drilling scenario questions. Do not skip Week 1 — arriving at mock exams without foundational fluency wastes practice questions on concepts you have not learned yet.

• Week 1 — Foundations via Skilljar: Complete the official Anthropic Skilljar courses in full. Take notes on every concept that surprises you — those are your gaps. Do not do practice questions yet. End the week by reading the CCA-F exam guide and mapping each objective to something you learned in the courses.
• Week 2 — Domain Deep Dives: Follow the domain priority order (D1, D3, D4, D2, D5). Spend roughly one day per domain. Use this platform's /learn section (59 concepts) and /glossary (91 terms) as your reference layer. At the end of each domain day, write a one-paragraph summary of what you learned without looking at your notes.
• Week 3 — Scenario Practice: Shift to an 80% practice, 20% reading ratio. Take your first timed mock exam on Day 15. Do targeted remediation mid-week based on your weakest domains. Take a second mock exam on Day 21 and measure your improvement. This is the week where the exam technique — identifying binding constraints — should become automatic.
• Week 4 — Mock Exams and Final Remediation: Take a full mock exam every other day (Days 22, 24, 26). Remediate on the off days. On Day 27, do a final review of CLAUDE.md hierarchy, MCP ownership model, and caching TTLs — the three highest-frequency specific topics. Day 28 is rest or a light 20-question warmup only.

The Scenario Question Technique

Every CCA-F question follows the same structure: a scenario that describes a system, a constraint, or a requirement, followed by four answer options. Two of those options are usually eliminatable in under 10 seconds — they contradict a core concept or describe something that simply does not exist. The real exam is deciding between the two remaining options, which both appear plausible. The technique for that decision is the same every time: find the binding constraint in the scenario. A binding constraint is a detail in the scenario that, when you apply it correctly, eliminates one of the two remaining options because that option fails under that specific constraint.

Common binding constraints and what they eliminate: a stateless multi-client deployment eliminates stdio transport in favor of StreamableHTTP, because stdio is a one-to-one process connection that cannot serve multiple clients. A model-invoked action (not user-invoked) eliminates MCP Resources and MCP Prompts in favor of MCP Tools, because Tools are the primitive the model calls autonomously. Low latency on repeated identical system prompts eliminates not caching the system prompt, because caching in position zero is the correct solution to that constraint. Sensitive customer data that cannot leave the organization eliminates any architecture that routes data through external services. Train yourself to find the binding constraint before you evaluate the options. Candidates who evaluate options first spend time rationalizing their instinct. Candidates who find the binding constraint first spend time verifying the answer.

What NOT to Study

The CCA-F rewards depth on high-leverage topics and punishes time wasted on low-ROI material. These are the six categories you should consciously skip or cap at minimal review time. Every hour not spent on these is an hour you can spend on the scenario practice that actually moves your score.

• Exact API syntax and parameter names: The exam does not ask you to write or complete code. It asks you to evaluate architectural decisions. Knowing the exact shape of a messages array does not help you answer a question about when to use streaming versus non-streaming responses.
• Model version history: The exam is not a trivia test about Claude version release dates or capability differences between generations. Focus on current architectural best practices, not version genealogy.
• RAG implementation details: You need to understand retrieval-augmented generation conceptually — when it is appropriate, how it interacts with context limits, and when to prefer it over caching. You do not need to know vector database internals, embedding model architectures, or chunking algorithm specifics.
• Pricing and cost math: The exam does not ask you to calculate costs or optimize for a specific price point. Cost considerations may appear as one signal in an architectural trade-off, but you will not be asked to compute token costs or compare pricing tiers.
• Constitutional AI and alignment research: This is foundational Anthropic research and it informs Claude's behavior, but the exam does not test your knowledge of RLHF, Constitutional AI methodology, or alignment theory. These are interesting topics but zero-ROI for CCA-F prep.
• Batch API retry mechanics: The Batch API is a real feature and may appear in questions, but the exam does not go deep on retry logic, failure handling specifics, or Batch API implementation details. Know what it is and when it is appropriate; do not study its operational details.

Three Failure Patterns to Avoid

These are the three most common patterns that cause candidates to score lower than their knowledge level should predict. All three are avoidable with deliberate prep design.

Over-Investing in Domain 5

Domain 5 (Context Management) is only 15% of the exam. It is also the most approachable domain for most candidates — the concepts are intuitive, the vocabulary is familiar, and the documentation is clear. This combination makes it a trap. Candidates who feel uncertain about their overall readiness gravitate toward Domain 5 because studying it feels productive and anxiety-reducing. The problem is that over-investing here has a hard ceiling on return. Even if you score 100% on Domain 5 questions, you have maximized 15 points. Spending four hours on Domain 5 instead of Domain 1 costs you potential points on 27% of the exam to gain marginal points on 15% of the exam. Cap your Domain 5 prep at your 15% time budget, and redirect the rest.

Reading Without Practicing

In the first half of prep, an 80% reading and 20% practice ratio is correct. You need conceptual foundations before scenario questions are useful. In the second half of prep, that ratio must invert: 20% reading and 80% practice. Most candidates who fail did not make this switch. They read through the second week because reading feels like learning and practice feels like testing. But the CCA-F scenario questions require a specific cognitive skill — finding binding constraints and eliminating options — that only develops through repetition on questions. Reading about agentic architecture for the fifth time does not improve your score. Doing 30 more scenario questions and reviewing the ones you got wrong does.

Treating CLAUDE.md Hierarchy as a Minor Topic

Candidates who use Claude Code regularly often assume they understand the CLAUDE.md hierarchy because they use it in practice. This assumption leads to skipping explicit study of the precedence rules. The exam exploits this gap. Domain 3 generates a disproportionate share of questions about hierarchy edge cases: what happens when a project-level CLAUDE.md setting conflicts with a user-level setting, which layer takes precedence when multiple configuration sources apply, and how the @import syntax affects resolution order. These are not questions you can answer correctly based on casual usage. You need to map the hierarchy explicitly — write it out, trace through conflict scenarios, and verify your understanding against the documentation before exam day.

Free Resources on This Platform

This platform has everything you need for a complete CCA-F prep cycle at no cost. The /learn section covers 59 concepts mapped to exam objectives — use it as your primary reference during domain study weeks. The /glossary covers 91 terms with precise definitions — use it to resolve vocabulary questions quickly rather than searching documentation. The /exam section provides full mock exams structured to match the real exam format — use these for all your timed practice sessions. The /reference section has cheat sheets for high-density topics like the MCP ownership model and caching TTL values — use these for your final review. The /study-plan section offers a structured preparation timeline if you want a guided path through the material rather than building your own schedule.