CCA-FAnthropicClaudeCertification GuideAI Architecture

Claude Certified Architect (CCA-F / CCAR-F) Certification: Complete Guide [2026]

Preporato TeamNovember 16, 202617 min readCCA-F
Claude Certified Architect (CCA-F / CCAR-F) Certification: Complete Guide [2026]

CCA-F (Claude Certified Architect - Foundations) is Anthropic's certification for solution architects who design and build production applications with Claude. Pearson VUE now lists the same exam as CCAR-F, and many people write it CCAF. The exam has 60 questions in 120 minutes, costs $125, needs 720 out of 1,000 to pass, and covers five domains: agentic architecture and orchestration, tool design and MCP integration, Claude Code configuration and workflows, prompt engineering and structured output, and context management and reliability. This guide takes each domain in turn, then the seven anti-patterns the exam punishes, a study timeline and what changed for the exam in 2026.

A typical CCA-F question looks like this. A support agent built on the Claude Agent SDK tells a customer there are no orders on their account, because the order system timed out and the lookup tool returned an empty list as though the search had run and found nothing. The exam asks what to change, and the answer it grades as correct is a tool that reports the failure as a structured error, with the error's category and whether a retry makes sense, so the agent can try the lookup again or tell the customer the system is down.

Every CCA-F question belongs to a production scenario like that support agent, and each exam draws 4 scenarios at random from a published bank of 6. Anthropic writes the exam for solution architects with six months or more of hands-on work across the Claude API, the Agent SDK, Claude Code and the Model Context Protocol (MCP). As of October 2026, only people who work at Claude Partner Network organizations can register, and they sign in with a company email on their organization's partner domain.

Free questions

Try 15 CCA-F practice questions free

They come from the CCA-F practice tests, and each option shows its explanation once you answer.

  • 6 timed practice exams
  • Every answer explained
  • A score for each domain
  • $19.99 one-time

Exam Quick Facts

Duration
120 minutes
Cost
$125 USD
Questions
60 questions
Passing Score
720 out of 1000
Valid For
1 year
Format: Pearson VUE test center or online proctored

What's New for CCA-F in 2026

Updates verified October 2026:

  • The exam code is now CCAR-F. Pearson VUE lists the exam as Claude Certified Architect - Foundations (CCAR-F), named like CCAR-P, CCDV-F and CCAO-F. CCA-F (often written CCAF) and CCAR-F are the same exam, and this guide keeps the older CCA-F that most study material still uses.
  • Pearson VUE delivery since June 30, 2026. You sit CCA-F online with a live proctor or at a Pearson test center, and passing badges now arrive through Credly. The fee rose from $99 to $125 on the same date.
  • Japanese is now an exam language. Anthropic offers the exam and its prep content in English and Japanese, and published Japanese versions of all four exam guides in October 2026.
  • Partners get exam discounts. Select, Preferred and Global Premier partners get 50% off, and Global Premier partners pay nothing through December 31, 2026. Anthropic has announced no date for opening registration to people outside partner organizations.
  • Retake rules are published. Each retake costs the full fee, the waits are 14, 30 and 90 days after the first, second and third fail, and you can sit CCA-F at most four times in any 12 months. Our registration guide covers booking, rescheduling and retakes step by step.
  • The official practice exam is gone. Anthropic retired it in the move to Pearson, and the sample questions in the exam guide are the only official practice material left.

Why CCA-F Matters in 2026

Anthropic opens its certification exams to the Claude Partner Network, the organizations that deliver Claude for clients, and describes the exams as testing the work of scoping, designing, building and running Claude deployments on customer engagements. CCA-F is the foundations-level architect exam. The program also has an Associate exam (CCAO-F) for people who use Claude at work, a Developer exam (CCDV-F), and the Architect Professional exam (CCAR-P) a level above CCA-F. The Claude certifications overview compares all four, and What is CCA-F? is a shorter introduction to this one.

The questions are built from problems that come up on those engagements. A research subagent writes a thin report although the coordinator had already found what it needed. Coding rules meant for a whole team show up in only one developer's Claude Code sessions. And when a contract names no governing law, an extraction pipeline invents one. The three questions below come from the free CCA-F sample and cover those situations, and their explanations show the reasoning the exam expects.

Three quick CCA-F questions

Question 1 of 3Agentic Architecture & Orchestration

Your multi-agent research system uses a hub-and-spoke architecture where a coordinator agent dispatches tasks to specialized subagents (market research, patent search, competitor analysis). A subagent needs context about the overall research objective. What is the correct way to provide this context?

Pick one answer

Full CCA-F set: 6 timed exams, every answer explained, $19.99 one-time.

See the practice tests

CCA-F Exam Overview

The 6 production scenarios that ground all CCA-F exam questions
The 6 production scenarios that ground all CCA-F exam questions

Exam Format and Structure

The exam has 60 questions and a 120-minute limit, an average of 2 minutes a question. Some are multiple-response items, and each of those states how many options to select. The 60 questions are spread across the 4 scenarios you are given, an average of 15 per scenario.

CCA-F Exam Format Details

AspectDetails
Total Questions60 multiple-choice and multiple-response
Time Limit120 minutes
Passing Score720 out of 1000
ProctoringPearson VUE: online proctored or test center
Question TypesEach item states how many options to select
Production Scenarios6 available, 4 randomly selected per exam
Retake PolicyFull fee; waits of 14, 30 and 90 days; at most 4 attempts in 12 months
Validity1 year (free renewal assessment before expiration)
Cost$125 USD per attempt
RegistrationAnthropic Partner Academy (staff of Claude Partner Network organizations)
LanguagesEnglish or Japanese
PrerequisitesNone (experience recommended)

The Production Scenario Questions

Anthropic publishes the six scenarios in its exam guide, and your exam uses four of them, picked at random:

  1. Customer Support Resolution Agent. An Agent SDK agent handles returns, billing disputes and account issues through MCP tools such as get_customer, lookup_order, process_refund and escalate_to_human, with a target of 80% first-contact resolution and clear rules for when to escalate.
  2. Code Generation with Claude Code. A team uses Claude Code for generation, refactoring, debugging and documentation, with custom slash commands, CLAUDE.md files and a choice between plan mode and direct execution.
  3. Multi-Agent Research System. A coordinator delegates searching, document analysis, synthesis and report writing to subagents, and the system produces cited reports.
  4. Developer Productivity with Claude. An Agent SDK tool helps engineers explore unfamiliar codebases and legacy systems with the built-in Read, Write, Bash, Grep and Glob tools plus MCP servers.
  5. Claude Code for Continuous Integration. Claude Code runs in a CI/CD pipeline, reviewing code, generating tests and commenting on pull requests, and the feedback has to be actionable with few false positives.
  6. Structured Data Extraction. A system pulls information out of unstructured documents, validates it against JSON schemas, handles edge cases and passes the results to downstream systems.

A scenario leads into several questions, and they can come from different domains. The support agent alone can produce questions on the agent loop, on tool design and on escalation.

Programmatic vs Prompt-Based Enforcement

