Claude Certified Architect (CCA-F) Exam Guide

Everything you need to know about the Claude Certified Architect – Foundations (CCA-F) exam. Review the format, track your readiness, and learn test-taking strategies.

Claude Certified Architect – Foundations

Exam Format

  • All multiple choice — 1 correct answer, 3 distractors
  • Scenario-based: 4 scenarios drawn from a pool of 6
  • ~15 questions per scenario (~60 total)
  • No penalty for guessing — answer every question

Scoring

  • Scaled score: 100 – 1,000
  • Passing threshold: 720
  • Each domain weighted independently toward final score

Who Is This For?

Solution architects with 6+ months of hands-on experience building with Claude and the Anthropic API.

Key competencies tested:

Agentic ArchitectureTool DesignClaude CodePrompt EngineeringContext Management

Domain Readiness

Exam weight vs. your current mastery across all five domains.

Exam Scenarios

4 of these 6 scenarios will appear on your exam, chosen randomly. Each scenario provides a narrative context for ~15 questions.

Customer Support Resolution Agent

Not yet

You are building a customer support resolution agent using the Claude Agent SDK. The agent handles high-ambiguity requests like returns, billing dispu...

Agentic ArchitectureTool Design & MCPContext & Reliability

Code Generation with Claude Code

Not yet

You are using Claude Code to accelerate software development. Your team uses it for code generation, refactoring, debugging, and documentation. You ne...

Claude Code & WorkflowsContext & Reliability

Multi-Agent Research System

Not yet

You are building a multi-agent research system using the Claude Agent SDK. The system has a coordinator agent that receives research queries and deleg...

Agentic ArchitectureTool Design & MCPContext & Reliability

Developer Productivity with Claude

Not yet

You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy sy...

Tool Design & MCPClaude Code & WorkflowsAgentic Architecture

Claude Code for Continuous Integration

Not yet

You are integrating Claude Code into your Continuous Integration/Continuous Deployment (CI/CD) pipeline. The system runs automated code reviews, gener...

Claude Code & WorkflowsPrompt Engineering

Structured Data Extraction

Not yet

You are building a structured data extraction system using Claude. The system extracts information from unstructured documents, validates the output u...

Prompt EngineeringContext & Reliability

Strategy & Pitfalls

Eight principles that appear repeatedly in exam answer logic. Internalize these to quickly eliminate distractors.

Simplest Effective Solution First

Don't deploy a classifier when improving the prompt hasn't been tried.

The exam rewards choosing the least complex solution that meets requirements. Over-engineering is a common distractor pattern. Always check whether a prompt-level fix was offered before jumping to architectural changes.

Prompt EngineeringAgentic Architecture

Programmatic Enforcement for Critical Paths

Use hooks/prerequisites for financial operations, not prompt instructions.

When safety or compliance is at stake, relying on prompt instructions alone is insufficient. The correct answer will use programmatic guardrails like tool-level hooks, prerequisite checks, or code-enforced gates.

Agentic ArchitectureTool Design

Tool Descriptions Are the #1 Lever

When tools are misselected, fix descriptions before adding few-shot examples.

Claude selects tools primarily based on their descriptions. If the wrong tool is being called, the first intervention should be improving the tool description's clarity and specificity, not adding examples or restructuring the agent.

Tool Design & MCP

Few-Shot Examples > Detailed Instructions

When instructions produce inconsistent output, switch to concrete examples.

Detailed procedural instructions often lead to inconsistent results. Providing 2-3 concrete input/output examples anchors Claude's behavior more reliably than lengthy rule lists.

Prompt Engineering

Independent Review > Self-Review

A second Claude instance catches what the generator rationalized away.

Self-review is weak because the same reasoning that produced the error will rationalize it during review. A separate Claude instance with a reviewer prompt and fresh context is the reliable pattern.

Prompt EngineeringClaude Code

Escalate on Policy Gaps, Not Complexity

Escalate when policy is silent, not just when the case is hard.

