Claude Certification Study Guide: Pass CCA-F in 2026

This claude certification study guide covers everything you need to pass the Claude Certified Architect, Foundations exam (CCA-F): domain weights, the scenario patterns Anthropic favours, and the study sequence we recommend based on the 30 task statements. The exam launched 12 March 2026, costs $99 per attempt, and requires a scaled score of 720 out of 1000 across 60 scenario-based questions.

We are an independent prep platform. AI Skill Certs is not affiliated with, endorsed by, or approved by Anthropic.

What is the CCA-F and why does the domain weighting matter?

The CCA-F is Anthropic's first professional certification, part of the Claude Partner Network, a $100M programme. As of 3 June 2026, more than 10,000 individuals hold the credential and more than 40,000 partner firms have applied to the network. That scale means the exam is already a meaningful signal in hiring conversations.

Domain weighting determines where to invest your study hours. The five domains are not equal:

Domains 1, 3, and 4 together account for 67% of the exam. If you are short on time, those three domains return the most marks per hour of study. Domain 5 is the smallest slice but it underpins every other domain: a shaky understanding of context state will cost you marks in agentic and prompt questions alike.

How should you sequence your study plan?

Start with Domain 1, then pair Domains 3 and 4 together, and finish with Domains 2 and 5 as a consolidation block. Here is the logic:

1. Domain 1 first (Agentic Architecture & Orchestration, 27%). The coordinator-subagent mental model recurs across every other domain. Understanding hub-and-spoke architecture and multi-agent error handling and routing before you study tool design or context management means you always have a structural frame to hang new concepts on.

2. Domains 3 and 4 together (Claude Code + Prompt Engineering, 20% each). These two domains share a common thread: deterministic, verifiable outputs. Claude Code configuration controls how Claude behaves in a repository; prompt engineering controls what it produces. Studying them in parallel reinforces the principle that structure beats improvisation.

3. Domain 2 (Tool Design & MCP Integration, 18%). By this point you understand agentic loops and structured outputs. Tool design is the bridge: how do you expose capabilities to the model without confusing it? The tool descriptions as selection mechanism concept is the single highest-leverage idea in this domain.

4. Domain 5 last (Context Management & Reliability, 15%). This domain synthesises everything. You will recognise the stale context problem and session management trade-offs much more clearly after you have worked through the other four domains.

What does Domain 1 actually test?

Domain 1 (27%) is the heaviest domain and the one candidates most often underestimate. It tests your ability to design and debug agentic loops, not just describe them.

The exam consistently rewards deterministic solutions over probabilistic ones when stakes are high. That principle shows up in questions about prompt-based vs programmatic enforcement: when a workflow has compliance or financial consequences, a hard-coded gate beats a model-level instruction every time.

Key concept clusters to master in Domain 1:

• Loop mechanics. How does the model signal that it wants to call a tool versus that it has finished? The stop_reason field is the canonical signal. Misreading it is a common source of premature loop termination.
• Coordinator responsibilities. The coordinator must select subagents dynamically, pass structured context, and handle errors without losing task state. See coordinator dynamic subagent selection for the decision logic.
• Decomposition strategy. Fixed sequential pipelines suit predictable tasks; dynamic adaptive decomposition suits tasks where the shape of the work is unknown at the start. The exam tests whether you can pick the right one for a given scenario.
• Session management. When do you resume a session, fork it, or start fresh? Each choice has context and cost implications.

What makes Domain 2 (Tool Design & MCP) hard to pass?

Domain 2 (18%) is deceptively difficult because its questions look like common sense but reward precise vocabulary. The most tested failure mode is tool misrouting: Claude selects the wrong tool because two tools have overlapping or ambiguous descriptions.

The fix is almost always a description rewrite, not a model change. The low-effort high-leverage fix principle captures this: before you restructure your tool registry, check whether a one-sentence clarification in the description resolves the ambiguity.

MCP-specific concepts that appear frequently:

• The isError flag pattern and how it differs from a valid empty result
• Environment variable expansion in MCP configuration files
• The MCP scoping hierarchy (user-level vs project-level vs server-level)
• When to build a custom MCP server versus consume an existing one

A common exam trap: a question describes a tool that returns an empty array and asks whether the agent should treat it as an error. The correct answer depends on whether the empty array is a valid business state (no results found) or a signal that the data source was unreachable. These are categorically different, and the exam expects you to distinguish them.

How do Domains 3 and 4 overlap in practice?