Across all five domains, the exam prefers a rule enforced in code over the same rule written into a prompt, and when you are torn between two options, the one that enforces the rule in code is usually the graded answer. Some of the places it appears:

  • Ordering and prerequisites: workflow code calls step B only after step A returns successfully. A prompt that says "complete step A before step B" can be skipped or reordered.
  • Output format: a tool_use JSON schema fixes the structure of the output, and validation with a retry loop catches the values a schema can't check. An instruction such as "always return valid JSON" still fails now and then.
  • Termination conditions: the loop reads the stop_reason field, where "tool_use" means run the tool and continue and "end_turn" means Claude has finished. Parsing Claude's text for words like "done" breaks on sentences that only sound final.
  • Escalation rules: code escalates on explicit triggers: the user asks for a human, the policy is ambiguous, or the agent has made no progress after a set number of attempts. Asking Claude to "escalate when it seems appropriate" leaves you with no rule you can test.

Scoring Methodology

CCA-F is scored from 100 to 1,000, and 720 passes. Anthropic set that cut score in a standard-setting study with subject matter experts, and scaled scoring evens out small differences in difficulty between versions of the exam, so 720 doesn't correspond to a fixed number of correct answers. Your result is pass or fail with the scaled score, and the score report also shows the percentage of questions you answered correctly in each domain. Those percentages are there to show your strengths and gaps, and the pass decision rests on the total scaled score alone.

The Five Exam Domains (Detailed)

Anthropic's exam guide splits CCA-F into five domains and lists task statements under each one, the specific skills the questions are written from.

CCA-F exam blueprint
domains · weights · format
what the exam weights
Agentic Architecture & Orchestration
0%
Claude Code Configuration & Workflows
0%
Prompt Engineering & Structured Output
0%
Tool Design & MCP Integration
0%
Context Management & Reliability
0%
the format
60
scored questions
120 min
time limit
720/1000
scaled pass mark
$125
exam fee · Pearson VUE
rehearse to the same blueprint
6 full-length tests · 390 questions · domain-proportional
free 20-question sampler first, no signup
Nearly half the exam is agents and Claude Code configuration. Study in the weights the blueprint gives you, and rehearse on tests that keep the same proportions.
The CCA-F blueprint: five domains, with agent architecture and Claude Code configuration making up nearly half the exam.

Domain 1: Agentic Architecture & Orchestration (27%)

Domain 1 is the largest, at 27% of the exam. It covers how an agent loop runs and stops, how a coordinator splits work across subagents, and how sessions are resumed or forked.

The Agentic Loop

An agent built on Claude runs in a loop: send the conversation to Claude, check whether the response asks for a tool, run the tool, send the result back, and repeat until Claude has finished.

Your code decides whether to continue by reading the stop_reason field of each response:

  • stop_reason = "tool_use" means Claude wants to call a tool. Your code should execute the tool and continue the loop.
  • stop_reason = "end_turn" means Claude has completed its response. Your code should exit the loop and return the result.
  • stop_reason = "max_tokens" means the response was truncated due to token limits. Your code should handle this as an edge case, potentially by requesting a continuation.

The wrong answers here parse Claude's text instead, checking whether it said "I'm done" or "Task complete". Claude can write "I've completed the first step" in the middle of a task and "I've completed everything" at the end, and string matching or a second LLM call that tries to tell the two apart adds errors where stop_reason already gives a clear signal.

An iteration cap such as "stop after 10 loops" is the other wrong answer when it is the main way the loop ends. Keep stop_reason as the signal and add a generous cap, say 50 or 100 iterations depending on the task, as a safety net that logs a warning when it trips, since hitting it usually points to a bug in the tools or the prompt.

The canonical pattern, in code:

while True:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=4096,
        messages=messages,
        tools=tools,
    )
    if response.stop_reason == "end_turn":
        break                                     # semantic completion, the primary signal
    if response.stop_reason == "tool_use":
        tool_result = execute_tool(response.content)
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_result})

Termination reads stop_reason, and the full assistant turn plus the tool result are appended before the next call, because the API is stateless and knows only what the message history tells it.

Agentic Loop Implementation Considerations

Three more details matter in a production loop:

Streaming vs Non-Streaming: In production, you often want to stream responses so that users see partial results in real-time. When streaming, the stop_reason is provided in the final event of the stream. Your implementation must handle both the streaming content events and the final stop event correctly.

Error Recovery Within the Loop: When a tool call fails, return the error to Claude as a tool result with structured details, so Claude can retry the tool, try another approach or tell the user. Exiting the loop on the first failure throws those options away.

Token Budget Management: Long-running agentic loops can run up large token costs. Production implementations should track cumulative token usage across loop iterations and implement budget controls. This is distinct from iteration caps: you might have a generous iteration cap but a strict token budget that terminates the loop if costs exceed a threshold.

Hub-and-Spoke Architecture

Applications that need several specialized capabilities use the hub-and-spoke pattern:

  • A coordinator agent (the hub): Receives the user's request, determines which specialized agent(s) to invoke, routes tasks appropriately, and synthesizes results.
  • Specialized subagents (the spokes): Each handles a specific domain or capability. For example, one subagent might handle database queries, another might handle document analysis, and a third might handle email composition.

The coordinator routes, delegates and combines results, and the subagents do the work. Splitting the roles this way has four benefits:

  1. Context efficiency: Each subagent only receives the context it needs, rather than the entire conversation history.
  2. Specialization: Each subagent can have its own system prompt, tool set, and behavioral configuration optimized for its specific task.
  3. Reliability: If one subagent fails, the coordinator can retry it or route to a fallback without affecting other subagents.
  4. Scalability: New capabilities can be added by creating new subagents without modifying existing ones.

Subagent Context Isolation

Subagents do not inherit the coordinator's conversation. A new subagent starts with an empty context and knows only what the coordinator puts in its prompt, so everything it needs has to be passed explicitly.

Isolation prevents three problems:

  • Context pollution: Subagents do not receive irrelevant information from other conversation threads.
  • Security: Sensitive information from the user's conversation does not leak to subagents that do not need it.
  • Predictability: Each subagent's behavior is determined only by what you explicitly provide, making the system easier to reason about and debug.

A typical question describes a subagent that "can't access" information the coordinator discussed earlier. The information never reached the subagent, and the fix is to include it in the prompt that creates the subagent.

Parallel Task Execution

In the Agent SDK, a coordinator spawns subagents through the Task tool, and it runs them in parallel by emitting several Task tool calls in a single response.

Parallel subagents follow three rules:

  • Independence requirement: Only parallelize tasks that are independent. If task B depends on the output of task A, they must run sequentially.
  • Result aggregation: The coordinator must gather results from all parallel tasks and synthesize them into a coherent response.
  • Error handling: If one parallel task fails, the coordinator must decide whether to retry it, skip it, or fail the entire operation. This decision depends on whether the task is critical or optional.

A typical question has a system searching several data sources at once. The coordinator launches one subagent per source in parallel, then merges and deduplicates the results.

Session Management

Long-running work gets interrupted and sometimes needs to branch, and two session features handle that:

  • --resume <session-name>: Continues a named session from where it stopped, with its conversation history intact.
  • fork_session: Creates an independent branch that starts from the current conversation history, for exploring an alternative without changing the original session.