The exam distinguishes between cases that are complex (handle with existing rules) and cases where no policy exists. Human escalation is the correct answer when the agent encounters a situation its instructions don't cover.

Context Management

Graceful Degradation with Transparency

Annotate gaps rather than hiding failures or terminating.

When a tool fails or data is missing, the correct pattern is to continue processing, annotate what was skipped, and surface the gap to the user. Silent failure and hard termination are both incorrect.

Context ManagementAgentic Architecture

Scope Tools to Agent Roles

Don't give a synthesis agent web search tools.

Each agent in a multi-agent system should have only the tools it needs for its role. Giving all tools to all agents increases misselection risk and blurs responsibility boundaries.

Tool DesignAgentic Architecture

Domain Study Guides

The certification exam requires partner access — but that's beside the point. Mastering what the exam tests will teach you to build production-grade applications. The knowledge is the goal, and every skill here is independently valuable.

Six scenarios the exam is built around

1

Customer Support Resolution Agent

Agent SDKMCPEscalation
2

Code Generation with Claude Code

CLAUDE.mdPlan ModeSlash Commands
3

Multi-Agent Research System

OrchestrationSubagentsContext
4

Developer Productivity Tools

Built-in ToolsMCP Servers
5

Claude Code for CI/CD

Non-interactiveStructured Output
6

Structured Data Extraction

JSON Schemastool_useValidation

Agentic Architecture & Orchestration

27% of exam

Key Insight

The most commonly misunderstood concept: subagents do not share memory with the coordinator and do not inherit conversation history. Every piece of context must be passed explicitly in each subagent prompt.

What the exam rewards

  • Determine loop completion using stop_reason — never parse natural language signals or apply arbitrary iteration caps
  • For financial or security-critical operations, enforce tool ordering programmatically with hooks; prompt instructions alone have a non-zero failure rate
  • In hub-and-spoke orchestration, all communication routes through the coordinator — subagents never communicate directly with each other
  • Emit multiple Task tool calls in a single response to spawn subagents in parallel and reduce round-trip latency
  • Trace failures to their root cause: a research report missing entire topic areas is a coordinator decomposition failure, not a subagent failure

Anti-patterns to reject

  • Parsing natural language to detect when the agentic loop should stop
  • Treating iteration caps as the primary stopping mechanism
  • Assuming subagents automatically inherit the coordinator's context
  • Using prompt instructions to enforce critical business rules

Tool Design & MCP Integration

18% of exam

Key Insight

Tool descriptions are the primary mechanism Claude uses for tool selection — not an afterthought. Vague or overlapping descriptions cause misrouting, and the correct first fix is always better descriptions, not a routing classifier.

What the exam rewards

  • A strong tool description specifies: what it does, expected input formats, example queries it handles well, and explicit boundaries versus similar-looking tools
  • When misrouting occurs, improve descriptions first — before adding few-shot examples, routing classifiers, or consolidating tools
  • Scope each subagent to 4–5 tools relevant to its role; giving one agent 18 tools degrades selection reliability
  • Know tool_choice: 'auto' (model may return text), 'any' (must call a tool, picks which), forced name (must call a specific named tool)
  • Evaluate existing community MCP servers before building custom ones; only build custom servers for workflows community servers cannot handle

Anti-patterns to reject

  • Near-identical tool descriptions causing constant misrouting between similar tools
  • Giving all agents access to all available tools
  • Building a custom MCP server before checking community servers
  • Using Glob to search file contents, or Grep to match file names

Claude Code Configuration & Workflows

20% of exam

Key Insight

The CLAUDE.md hierarchy separates people who use Claude Code from people who have configured it for a team. User-level config lives only on your machine — new team members won't see it. Team standards belong in project-level config.