Domain 3 (Claude Code Configuration & Workflows, 20%) and Domain 4 (Prompt Engineering & Structured Output, 20%) share a core principle: explicit structure outperforms implicit instruction.

In Domain 3, that principle manifests as the three-level CLAUDE.md hierarchy. Project-level files set team-wide conventions; user-level files set personal preferences; sub-directory files set path-specific rules. The exam tests whether you know which level to use for a given requirement and what happens when levels conflict.

In Domain 4, the same principle manifests as JSON schema validation and few-shot examples. A schema enforces output shape; few-shot examples calibrate tone, field selection, and edge-case handling. The exam frequently presents a scenario where a model is producing structurally correct but semantically wrong output, and asks which intervention fixes it. The answer is almost always few-shot examples, not a schema change.

{
  "type": "object",
  "properties": {
    "status": { "type": "string", "enum": ["approved", "rejected", "escalated"] },
    "reason": { "type": "string", "minLength": 10 },
    "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
  },
  "required": ["status", "reason", "confidence"]
}

The schema above enforces structure. It cannot enforce that the reason field is logically consistent with the status field. That is where few-shot examples do work the schema cannot.

Domain 3 also tests plan mode versus direct execution. Plan mode is appropriate when the task requires exploring an unfamiliar codebase before writing any code. Direct execution is appropriate when the task is well-scoped and the conventions are already captured in CLAUDE.md. The exam will give you a scenario and ask which mode is correct; the answer traces to how much uncertainty exists at the start of the task.

What does Domain 5 test about context management?

Domain 5 (Context Management & Reliability, 15%) tests your ability to keep long-running agents reliable as context grows. The core problem is that context windows are finite and attention is not uniform: content in the middle of a long context receives less model attention than content at the start or end. This is the attention dilution problem, and it compounds over multi-turn sessions.

The exam tests three remediation patterns:

A question type that appears in Domain 5: a multi-turn customer support agent is producing responses that contradict earlier decisions in the same session. What is the root cause and what is the fix? The root cause is stale or diluted context; the fix is either a structured context-passing pattern or a session reset with summary injection, depending on how far the session has drifted.

How should you use practice exams and the concept library?

Our concept library at /concepts maps 174 atomic concepts to the five domains and all 30 task statements. Each concept is a discrete, testable idea, not a chapter summary. The adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold, which means it will keep routing you back to concepts where your response pattern suggests uncertainty, even if you answered the last question correctly.

Practice exams on our platform are 60 questions, scored 100 to 1000 on the same scale as the real exam, with 720 as the passing bar. Use them diagnostically, not as a final rehearsal. After each attempt, sort your wrong answers by domain and look for clusters. A cluster in Domain 1 usually means a gap in loop mechanics or decomposition strategy. A cluster in Domain 4 usually means a gap in few-shot application or schema design.

The exam rewards root-cause tracing over surface-level fixes. When a practice question describes a broken system, resist the temptation to pick the answer that sounds most active. The correct answer is usually the one that addresses the structural cause, not the one that patches the symptom.

One study pattern that works well: for each domain, work through the concept library in dependency order, then take a domain-filtered practice set, then review wrong answers with Archie, our Socratic tutor. Archie will not give you the answer directly; it will ask you questions that surface the gap in your reasoning. That process is slower than reading a summary, but it produces durable understanding rather than short-term recall.

What exam-day tactics improve your score?

The CCA-F is delivered online-proctored or at a test centre. Sixty questions, no stated time limit published per question, but plan for roughly 90 minutes total.

Tactical notes:

• Read the scenario before the options. Each question is scenario-based. The scenario contains the signal; the options contain the distractors. Forming a hypothesis before reading the options reduces anchoring on plausible-sounding wrong answers.
• Identify the stakes first. The exam consistently favours deterministic, programmatic solutions when the scenario involves compliance, financial data, or irreversible actions. If the scenario describes a high-stakes context, eliminate answers that rely on model judgement alone.
• Proportionate fixes. When a question asks how to fix a broken system, the correct answer is usually the smallest change that addresses the root cause. Answers that propose architectural rewrites for a description-level problem are almost always wrong.
• Distractor pattern: the adjacent domain. Anthropic writes distractors that are correct in a different context. A tool design answer might be technically accurate but wrong for an agentic loop question. Always anchor your answer to the domain the question is actually testing.

The agentic loop anti-patterns concept page is worth reviewing the day before the exam. It consolidates the most common wrong answers into a single reference.