Resume when you are continuing interrupted work, and fork when you want to try a direction without touching the main thread. Questions put these in situations such as a customer service agent comparing two resolution paths before committing to one (fork a session for each path) or a development agent that has to carry on after a system restart (resume its session).

Common Domain 1 Exam Patterns

Architecture Selection: Given a business requirement, you pick the architecture. A single agent fits a simple, focused task, hub-and-spoke fits work that needs several specializations, and parallel subagents fit independent operations on several data sources. The graded answer matches the architecture to the task, so the most elaborate option is often wrong.

Debugging Failures: A scenario describes a multi-agent system that is producing incorrect results. Common diagnoses include: subagent not receiving necessary context (context isolation violation), coordinator routing to the wrong subagent (tool description problem from Domain 2), or agentic loop not terminating properly (stop_reason not being checked).

Scaling Decisions: When a system needs to handle more volume, the usual answer is more parallel subagents or more agent instances, and making each agent more complex is usually wrong.

Practice Domain 1

Test your agentic architecture calls under exam conditions

Agentic loops, hub-and-spoke orchestration, subagent isolation and session handling make up 27 percent of the exam. The six CCA-F practice exams include 89 questions on this domain, each with the reasoning behind every option.

  • 6 timed practice exams
  • Every answer explained
  • A score for each domain
  • $19.99 one-time

Domain 2: Tool Design & MCP Integration (18%)

Domain 2, at 18% of the exam, covers how Claude reaches external systems through tools and the Model Context Protocol: how tools are described, how many an agent gets, how MCP servers are configured and how tools report errors.

Tool Descriptions as the Primary Routing Mechanism

Claude chooses a tool mainly by reading the tool descriptions. With several tools available, the description is what tells Claude which one fits the request, so a good description is:

  • Clear and specific: It says what the tool does, in more detail than the name.
  • Differentiating: If you have similar tools, the descriptions must clearly explain when to use each one.
  • Accurate about limitations: If a tool only works with certain input types or has specific requirements, say so in the description.
  • Action-oriented: It describes what the tool does and when to use it.

Vague or overlapping descriptions are a common cause of wrong tool choices, and questions ask you to spot the problem in a set of descriptions and fix it.

Optimal Tool Count

Anthropic's exam guide puts a number on this: an agent with 18 tools chooses less reliably than one with 4 or 5, because every extra tool makes the decision harder.

  • 4 or 5 tools per agent keeps the choice easy enough for Claude to tell the tools apart and pick the right one.
  • 18 tools is the guide's example of too many, where Claude picks the wrong tool more often.
  • Complex systems split their tools across agents. A hub-and-spoke design gives each specialized subagent its own focused set of 4 or 5 tools.

When a question describes a team whose agent started picking the wrong tools after they added more, the graded answer restructures the system so each agent has fewer, more focused tools. Better descriptions might help a little, and they are rarely the best option there.

tool_choice Configuration

The tool_choice parameter controls how Claude interacts with available tools:

  • auto (default): Claude decides whether to use a tool or respond directly. This is appropriate for most general-purpose agents.
  • any: Forces Claude to use one of the available tools. The model chooses which tool, but it must use one. This is useful for tool-focused workflows where a direct text response is never appropriate.
  • {type: "tool", name: "specific_tool"}: Forces Claude to use a specific named tool. This is useful for structured extraction or when you programmatically know which tool should be called.
  • none: Prevents Claude from using any tools. Useful for analysis or synthesis steps where tool use would be inappropriate.

Questions describe a workflow step and ask which tool_choice setting fits it.

MCP Configuration

MCP connects Claude to external tools and data sources through a standard protocol, and Claude Code reads MCP server settings at two levels:

  • Project-level configuration (.mcp.json): Located in the project root, this file configures MCP servers that are available to everyone working on the project. It is typically committed to version control.
  • User-level configuration (~/.claude.json): Located in the user's home directory, this file configures MCP servers that are specific to the individual user. It is not shared with the team.

Questions turn on scope. Project-level MCP configuration applies to everyone on the project and should contain shared tools (like a project-specific database connector). User-level configuration should contain personal tools (like a user's personal GitHub integration).

Environment Variable Expansion

MCP configuration files support environment variable expansion using the ${VARIABLE_NAME} syntax. For example, ${GITHUB_TOKEN} in a .mcp.json file will be replaced with the value of the GITHUB_TOKEN environment variable at runtime.

That keeps secrets out of a file the team commits: the configuration names the variable, and each environment supplies the value. Questions about MCP servers that need credentials expect this pattern.

Structured Error Handling in Tools

When a tool fails, the error it returns decides what Claude does next. The structured error in Anthropic's exam guide has three parts:

  • Error category: transient, validation or permission.
  • isRetryable flag: whether trying again could succeed, or Claude needs a different approach.
  • A human-readable description: what the tool was trying to do and what went wrong.

The wrong answers return a vague message like "tool call failed", or an empty result that hides the failure.

Access Failures vs Empty Results

The exam separates two outcomes that can look the same to Claude:

  • Access failure: The tool could not complete its operation (network error, authentication failure, timeout). Claude needs to know the operation failed so it can retry or try an alternative approach.
  • Empty result: The tool completed successfully but found no data. Claude needs to know the search succeeded but returned nothing, so it can inform the user rather than trying the same search again.

Return an empty result after an access failure, and Claude concludes the data doesn't exist and tells the user so with confidence.

Common Domain 2 Exam Patterns

Routing Accuracy Degradation: A team reports that Claude calls the wrong tool more often since they added tools. The usual diagnosis is too many tools on one agent, and the fix is to split them across specialized subagents in a hub-and-spoke design.

Tool Description Analysis: The exam may present two or more tool descriptions and ask which has a problem. Look for descriptions that are too vague ("handles data operations"), too similar to other tools (making routing ambiguous), or missing information about when to use the tool instead of the alternatives.

MCP Configuration Debugging: A scenario describes a team where MCP tools work for one developer but not others. The diagnosis typically involves configuration scoping issues: the working developer has the configuration in their user-level ~/.claude.json, but the project-level .mcp.json is missing or misconfigured. The fix is to add the shared configuration to .mcp.json in the project root.

Error Handling Design: Given a tool that can fail in multiple ways (authentication expired, rate limited, resource not found, server error), design the structured error response. The best answer includes the error category, the isRetryable flag and a description that helps Claude decide what to do next.

Practice Domain 2

Test yourself on tool design and MCP integration

Tool descriptions, tool_choice, MCP configuration and structured tool errors account for 18 percent of the exam. The practice exams include 76 questions on this domain, each explained option by option.

  • 6 timed practice exams
  • Every answer explained
  • A score for each domain
  • $19.99 one-time

Domain 3: Claude Code Configuration & Workflows (20%)

Domain 3, at 20% of the exam, covers Claude Code, Anthropic's agentic coding tool: where its instructions live, how skills, rules and hooks are set up, and how it runs in team workflows and CI.

CLAUDE.md Hierarchy

CLAUDE.md files provide instructions to Claude Code, and they follow a hierarchical scoping system:

  1. User-level (~/.claude/CLAUDE.md): Personal instructions that apply to all projects for a specific user. These might include preferred coding style, personal workflow preferences, or default behaviors.
  2. Project-level (./CLAUDE.md in project root): Instructions that apply to the entire project. These typically include project architecture, coding standards, testing requirements, and deployment procedures. This file is committed to version control and shared with the team.
  3. Directory-level (./src/components/CLAUDE.md): Instructions that apply only when working within a specific directory. These are useful for component-specific patterns, directory-specific conventions, or subsystem-specific requirements.

The hierarchy works through specificity: more specific (directory-level) instructions take precedence over more general (project-level) instructions, which take precedence over user-level instructions. All applicable levels are loaded and combined, with more specific instructions overriding general ones where they conflict.

The Team Instructions Trap

User-level CLAUDE.md instructions are not shared with the team. If a developer puts team coding standards in their personal ~/.claude/CLAUDE.md, those standards only apply when that specific developer is using Claude Code. Other team members will not see or follow those instructions.

The correct approach is to put shared team instructions in the project-level ./CLAUDE.md file (committed to version control) or in .claude/rules/ files within the project.

When a question says a team lead wrote coding standards that other developers' sessions ignore, check where the standards live. They are usually in the lead's user-level file.

Skills Frontmatter

Claude Code skills are reusable instruction sets that can be invoked on demand. They are defined with frontmatter that controls their behavior:

  • context: fork: The skill runs in an isolated sub-agent context, so its work and its verbose output stay out of the main conversation. A codebase-analysis skill that produces pages of output is the typical case.
  • allowed-tools: Specifies which tools the skill is allowed to use. This provides security boundaries, ensuring that a skill cannot use tools outside its intended scope.

Questions give a use case and ask which frontmatter options the skill needs.

Rules Files with Glob Patterns

Files in a project's .claude/rules/ directory can apply only to matching files, through a paths field of glob patterns in their YAML frontmatter. For example:

  • .claude/rules/react-components.md with paths: ["**/*.tsx"] applies whenever Claude Code works on TypeScript React files.
  • .claude/rules/api-routes.md with paths: ["src/routes/**/*"] applies inside the routes directory.

A glob can cover a convention that spans directories, such as every test file wherever it lives, which a directory-level CLAUDE.md can't do.

Hooks: Programmatic Enforcement

Hooks run shell commands at lifecycle events, and they are the exam's canonical example of the programmatic-over-prompt principle. The events with the most exam weight are PreToolUse (before a tool executes, able to block it), PostToolUse (after it completes, for linters and validation), and Stop (when Claude is about to finish, for verifying required steps actually ran).

Configuration in settings.json nests event, then matcher group, then hook handlers:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "if": "Bash(rm *)",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-destructive.sh"
          }
        ]
      }
    ]
  }
}