What the exam rewards

  • Three config levels: user (~/.claude/CLAUDE.md, personal, not shared), project (.claude/CLAUDE.md, version-controlled, shared via git), directory (subdirectory files, applies to that path only)
  • Path-specific rules in .claude/rules/ with YAML glob frontmatter apply across the entire codebase — unlike directory-level CLAUDE.md which is location-bound
  • Use plan mode for multi-file migrations, architectural decisions, or any task where the correct approach needs exploring before committing; use direct execution for clear, single-file tasks
  • The -p flag is mandatory for non-interactive CI/CD pipelines — without it, the pipeline job hangs waiting for input
  • Skills with context: fork run in isolated sub-agent context, keeping verbose output out of the main conversation window

Anti-patterns to reject

  • Putting team standards in user-level CLAUDE.md — new team members won't receive them
  • Using directory-level CLAUDE.md when test conventions need to span many directories
  • Running Claude Code in CI without the -p flag
  • Putting task-specific procedures in CLAUDE.md, or universal standards in skills

Prompt Engineering & Structured Output

20% of exam

Key Insight

Two words cover this entire domain: be explicit. 'Be conservative' does not reduce false positives. Defining exactly which issues to flag — with concrete code examples for each severity level — does.

What the exam rewards

  • Replace vague confidence instructions with specific categorical criteria: 'flag only when claimed behaviour contradicts actual code behaviour' outperforms 'be conservative'
  • Few-shot examples (2–4 targeted cases showing reasoning for ambiguous calls) are more effective than detailed instructions for consistency
  • tool_use with JSON schemas eliminates syntax errors, but not semantic errors — schemas won't prevent wrong field values, mismatched sums, or fabricated data
  • Make fields nullable when source documents may not contain the information — this prevents the model from fabricating required fields
  • Batch API is for latency-tolerant workflows (overnight reports, nightly audits). Blocking pre-merge checks that developers wait on must stay synchronous

Anti-patterns to reject

  • Using confidence thresholds ('only high-confidence findings') instead of categorical criteria
  • Adding more instructions when 2–3 concrete examples would resolve the inconsistency
  • Routing blocking pre-merge checks through the batch API
  • Assuming JSON schemas prevent all extraction errors

Context Management & Reliability

15% of exam

Key Insight

Progressive summarisation silently corrupts transactional data — amounts, dates, and order numbers become vague paraphrases. A persistent 'case facts' block that is never summarised and always included verbatim is the correct fix.

What the exam rewards

  • Extract transactional specifics (amounts, dates, IDs) into a persistent case facts block and include it verbatim in every prompt — never let it be summarised
  • Three valid escalation triggers: customer explicitly requests a human, a policy gap exists, unable to make meaningful progress. Sentiment and self-reported confidence are not reliable triggers.
  • The 'lost in the middle' effect is real — place key summaries and findings at the beginning of long inputs, not buried in the middle
  • When propagating errors in multi-agent systems, include: failure type, what was attempted, partial results obtained, and alternative approaches. Never silently suppress failures or terminate the full pipeline on one error.

Anti-patterns to reject

  • Using progressive summarisation on conversations containing transactional data
  • Escalating based on customer frustration or detected sentiment
  • Escalating based on the model's self-reported confidence score
  • Terminating an entire pipeline workflow because a single tool failed

Readiness Assessment

Personalized readiness score based on your mastery across all domains.

Overall Readiness

0%

Agentic Architecture

0%

Needs Work

Tool Design & MCP

0%

Needs Work

Claude Code & Workflows

0%

Needs Work

Prompt Engineering

0%

Needs Work

Context & Reliability

0%

Needs Work

Weak Areas

Design and implement agentic loops for autonomous task execution0%
Orchestrate multi-agent systems with coordinator-subagent patterns0%
Configure subagent invocation, context passing, and spawning0%
Implement multi-step workflows with enforcement and handoff patterns0%
Apply Agent SDK hooks for tool call interception and data normalization0%

Action Items

  • Focus on Agentic Architecture — your weakest domain at 0% mastery.
  • Practice 6 remaining scenarios to broaden exam exposure.
  • Review task statement: Design and implement agentic loops for autonomous task execution (0% mastery).

More preparation needed — follow the action items above