The script controls the outcome: exit 0 allows, exit 2 blocks, and a JSON permissionDecision: "deny" on stdout blocks with a structured reason. Two details to know for the exam: there is no dedicated commit event, so "always run tests before committing" is a PreToolUse hook matching Bash with an if filter on git commit, and hooks in the committed project settings.json reach the whole team while ~/.claude/settings.json hooks stay personal.

When a question asks how to guarantee a behavior, the answer is a hook. A CLAUDE.md instruction is guidance the model will probably follow, while a hook runs every time and the model can't skip it.

Plan Mode vs Direct Execution

Claude Code supports two primary modes of operation:

  • Plan Mode: Claude analyzes the task, creates a detailed plan, and presents it for review before making any changes. This is appropriate for complex refactoring, architectural changes, or any situation where an incorrect change would be costly.
  • Direct Execution: Claude analyzes and implements changes in a single pass. This is appropriate for well-understood, smaller changes where the risk of incorrect implementation is low.

Use plan mode when the scope is large, mistakes would be costly or the requirements are unclear, and direct execution for small, well-defined tasks.

CI/CD Integration

In a CI/CD pipeline, Claude Code runs with the -p (or --print) flag, which makes it non-interactive: it takes the prompt, does the work and prints the result without waiting for input, so the job can't hang on a question. Adding --output-format json returns the result as JSON for the next step to parse.

Common CI/CD use cases tested on the exam:

  • Automated code review: Claude Code reviews pull requests and provides feedback.
  • Documentation generation: Claude Code generates or updates documentation based on code changes.
  • Test generation: Claude Code writes tests for new or modified code.

Reviews should come from an independent instance. A session that wrote the code still holds the reasoning behind it and is less likely to question its own decisions, so a separate instance without that context catches more.

Common Domain 3 Exam Patterns

Configuration Hierarchy Debugging: A common Domain 3 question presents a scenario where Claude Code is not following expected instructions. You need to diagnose where the instructions are configured and whether they are at the correct level. User-level files are personal, project-level files are shared, and directory-level files apply to specific paths. The classic mistake is shared team standards placed at the user level.

Skills Configuration: Questions ask you to configure skills for specific use cases. Key decisions include whether to use context: fork (for exploratory or analytical skills that should not modify the main conversation) and which tools to allow. A security-sensitive skill (like one that generates deployment configurations) should have a restricted allowed-tools list to prevent unintended side effects.

CI/CD Pipeline Design: Beyond the -p flag, questions cover how the pipeline itself is set up. For code review pipelines, use a separate Claude Code instance from the one that generated the code. For documentation generation, configure appropriate CLAUDE.md instructions that specify documentation standards. For test generation, scope the Claude Code instance to only have access to testing-related tools and files.

Plan Mode Decision Making: The exam presents scenarios and asks whether Plan Mode or Direct Execution fits. Plan Mode suits large, complex or risky changes, such as a refactor across many files, a change to core business logic or a change to production configuration. Direct Execution suits small, well-understood, low-risk changes.

Build Domain 3

Ship a Claude Code skill, a permission set, and a headless review bot

The configuration-precedence and workflow questions in this 20 percent domain are graded from a working .claude directory and a CI review bot you build yourself.

Domain 4: Prompt Engineering & Structured Output (20%)

Domain 4, at 20% of the exam, covers prompts that give consistent results and output pipelines that guarantee structure: explicit criteria, few-shot examples, schemas, validation and the Batch API.

Explicit Criteria Over Vague Guidance

The exam favors prompts with explicit, measurable criteria over vague instructions. Compare:

Vague (anti-pattern):

"Write a good summary of this document."

Explicit (correct):

"Write a summary of this document in 3-5 sentences. Include: the main argument, the key evidence cited, and the conclusion. Use formal academic tone. Do not include direct quotes."

Each requirement in the second prompt can be checked, while "good" can't. With explicit criteria you can validate the output in code and retry when it falls short.

When a question describes inconsistent output, check the prompt for vague criteria first.

Few-Shot Examples

Examples in the prompt (few-shot prompting) make output more consistent and accurate, and four points about them come up:

  • Two to four examples is the range Anthropic's exam guide uses, aimed at the ambiguous cases where Claude would otherwise guess.
  • Edge cases belong in the examples. If inputs can be ambiguous, include one that shows how to handle the ambiguity and why that choice was made.
  • The examples show the output format you expect, with the same field names, data types and structure.
  • Varied examples cover different kinds of input, so Claude sees the range of expected behavior.

tool_use JSON Schemas

A tool with a JSON schema is the standard way to get structured output: when Claude answers through tool_use, the response follows the schema's structure.

A schema enforces structure, and checking the values stays your job. It guarantees the fields, data types and nesting, while the values inside can still be wrong or inconsistent. A schema can make an "age" field an integer, and only your code can check that the integer is a plausible human age.

A reliable pipeline has both:

  1. Schema enforcement for structural correctness (guaranteed by tool_use)
  2. Validation logic for semantic correctness (implemented in your code)

Nullable Fields and "Unclear" Enum Values

Documents often leave information out or state it ambiguously, and two schema choices handle that:

  • Nullable fields: Define schema fields as nullable when the information might not be present. Claude can then say "this information is not available" instead of inventing a value.
  • "Unclear" enum values: When a field uses an enum (a fixed set of allowed values), include an "unclear" or "ambiguous" option. Claude then has a valid way to signal uncertainty and isn't forced into a wrong category.

Downstream code can send null or "unclear" values to human review.

Validation Retry Loops

Even with a schema and explicit criteria, some output fails your validation rules. A validation retry loop handles it:

  1. Claude generates output (constrained by tool_use schema)
  2. Your code validates the output against semantic rules
  3. If validation fails, send the output AND the validation errors back to Claude
  4. Claude generates a corrected version
  5. Repeat until validation passes or a maximum retry count is reached

The retry prompt carries both the invalid output and the specific validation errors, which gives Claude what it needs to fix the mistake instead of repeating it.

The loop in code, with the two boundaries the exam tests marked:

prompt = document
for attempt in range(MAX_RETRIES):
    response = extract(prompt, schema=EXTRACTION_SCHEMA)     # tool_use forces the shape
    errors = validate_semantics(response)                     # your rules, beyond the schema
    if not errors:
        return response
    prompt = (
        f"The following extraction failed validation.\n"
        f"Original document:\n{document}\n"
        f"Failed extraction:\n{response}\n"
        f"Validation errors:\n{errors}\n"
        f"Re-extract, fixing only the identified errors."
    )
raise ExtractionFailed(errors)   # retries fix execution errors, never absent data

The schema eliminated syntax errors before the loop started; the loop handles semantic ones; and the final raise exists because a required field absent from the source will fail every retry identically, which is the signal to redesign the schema with nullable fields rather than raise MAX_RETRIES.

The Batch API

The Message Batches API takes a large set of requests at once, at half the price and with no latency guarantee:

  • Cost: 50% less than the same calls made in real time.
  • Latency: Results arrive within a 24-hour processing window, with no guaranteed latency inside it.
  • Limitations: A batch request can't run a tool loop, because Claude can't call a tool and get the result back within one request.
  • Use cases: Large-scale document processing, data extraction, content generation where real-time response is not required.

The wrong answer to watch for is the Batch API in a blocking workflow. Results might come back in 5 minutes or in 23 hours, so any step that waits on them stalls for an unpredictable time. Batches suit background processing.

Multi-Instance Review

For outputs where errors are costly, the exam uses a multi-instance review:

  1. Generate the output with one Claude instance
  2. Review the output with a separate, independent Claude instance
  3. If the reviewer identifies issues, either flag for human review or send back for correction

The reviewer has to be a separate instance, the same rule as code review in Domain 3, because the instance that generated the output carries its own reasoning and tends to repeat its blind spots.

Common Domain 4 Exam Patterns

Prompt Diagnosis: The exam presents a prompt that produces inconsistent results and asks you to identify the problem. Common diagnoses include vague criteria (replace with explicit, measurable specifications), missing examples (add 2-4 diverse few-shot examples), or format ambiguity (add a tool_use schema to enforce structure).

Schema Design: Given a data extraction task, design the tool_use schema. The graded schema includes nullable fields for optional or uncertain data, "unclear" enum values for ambiguous categories, and appropriate data types. A common trap is designing a schema that only handles the happy path and fails when real-world data is messy or incomplete.

Batch API Appropriateness: The exam describes a processing pipeline and asks whether the Batch API fits. Ask whether anything waits on the results in real time. If something does, the Batch API is the wrong choice whatever it saves, and if nothing does and the volume is large, its 50% discount makes it a good fit. A task that needs Claude to call tools and act on the results can't run inside a single batch request.

Validation Pipeline Design: The exam may ask you to design a complete validation pipeline for structured output. The correct answer typically involves three layers: tool_use schema for syntactic enforcement, programmatic validation for semantic correctness (business rules, data consistency, range checks), and a retry loop that sends validation errors back to Claude for correction. An answer missing one of the three layers is incomplete.

Practice Domain 4

Test yourself on prompt engineering and structured output

Explicit criteria, few-shot examples, tool_use schemas, validation retry loops and the Batch API account for 20 percent of the exam. The practice exams include 84 questions on this domain, each with the reasoning behind every option.

  • 6 timed practice exams
  • Every answer explained
  • A score for each domain
  • $19.99 one-time

Domain 5: Context Management & Reliability (15%)

Domain 5, at 15% of the exam, covers what keeps a long-running system accurate and recoverable: long contexts, escalation, error propagation, crash recovery and human review.

The Lost-in-the-Middle Phenomenon

In a long context, language models, Claude included, use information near the beginning and the end more reliably than information in the middle. The effect is known as "lost in the middle", and three mitigations come up:

  1. Persistent case facts at the top: If some information must be referenced throughout a conversation (like a customer's account details or a legal clause under analysis), place it at the beginning of the context where attention is highest.
  2. Trim verbose outputs: When tool results or retrieved documents are very long, trim them to include only the relevant portions. Less total context means less "middle" for information to get lost in.
  3. Summaries at the top: For long conversations, periodically create summaries of the key information and place them at the beginning of the context. This ensures that the most important facts are in the high-attention zone.

When a question has an agent "forgetting" information it was given earlier, think of this effect first, and look for the answer that moves the information or shortens the context.

Escalation Triggers

An agent should hand a case to a human on three triggers:

  1. The user explicitly requests a human. If the user says "I want to talk to a person" or "transfer me to a human agent," the system complies immediately.
  2. The policy is ambiguous. If the agent encounters a situation where the applicable policy is unclear (for example, a refund request that falls between two policy categories), it should escalate rather than guess.
  3. The agent has made no progress. If the agent has attempted the same approach multiple times without making progress (typically defined as N attempts with no state change), it should escalate.

Two other signals look useful, and the exam treats both as wrong answers:

  • Sentiment. Escalating because "the customer seems angry" ties the decision to tone, and tone says little about whether a case is complex or outside policy. An upset customer with a simple refund can be served, while a polite one with a policy gap still needs a human.
  • Self-reported confidence. Asking Claude how confident it is and escalating below a threshold fails because a model's confidence in its own answers is poorly calibrated.

Structured Error Propagation

When a subagent or tool fails, what it passes up decides what the coordinator can do next. A structured error carries:

  • Error type and code: A machine-readable classification of what went wrong.
  • Context: What the system was trying to do when the error occurred.
  • Retryable flag: Whether the error is transient or permanent.
  • Partial results: If the system completed some work before the error, those results should be preserved.
  • Suggested action: What the system or user should do next.

The wrong answers log errors without passing them to the agent, or pass them as plain text that code can't act on.

Context Degradation Strategies

Long sessions fill the context window, and three techniques keep them workable:

  • Scratchpad pattern: The agent maintains a structured scratchpad that summarizes key information from the conversation. When the context grows too long, the scratchpad keeps the important facts while the raw conversation history is trimmed.
  • Subagent delegation: For complex tasks that would consume too much context in a single agent, delegate subtasks to subagents. Each subagent gets a fresh context with only the information it needs, and returns a compact result to the coordinator.
  • /compact command: In Claude Code, the /compact command summarizes the current conversation and starts a fresh context with the summary. This is the manual trigger for context management.

Scratchpads suit a single agent whose context grows gradually, subagent delegation suits systems that process large volumes of varied information, and /compact suits interactive sessions where a person can trigger it.

Crash Recovery with Manifest Files

For crash recovery, the exam uses manifest files:

  1. Before starting a batch of work, write a manifest file that describes all the tasks to be completed.
  2. As each task completes, update the manifest to record the completion status.
  3. If the system crashes and restarts, read the manifest to determine which tasks were completed and which need to be retried.

After a restart, finished tasks are skipped and unfinished ones are retried, so no work is lost or done twice. The manifest holds the task list, each task's status and any partial results.

Human Review with Stratified Sampling

Reviewers can't check every output, and stratified sampling decides which ones they see:

  • Stratify by risk: Classify outputs into risk categories (e.g., low-risk routine responses, medium-risk edge cases, high-risk financial or medical outputs).
  • Sample proportionally: Review a higher percentage of high-risk outputs and a lower percentage of low-risk outputs.
  • Use the results to improve: Track which categories have the highest error rates and use that data to improve the system (better prompts, additional validation, new tools) and adjust sampling rates.

Reviewing everything doesn't scale, and a plain random sample spends most of the review time on routine outputs. Sampling by category spends it where errors cost the most.

Common Domain 5 Exam Patterns

Context Degradation Diagnosis: The exam describes an agent that becomes less accurate or starts "forgetting" information over long conversations. The diagnosis involves identifying the lost-in-the-middle effect and recommending appropriate mitigation: moving the important information to the top of the context, trimming verbose tool outputs, using the scratchpad pattern for persistent facts, or delegating to subagents to keep per-agent context manageable.

Escalation Policy Design: Given a business scenario (e.g., customer service, financial advisory, medical triage), design the escalation policy. The graded answer uses the three triggers (explicit human request, ambiguous policy, no progress) and leaves out sentiment and self-reported confidence, even when an option adds sentiment "as an additional safety measure".

Recovery Scenario: The exam describes a long-running agent that crashes mid-operation. The correct recovery approach depends on the scenario: manifest files for batch processing operations, session resumption (--resume) for interactive sessions, and checkpoint-based recovery for multi-stage pipelines. The question is which recovery pattern fits the operational context.

Human Review Workflow Design: Given a production system processing a specified volume of outputs per day, design the human review workflow. The correct answer involves stratified sampling based on risk classification, with higher review rates for high-risk categories. The review results then feed back into the system's prompts, validation and sampling rates.

The CCA-F exam domains breakdown goes through each domain with more scenarios and worked examples.

Practice Domain 5

Test yourself on context management and reliability

Lost-in-the-middle effects, escalation triggers, error propagation and crash recovery account for 15 percent of the exam. The practice exams include 59 questions on this domain, each explained option by option.

  • 6 timed practice exams
  • Every answer explained
  • A score for each domain
  • $19.99 one-time

Seven Anti-Patterns You Must Know

Programmatic enforcement versus prompt-based guidance
Programmatic enforcement versus prompt-based guidance

Anti-Pattern 1: Prompt-Based Task Ordering

Wrong approach: Telling Claude "First complete step A, then step B, then step C" in the system prompt and hoping it follows the order.

Why it fails: Claude may skip steps, reorder them or start a later step before an earlier one is complete, because nothing enforces an instruction in a prompt. The more steps a workflow has, the more chances the order has to slip.

Correct approach: Use programmatic prerequisites in your orchestration code. Step B's function only executes after step A returns a success result. Your code enforces the order, whatever Claude makes of the prompt.

Exam tip: When you see an answer choice that says "add instructions to the prompt specifying the order," it is usually wrong. Look for the answer that implements the ordering in code.

Anti-Pattern 2: Self-Reported Confidence for Escalation

Wrong approach: Asking Claude "On a scale of 1-10, how confident are you in this answer?" and escalating to a human when the confidence is below a threshold.

Why it fails: LLM self-assessed confidence is poorly calibrated. Claude may report high confidence for incorrect answers and low confidence for correct ones. The score is more text from the same model, with no independent check behind it.

Correct approach: Use programmatic escalation triggers: the user explicitly requests a human, the applicable policy is ambiguous, or the agent has made no progress after N attempts. Code can observe each of these conditions directly.

Exam tip: Any answer choice involving self-assessed confidence, self-reported certainty, or sentiment-based escalation is a red flag. Look for answers with concrete, programmatic triggers.

Anti-Pattern 3: Batch API for Blocking Workflows

Wrong approach: Using the Batch API for operations where downstream processes are waiting for the results, such as in a request-response pipeline where the user is waiting for output.

Why it fails: The Batch API provides results within 24 hours but offers no SLA within that window. Your results might come back in 3 minutes or 20 hours. Any workflow that blocks on Batch API results is unpredictable and potentially very slow.

Correct approach: Use the real-time API for blocking workflows. Reserve the Batch API for background processing where the 50% cost savings justify the unpredictable latency: document processing overnight batches, data enrichment pipelines, content generation queues.

Exam tip: When a scenario mentions cost savings as the primary motivation for using the Batch API, check whether the workflow is blocking. If it is, the cost savings do not justify the latency risk.

Anti-Pattern 4: Larger Context Equals Better Attention

Wrong approach: Stuffing as much information as possible into the context window, believing that more context gives Claude more to work with and therefore better results.

Why it fails: The lost-in-the-middle phenomenon means that information in the middle of large contexts receives less attention. Additionally, larger contexts slow down inference, increase costs, and increase the chance of the model being distracted by irrelevant information.

Correct approach: Use per-file or per-section passes. Instead of putting all 50 documents in a single context, process each document (or small batch) in a separate API call with a focused prompt. Then aggregate the results. For analysis tasks that require cross-document comparison, use a two-pass approach: extract key facts from each document individually, then compare the extracted facts in a synthesis pass.

Exam tip: When a scenario involves large volumes of information and accuracy problems, look for answers that reduce context size per call rather than answers that increase the context window.

Anti-Pattern 5: Silent Empty Results on Failure

Wrong approach: When a tool call fails (network error, authentication failure, timeout), returning an empty result set as if the search had found nothing.

Why it fails: Claude interprets empty results as "the search completed successfully but found no matches." This leads Claude to confidently tell the user "no results were found" when in reality the search failed to execute. The user receives a confident but completely wrong answer.

Correct approach: Return structured errors that distinguish between access failures and empty results. An access failure should include the error type, whether it is retryable, and contextual information. An empty result should explicitly confirm that the search completed successfully but returned no matches. Claude needs to know which of the two happened.

Exam tip: When you see a scenario where Claude gives confidently wrong "no results" answers, the root cause is usually a tool failure masked as an empty result.

Anti-Pattern 6: All Tools Available to All Agents

Wrong approach: Making every tool available to every agent in the system, giving each agent maximum flexibility.

Why it fails: As Domain 2 covers, an agent choosing among 18 tools picks less reliably than one with 4 or 5. Giving every tool to every agent makes each of them choose from the full set, and wrong tool choices spread across the whole system.

Correct approach: Scope tools to the agents that need them. Use the hub-and-spoke architecture where the coordinator routes to specialized subagents, each with a focused set of 4-5 tools. A database subagent gets database tools. An email subagent gets email tools. Neither needs the other's tools.

Exam tip: When a scenario describes a flat architecture with many tools and routing problems, look for the answer that splits the tools across specialized agents. Better descriptions might help a little, and they aren't the best answer.

Anti-Pattern 7: Prompt-Only JSON Enforcement

Wrong approach: Relying solely on prompt instructions like "Always respond in valid JSON format" or "Return your answer as a JSON object with the following fields" to ensure structured output.

Why it fails: Claude follows JSON formatting instructions most of the time and occasionally returns malformed JSON, missing or extra fields, or wrong data types. At high volume, a 1% failure rate means thousands of broken records a day.

Correct approach: Use tool_use JSON schemas for syntactic enforcement (guarantees correct structure), then add programmatic validation for semantic correctness, then implement a retry loop that sends validation errors back to Claude for correction.

Exam tip: When a scenario describes intermittent JSON formatting problems, look for the answer that adds schema enforcement and validation. Rewording the prompt instructions is the weakest of the options.

Study Timeline

Four-phase study plan from foundations to exam day
Four-phase study plan from foundations to exam day

We suggest 8 weeks if you already build with Claude, and 10 to 12 if you are new to it, since Anthropic's exam guide assumes six months or more of hands-on experience and newcomers need the extra weeks for building. Keep the CCA-F cheat sheet open while you study; it puts the decision rules from every domain on one page.

Foundations

Weeks 1-2
  • •Complete Anthropic Academy courses: Claude 101 and Building with the Claude API
  • •Read the Claude API reference documentation end-to-end
  • •Review the Agent SDK getting started guide
  • •Build a simple single-agent application using the API
  • •Study the agentic loop pattern and implement stop_reason checking
  • •Review the MCP protocol overview documentation

Domain by Domain

Weeks 3-4
  • •Study Domain 1 in depth: build a hub-and-spoke multi-agent system
  • •Study Domain 2: implement 3-4 custom tools with proper descriptions and error handling
  • •Study Domain 3: configure CLAUDE.md hierarchy, skills, and rules files
  • •Study Domain 4: build a structured output pipeline with tool_use schemas and validation
  • •Study Domain 5: implement context management with scratchpad pattern
  • •Complete Anthropic Academy courses: Prompt Engineering and Claude Code

Hands-On Practice

Weeks 5-6
  • •Build a production-grade project combining all 5 domains
  • •Implement crash recovery with manifest files
  • •Create a parallel task processing system with error handling
  • •Practice configuring MCP servers with environment variable expansion
  • •Build a Batch API pipeline for background document processing
  • •Implement escalation logic with proper programmatic triggers

Exam Preparation

Weeks 7-8
  • •Take practice tests on Preporato and review incorrect answers thoroughly
  • •Study all 7 anti-patterns until you can explain why each is wrong
  • •Review the programmatic vs prompt-based distinction across all domains
  • •Take a second round of practice tests and track improvement
  • •Review any domains where practice test scores are below 80%
  • •Complete a final full-length practice exam under timed conditions
  • •Rest the day before the exam

Phase-by-Phase Breakdown

Phase 1: Foundations (Weeks 1-2) focuses on building core knowledge. If you already use the Claude API regularly, this phase might go quickly. The key is ensuring you have no gaps in the fundamentals: API mechanics, the agentic loop, basic tool use, and MCP concepts. Check the details even if the basics feel familiar, because the exam asks about specifics that everyday use doesn't teach, such as the difference between --resume and fork_session.

Phase 2: Domain by Domain (Weeks 3-4) gives each domain a focused project. Build a working example of each major pattern as you read about it: hub-and-spoke, structured output with validation, CLAUDE.md configuration and context management.

Phase 3: Hands-On Practice (Weeks 5-6) integrates everything into larger, more realistic projects. Push a system until something breaks, such as a context that degrades over a long session or tools that get misrouted, and fix it, because those failures are what the scenario questions describe.

Phase 4: Exam Preparation (Weeks 7-8) focuses on practice tests, review, and filling gaps. Take a practice test, then review every answer you missed: why the graded option wins and why each of the others loses. Anti-pattern questions deserve extra attention.

Preparation Resources

Anthropic Academy

The Anthropic Partner Academy (hosted on Skilljar) offers free courses covering the Claude platform, along with the certification preparation courses and exam registration itself. These are the closest thing to "official study material" for the CCA-F exam. Courses particularly relevant to CCA-F include:

  • Claude 101: Core concepts, API basics, and fundamental usage patterns.
  • Building with the Claude API: The API in depth, including tool use, streaming and advanced parameters.
  • Prompt Engineering: Prompt engineering techniques and Claude-specific practices.
  • Claude Code: Configuration, workflows, and development patterns.
  • Agent SDK: Building agentic applications with the official SDK.
  • MCP (Model Context Protocol): Understanding and implementing MCP integrations.

The courses are free and self-paced. Take the ones that match the exam domains even if you are experienced, since they cover the same features and recommended practices the exam guide lists.

Official Documentation

Anthropic's official documentation is the authoritative reference:

  • Claude API Reference: Complete API documentation including all parameters, response formats, and error codes.
  • Agent SDK Documentation: Building agents, the agentic loop, multi-agent patterns, and session management.
  • Claude Code Documentation: CLI usage, configuration, CLAUDE.md, skills, rules, and CI/CD integration.
  • MCP Specification: Protocol details, server configuration, and tool definition formats.

Practice Tests

Practice tests show where you stand, which domains to study next and whether your pacing holds over a full exam.

We make the preporato.com CCA-F practice tests, so weigh this paragraph accordingly. There are 6 timed tests of 65 questions (390 in total), split across the domains in the blueprint's proportions, with an explanation for every option and a score for each domain, plus a 500-card flashcard deck. The free questions on the certificate page come from the same tests, so you can check the question style before you buy.

CCA-F Preparation Resources Compared

ResourceTypeCostBest For
Anthropic AcademySelf-paced coursesFreeFoundational knowledge across all domains
Official documentationReference docsFreeExact behavior of APIs, parameters and configuration
preporato.com practice testsTimed practice examsOne-time purchaseExam rehearsal, finding weak domains, pacing
Claude API (hands-on)Building projectsAPI usage costsPractical experience with each pattern

How to Use Resources Effectively

Work through them in this order:

  1. Start with Anthropic Academy courses to build foundational understanding.
  2. Read official documentation to fill in the details.
  3. Build hands-on projects to develop practical skills and intuition.
  4. Take practice tests to identify gaps and calibrate your knowledge.
  5. Return to documentation and building to address the gaps identified by practice tests.
  6. Take more practice tests to verify that the gaps are closed.

Building Effective Study Habits

Build what you read about: When you meet a concept in the documentation, build a small project that uses it. The scenario questions describe systems in production, and having built one makes the options easier to judge.

Spaced repetition for the anti-patterns: Review the seven anti-patterns every few days with flashcards or a one-page sheet, until you can name each one and its correct alternative without hesitating.

Study with colleagues: Registration runs through partner organizations, so the people most likely to be preparing alongside you work at your own company. Explaining a concept to one of them shows you quickly where your own understanding has gaps.

Practice Under Exam Conditions: At least twice during your preparation, take a full-length practice test under realistic exam conditions: timed, without external resources, and in a quiet environment. This builds stamina and shows whether your pacing holds.

With less time, the CCA-F 30-day study plan fits the preparation into four weeks.

The CCA-F exam format guide covers check-in, proctoring and room requirements for exam day.

Exam Day Strategy

A focused exam workspace ready for the proctored CCA-F exam
A focused exam workspace ready for the proctored CCA-F exam

Time Management

You have 120 minutes for 60 questions, an average of 2 minutes each, spread across your four scenarios. A question you recognize can take 30 seconds, while a multiple-response question with long options can take four minutes, so the average hides a wide range.

A three-pass plan:

  1. First pass (70-80 minutes): Work through all 60 questions. Answer the ones you know confidently. Flag the ones you are unsure about.
  2. Second pass (30-40 minutes): Return to flagged questions. With the pressure of the "first look" removed, you often find that the answer is clearer on the second reading.
  3. Final review (10 minutes): Check for any unanswered questions or obvious mistakes.

Reading Scenarios Carefully

Every question hangs off a scenario, and the scenario's details decide between options that would each work somewhere else. For each question:

  1. Read the entire scenario before looking at the question. Understand the system architecture, the problem, and the constraints.
  2. Identify the domain being tested. Is this about agentic architecture, tool design, configuration, prompt engineering, or reliability? The domain tells you which principles to apply.
  3. Look for anti-patterns in the scenario description. Many scenario questions describe a system with a specific problem and ask you to diagnose it. The problem is often one of the seven anti-patterns.
  4. Note the constraints. Production scenarios include constraints like latency requirements, cost budgets, or compliance requirements that eliminate certain answer choices.

The Elimination Technique

When you are not sure of the answer, eliminate wrong choices rather than trying to identify the right one:

  1. Eliminate prompt-based solutions when programmatic alternatives are available. This alone removes one or two options on many questions.
  2. Eliminate anti-patterns. If an answer choice implements one of the seven anti-patterns, eliminate it.
  3. Eliminate over-engineered solutions. If an answer is technically correct but far more complex than necessary, it is usually not the best answer. The exam favors practical, production-appropriate solutions.
  4. Eliminate solutions that violate context isolation. If an answer assumes that subagents inherit context, it is wrong.

The Programmatic Tiebreaker

When you are down to two options, choose the one that enforces the behavior in code. If one answer implements the logic in code and the other adds an instruction to a prompt, the code-based answer is usually correct.

Handling Uncertainty

Some questions have several options that would work, and you are choosing the best fit for the scenario. Three tests help:

  • Production fit: An option can work in a demo and still be the wrong answer. Parsing Claude's text to detect tool calls works some of the time, while stop_reason is the signal the API provides for it, so stop_reason is the graded choice.
  • Completeness: An answer that addresses all aspects of the problem is better than one that addresses only part of it. For example, an answer that includes both schema enforcement AND validation is better than one that includes only schema enforcement, since schema-only is a partial solution.
  • Simplicity: When two answers are equally correct and equally complete, prefer the simpler one.

Managing Exam Anxiety

  • Do not spend more than 4 minutes on any single question during your first pass. Flag it and move on. You can always come back.
  • Trust your preparation. If you score 80% or more on practice tests you haven't seen before, you have a margin above the pass mark.
  • Read the whole question before the options. Skimming the question and jumping to the options makes it easy to miss the constraint that decides the answer.
  • Weigh absolute words. Options that say "always" or "never" are often wrong, with one exception: when the question asks how to guarantee a behavior, the right answer is a mechanism that does guarantee it, such as a hook.

How to pass CCA-F on your first attempt has more tactics for each kind of scenario.

CCA-F vs Other AI Certifications

CCA-F vs Other AI Certifications

AspectCCA-F (Anthropic)NCP-AAI (NVIDIA)AWS AI Practitioner
FocusArchitecture of production Claude systemsDesigning, building, deploying and governing AI agents, including on the NVIDIA platformAI, machine learning and generative AI basics, and the AWS services built on them
LevelFoundations (architect track)ProfessionalFoundational
Who can registerStaff of Claude Partner Network organizations (October 2026)AnyoneAnyone
Best forEngineers and architects who build Claude systems for clientsEngineers who build and run AI agentsPeople new to AI, in technical or business roles

How They Complement Each Other

The three cover different ground:

  • CCA-F goes deep on one platform, and it fits if you design production systems on Claude.
  • NCP-AAI covers the design, deployment and governance of AI agents, NVIDIA's tools included, and it fits if you build agents on NVIDIA infrastructure.
  • AWS AI Practitioner covers AI and machine learning basics and the AWS services built on them, and it is a starting point for people new to the field.

Which Should You Pursue First?

If you work at a Claude partner and already build with Claude, start with CCA-F, since it tests the work you do every day.

If your organization isn't a Claude partner, you can't register for CCA-F, and NCP-AAI is open to anyone who builds agents.

If you are new to AI, a foundational exam such as AWS AI Practitioner comes before either of them.

Common Questions

Conclusion

Related reading: the Claude certifications overview compares all four exams, free Claude certification courses lists what you can study at no cost, and best CCA-F practice tests and flashcards covers how to rehearse the exam.

CCA-F checks the design calls a production Claude system depends on: agent loops that stop on stop_reason, tools that report failures as structured errors, team rules in shared configuration, schemas backed by validation, and contexts kept short enough to stay reliable. If your organization is a Claude partner and you already build with Claude, eight weeks of courses, building and timed practice tests is a realistic plan. Book the exam once two practice tests you haven't seen before both come back at 80% or higher.

0/15 completed

The preporato.com CCA-F practice tests score each domain separately, so after the first test you know which of the five to study next.

Sources:

CCA-F
6 Practice Exams
Detailed Explanations
Performance Analytics
Get Full Access - $19.99See what's included →

CCA-F · 6 practice exams

$19.99one-time

Get full access