Claude Certified Architect – Foundations (CCA-F): The Definitive Exam Guide
Everything you need to pass Anthropic's first official certification — domains, sample questions, study strategy, and hands-on exercises
The Claude Certified Architect – Foundations (CCA-F) is not just another AI certification. Launched on March 12, 2026 as Anthropic's first-ever official technical credential, it validates that practitioners can make real-world, production-grade decisions when building systems with Claude.
This is the definitive guide — built from Anthropic's official 40-page exam guide, supplemented with registration details, community insights, and everything you need to pass on your first attempt.
What Is the CCA-F Certification?
The Claude Certified Architect – Foundations (CCA-F) validates that you can design and implement production applications with Claude across five core technology areas: the Claude Agent SDK, Claude Code, the Claude API, Model Context Protocol (MCP), and prompt engineering.
Unlike most AI certifications that test memorization, the CCA-F is scenario-based. Every question places you in a realistic production context — a customer support agent, a multi-agent research pipeline, a CI/CD integration — and asks you to make the right architectural judgment call.
"This is a certification for engineers who build, not engineers who study about building.Questions on this exam are grounded in realistic scenarios drawn from actual customer use cases." — Anthropic Official Exam Guide
"
Exam At a Glance
Full name: Claude Certified Architect – Foundations (CCA-F)
Issued by: Anthropic
Launch date: March 12, 2026
Questions: 60 multiple-choice (4 options, one correct answer)
Time limit: 120 minutes
Passing score: 720 / 1,000 (scaled)
Exam format: Scenario-based — 4 scenarios out of 6, selected randomly
Proctoring: Online via ProctorFree
Cost: $99 per attempt (free for first 5,000 Claude Partner Network employees)
Results: Within 2 business days, with shareable digital badge
Penalty for guessing: None — unanswered questions are scored as incorrect
Registration: anthropic.skilljar.com/cca-f-access
Source: Article data
Target Candidate Profile
The CCA-F is designed for solution architects who design and implement production applications with Claude. The ideal candidate has 6+ months of hands-on experience with:
- Building agentic applications using the Claude Agent SDK (multi-agent orchestration, subagent delegation, tool integration, lifecycle hooks)
- Configuring Claude Code for team workflows (CLAUDE.md files, Agent Skills, MCP server integrations, plan mode)
- Designing Model Context Protocol tool and resource interfaces for backend system integration
- Engineering prompts for reliable structured output (JSON schemas, few-shot examples, extraction patterns)
- Managing context windows across long documents, multi-turn conversations, and multi-agent handoffs
- Integrating Claude into CI/CD pipelines for automated code review, test generation, and PR feedback
- Making escalation and reliability decisions (error handling, human-in-the-loop, self-evaluation)
You do not need advanced ML knowledge, a CS degree, or fine-tuning experience. The exam tests architectural judgment, not model internals.
"Enterprise momentum: The CCA-F is already driving industry adoption at scale. Accenture is training approximately 30,000 professionals on Claude. Cognizant is training up to 350,000 employees globally. Deloitte and Infosys are embedded as anchor partners. The credential is rapidly becoming a baseline requirement for Claude-focused delivery roles at major consulting firms.The candidate typically has 6+ months of practical experience building with Claude APIs, Agent SDK, Claude Code, and MCP, understanding both the capabilities and limitations of large language models in production environments." — Anthropic Exam Guide
"
Domain 1: Agentic Architecture & Orchestration (27%)
The highest-weighted domain — expect approximately 16–17 questions covering 7 task statements.
Task Statement 1.1 — Agentic loops for autonomous task execution
The core of any Claude-powered agent is the agentic loop: send a request to Claude, inspect `stop_reason`, execute tools if needed, and iterate.
The two stop reasons:
- `"tool_use"` → Continue: execute the requested tool, append the result to conversation history, send the next request
- `"end_turn"` → Stop: the model has completed its task
Anti-patterns to avoid on the exam:
- Parsing natural language signals to determine loop termination
- Setting arbitrary iteration caps as the primary stopping mechanism
- Checking for assistant text content as a completion indicator
Tool results must be appended to conversation history between iterations so the model can reason about accumulated context.
Task Statement 1.2 — Multi-agent systems: coordinator-subagent patterns
Hub-and-spoke architecture is the standard pattern: a coordinator agent manages all inter-subagent communication, error handling, and information routing.
What subagents do NOT do automatically:
- Inherit the coordinator's conversation history
- Share memory between invocations
- Communicate directly with each other (all routing goes through the coordinator)
The coordinator's responsibilities:
- Task decomposition — dynamically selecting which subagents to invoke based on query requirements
- Partitioning scope to minimize duplication between subagents
- Iterative refinement — evaluating synthesis output for coverage gaps, re-delegating with targeted queries
- Routing ALL inter-agent communication for observability and consistent error handling
"Critical exam trap: The coordinator should dynamically select which subagents to invoke — not always route through the full pipeline. Overly narrow task decomposition is the top-ranked failure mode.
"
Task Statement 1.3 — Subagent invocation and context passing
The Task tool is the mechanism for spawning subagents. The coordinator's `allowedTools` MUST include `"Task"`.
Context passing rules:
- Subagent context MUST be explicitly provided in the prompt
- Subagents do NOT inherit parent context or share memory automatically
- Include complete findings from prior agents directly in the subagent's prompt
- Use structured data formats to separate content from metadata (source URLs, document names, page numbers)
- Spawn parallel subagents by emitting multiple Task tool calls in a single coordinator response
Design coordinator prompts around research goals and quality criteria, not step-by-step procedural instructions, to enable subagent adaptability.
Task Statement 1.4 — Multi-step workflows with enforcement and handoffs
When deterministic compliance is required — identity verification before financial operations, for example — prompt instructions alone have a non-zero failure rate. Use programmatic prerequisites instead: code-level gates that block downstream tool calls until prerequisite steps complete.
Example: Block `process_refund` until `get_customer` returns a verified customer ID — not via prompt instruction, but via an actual code gate.
For human escalation, structured handoff summaries must include: customer ID, root cause analysis, refund amount, and recommended action. The human agent lacks access to the full conversation transcript.
Task Statement 1.5 — Agent SDK hooks
Hooks provide deterministic guarantees that prompt instructions cannot:
- PostToolUse hooks: Normalize heterogeneous data formats (Unix timestamps → ISO 8601, numeric status codes → human-readable labels) before the model processes them
- Tool call interception hooks: Block policy-violating actions (refunds above $500) before execution and redirect to escalation workflows
"Choose hooks over prompt-based enforcement when business rules require guaranteed compliance." — Official Exam Guide
"
Task Statement 1.6 — Task decomposition strategies
Prompt chaining (fixed sequential): Appropriate for predictable multi-aspect reviews. Breaks the work into focused sequential passes — each receiving results from prior passes.
Dynamic adaptive decomposition: Appropriate for open-ended investigation where next steps depend on findings. Generate subtasks based on what is discovered at each step.
For large code reviews: split into per-file local analysis passes + a separate cross-file integration pass. This prevents attention dilution and eliminates contradictory findings.
Task Statement 1.7 — Session state, resumption, and forking
- `--resume
`: Continue a specific named prior conversation - `fork_session`: Create independent branches from a shared analysis baseline to explore divergent approaches
- When to start fresh (vs. resume): If prior tool results are stale after code modifications, inject a structured summary into a new session rather than resuming with outdated context
Simplified visualization of the concept
Domain 2: Tool Design & MCP Integration (18%)
Task Statement 2.1 — Effective tool interfaces
The single most important rule: Tool descriptions are the primary mechanism LLMs use for tool selection. Minimal descriptions cause unreliable selection between similar tools.
A complete tool description includes:
- Input formats it handles
- Example queries that should trigger this tool
- Edge cases and boundary conditions
- Explicit boundary: when to use this tool vs. similar alternatives
Bad example: `analyze_content` and `analyze_document` with near-identical descriptions cause misrouting.
Fix: Rename `analyze_content` → `extract_web_results` with a web-specific description that explicitly states when to use it vs. document tools. Split generic tools into purpose-specific variants with defined input/output contracts.
Task Statement 2.2 — Structured error responses
Return structured error metadata — not just a message string:
- `isError: true`
- `errorCategory: "transient"` / `"validation"` / `"business"` / `"permission"`
- `isRetryable: true/false`
- `description: "Human-readable details"`
Critical distinction: access failures (timeout → should retry) vs. valid empty results (query succeeded, no matches → do NOT retry — this is success).
For business errors: include `retryable: false` and a customer-friendly explanation so the agent can communicate appropriately without wasted retry attempts.
Task Statement 2.3 — Tool distribution across agents
Giving an agent 18 tools instead of 4–5 degrades tool selection reliability by increasing decision complexity.
`tool_choice` configuration:
- `"auto"` — Model may return text OR call a tool (default)
- `"any"` — Model MUST call a tool; chooses which (use to guarantee structured output)
- `{"type": "tool", "name": "extract_metadata"}` — Model MUST call this specific tool (use to enforce ordering in pipelines)
Task Statement 2.4 — MCP server integration
Project-level (.mcp.json): Shared team tooling, version-controlled, available to all team members.
User-level (~/.claude.json): Personal/experimental servers, not shared via version control.
Use environment variable expansion: `${GITHUB_TOKEN}` in `.mcp.json` — never commit credentials directly.
MCP resources expose content catalogs (issue summaries, documentation hierarchies, database schemas) to reduce exploratory tool calls. Resources are read-only catalogs; tools are actions.
Tools from all configured MCP servers are discovered at connection time and available simultaneously.
Task Statement 2.5 — Built-in tools: when to use each
Grep: Search file contents by pattern (function names, error messages, import statements)
Glob: Find files by name/extension pattern (`**/*.test.tsx`, `src/**/*.ts`)
Read: Load full file contents for analysis
Write: Full file creation or replacement
Edit: Targeted modification using unique anchor text matching
Bash: System commands and shell execution
When Edit fails (non-unique anchor text): fall back to Read + Write.
Build codebase understanding incrementally: Grep to find entry points → Read to follow imports → Glob to locate related files.
Domain 3: Claude Code Configuration & Workflows (20%)
Task Statement 3.1 — CLAUDE.md hierarchy
Four levels of configuration, each with different scope:
- ~/.claude/CLAUDE.md — Personal only. NOT version-controlled. Instructions apply only to that user — not shared with teammates.
- CLAUDE.md (project root) — Shared via git. Applies to all team members automatically.
- subdir/CLAUDE.md — Directory-specific overrides for that subdirectory.
- **.claude/rules/*.md — Glob-scoped rules that load only when editing matching files.
Use `@import` syntax to reference external files and keep CLAUDE.md modular. Use `.claude/rules/` for topic-specific files (testing.md, api-conventions.md, deployment.md). Use `/memory` command to verify which files are loaded and diagnose inconsistent behavior.
Source: Article data
Task Statement 3.2 — Custom slash commands and skills
Project commands (.claude/commands/): Version-controlled, available to all team members on clone/pull.
Personal commands (~/.claude/commands/): Not shared via version control, personal use only.
SKILL.md frontmatter options:
- `context: fork` — Run skill in isolated sub-agent context, preventing verbose output from polluting the main conversation
- `allowed-tools: [Write, Edit]` — Restrict tool access during skill execution
- `argument-hint: "module name"` — Prompt the developer for required parameters on invocation without arguments
Use `context: fork` for verbose analysis skills (codebase exploration, brainstorming). Skills are for on-demand invocation; CLAUDE.md is for always-loaded universal standards.
Task Statement 3.3 — Path-specific rules
```yaml
paths:
- "/*.test.tsx"
- "src/api/**/*"
```
Path-scoped rules load only when editing matching files. This reduces irrelevant context and token consumption. Critical advantage over directory-level CLAUDE.md: glob patterns apply to files spread across the entire codebase by type, regardless of directory structure.
Task Statement 3.4 — Plan mode vs. direct execution
Use plan mode for: Large-scale changes across many files, multiple valid architectural approaches, monolith-to-microservices restructuring, library migrations affecting 45+ files, new features with infrastructure implications.
Use direct execution for: Single-file bug fix with clear stack trace, adding a simple validation check, well-understood scope with no architectural decisions.
The Explore subagent isolates verbose discovery output and returns only summaries, preserving the main conversation context for coordination.
Task Statement 3.5 — Iterative refinement techniques
I/O examples: 2-3 concrete input → output examples clarify requirements when prose descriptions produce inconsistent results.
Test-driven iteration: Write test suites covering expected behavior and edge cases before implementation, then iterate by sharing test failures.
Interview pattern: Have Claude ask questions to surface design considerations (cache invalidation, failure modes) before implementing in unfamiliar domains.
Batch vs. sequential: Provide all issues in one message when fixes interact; fix sequentially when issues are independent.
Task Statement 3.6 — CI/CD integration
- `-p` / `--print` flag: Required for non-interactive mode in automated CI pipelines
- `--output-format json` + `--json-schema`: Machine-parseable output for automated inline PR comments
- Re-reviews: Include prior findings in context, instruct Claude to report only new or still-unaddressed issues
- Use an independent Claude instance (without the generator's reasoning context) for code review
Domain 4: Prompt Engineering & Structured Output (20%)
Task Statement 4.1 — Explicit criteria to reduce false positives
The difference between prompts that work and prompts that generate noise:
Vague: "Flag comments that seem inaccurate"
Specific: "Flag a comment ONLY when the claimed behavior directly contradicts what the code demonstrably does. Skip stylistic preferences and local patterns not documented in the standards file."
Specific categorical criteria outperform confidence-based filtering. High false-positive categories damage developer trust in accurate categories — temporarily disable them while improving their prompts.
Task Statement 4.2 — Few-shot prompting for consistency
Few-shot examples are the most effective technique for consistently formatted, actionable output when detailed instructions alone produce inconsistent results.
Best practices:
- 2-4 targeted examples for ambiguous scenarios — show reasoning for why one action was chosen over plausible alternatives
- Demonstrate the exact desired output format (location, issue, severity, suggested fix)
- Include examples distinguishing acceptable patterns from genuine issues to reduce false positives
- Show correct handling of varied document structures (inline citations vs. bibliographies)
Input: "Check order status for #12345"
→ Tool: lookup_order — User specified an order number; this is an order query, not an account query.
Input: "I need to update my billing address"
→ Tool: get_customer — Must verify customer identity before any account modification.
Input: "Why was I charged twice last week?"
→ Tool: get_customer then lookup_order — Need account context before order investigation.
Task Statement 4.3 — Structured output via tool_use
Tool use with JSON schemas is the most reliable approach for guaranteed schema-compliant output — it eliminates JSON syntax errors entirely.
Schema design principles:
- Use nullable/optional fields when information may not exist in source documents — prevents hallucination to satisfy required fields
- Add "other" + detail string patterns for extensible categorization
- Strict schema eliminates syntax errors but NOT semantic errors (values that don't sum, wrong field placement)
`tool_choice` options:
- `"any"` — Guarantees a tool is called; model chooses which. Use when document type is unknown.
- `{"type": "tool", "name": "extract_metadata"}` — Forces a specific tool. Use for ordered pipelines.
Task Statement 4.4 — Validation-retry loops
When validation fails, include specific error context in the retry:
Document: [original document]
Failed extraction: [failed JSON output]
Validation error: line_items sum to $847.32 but stated_total is $912.00. Ensure all line items are included.
When retries are ineffective: information absent from the source document cannot be extracted by retrying. Retries help only with format mismatches and structural errors — not missing data.
Task Statement 4.5 — Message Batches API
Use batch for: Overnight reports, weekly audits, nightly test generation — latency-tolerant workloads.
Do NOT use for: Blocking pre-merge checks, any workflow where developers wait for results.
Key specs: 50% cost savings vs. synchronous API. Up to 24-hour processing window. No guaranteed latency SLA. Multi-turn tool calling NOT supported within a single request. Use `custom_id` for request/response correlation.
Batch failure handling: Resubmit only failed documents (by custom_id) with modifications. Run prompt refinement on a sample set before processing large volumes.
Task Statement 4.6 — Multi-instance review architectures
A model retains reasoning context from generation, making it less likely to catch its own errors. Use an independent Claude instance for review — without the generator's reasoning context.
Multi-pass review for large PRs:
- Per-file local passes: Ensure consistent depth across all files
- Cross-file integration pass: Examine data flow, module boundaries, cross-file inconsistencies
Domain 5: Context Management & Reliability (15%)
Task Statement 5.1 — Preserving critical information
Progressive summarization risk: Condensing numerical values, dates, and customer expectations into vague summaries loses precision.
Fix: Extract transactional facts into a persistent "case facts" block included in every prompt, outside summarized history. Include: customer ID, order numbers, amounts, dates, stated expectations.
Lost-in-the-middle effect: Models reliably process information at the beginning and end of long inputs but may miss middle sections. Place key findings summaries at the beginning of aggregated inputs.
Verbose tool output: Tool results may return 40+ fields when only 5 are relevant. Trim to relevant fields before they accumulate in context.
Task Statement 5.2 — Escalation patterns
Valid escalation triggers:
- Customer explicitly requests a human (honor immediately — do NOT first attempt to resolve)
- Policy gap or exception (policy is silent on the specific request)
- Inability to make meaningful progress
Invalid proxies — frequently tested on the exam:
- Sentiment analysis (frustration ≠ case complexity)
- Self-reported confidence scores (poorly calibrated at inference time)
- Perceived complexity without defined criteria
When multiple customer matches return: request additional identifiers — do NOT select based on heuristics.
Task Statement 5.3 — Error propagation across multi-agent systems
Never return empty results as success on failure. Never terminate the entire workflow on a single subagent failure.
Return structured error context enabling coordinator recovery:
- Failure type (timeout vs. access denied vs. no results)
- What was attempted (the exact query or operation)
- Partial results (what was successfully retrieved before failure)
- Alternative approaches the coordinator could try
Subagents should implement local recovery for transient failures (retry with backoff) and propagate to the coordinator only errors they cannot resolve locally.
Task Statement 5.4 — Large codebase exploration
Context degradation in extended sessions: Models start referencing "typical patterns" rather than specific classes discovered earlier.
Mitigations:
- Scratchpad files: Agents maintain files recording key findings, referencing them for subsequent questions
- Subagent delegation: Spawn subagents for verbose exploration; main agent coordinates high-level understanding
- `/compact`: Reduce context usage when verbose discovery fills the window
- Structured manifests: Each agent exports state to a known path; coordinator loads manifest on resume
Task Statement 5.5 — Human review and confidence calibration
Aggregate accuracy (97% overall) can mask poor performance on specific document types or fields. Always validate by document type and field segment before reducing human review.
Confidence-based routing: Have the model output field-level confidence scores. Calibrate thresholds using labeled validation sets. Use stratified random sampling of high-confidence extractions for ongoing error rate measurement.
Task Statement 5.6 — Information provenance in synthesis
Require subagents to output structured claim-source mappings (source URL, document name, relevant excerpt, publication date). Downstream synthesis agents must preserve this attribution.
For conflicting statistics: annotate both values with source attribution — do NOT arbitrarily select one. Include publication dates to prevent temporal differences from being misinterpreted as contradictions.
The 6 Exam Scenarios
Only 4 of these 6 scenarios will appear in your exam, selected randomly. Each scenario frames multiple questions.
Scenario 1: Customer Support Resolution Agent
A customer support agent using the Claude Agent SDK with MCP tools: `get_customer`, `lookup_order`, `process_refund`, `escalate_to_human`. Target: 80%+ first-contact resolution.
Primary domains: 1 (Agentic Architecture), 2 (Tool Design), 5 (Reliability)
Watch out for: Choosing few-shot examples or system prompt enhancement over programmatic gates when questions describe financial consequences of failure.
Scenario 2: Code Generation with Claude Code
Team uses Claude Code for code generation, refactoring, debugging, and documentation. Custom slash commands, CLAUDE.md configurations, plan mode integration.
Primary domains: 3 (Claude Code), 5 (Reliability)
Watch out for: Placing team-shared commands in `~/.claude/commands/` (personal scope) instead of `.claude/commands/` (project scope, version-controlled).
Scenario 3: Multi-Agent Research System
A coordinator agent delegates to: web search agent, document analysis agent, synthesis agent, report generation agent. Produces comprehensive cited reports.
Primary domains: 1 (Agentic Architecture), 2 (Tool Design), 5 (Reliability)
Watch out for: Assuming subagents inherit coordinator context automatically. They never do — context must always be explicitly passed in the prompt.
Scenario 4: Developer Productivity with Claude
An agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate, and automate repetitive tasks. Uses built-in tools and MCP servers.
Primary domains: 2 (Tool Design), 3 (Claude Code), 1 (Agentic Architecture)
Watch out for: Confusing Grep (searches file contents by pattern) with Glob (finds files by name pattern).
Scenario 5: Claude Code for CI/CD
Automated code review, test generation, and PR feedback integrated into CI/CD pipelines. Minimize false positives and produce structured output for inline PR comments.
Primary domains: 3 (Claude Code), 4 (Prompt Engineering)
Watch out for: Options that reference `CLAUDE_HEADLESS=true` or `--batch` — neither of these are real Claude Code features.
Scenario 6: Structured Data Extraction
Extract information from unstructured documents, validate with JSON schemas, handle edge cases, integrate with downstream systems.
Primary domains: 4 (Prompt Engineering), 5 (Reliability)
Watch out for: Designing all schema fields as required — this forces the model to hallucinate values when information is absent from the source document.
Official Sample Questions — Full Analysis
All 12 official sample questions from Anthropic's exam guide with complete explanations.
Scenario 1: Customer Support — Questions 1–3
Q1. Production data shows that in 12% of cases, the agent skips `get_customer` and calls `lookup_order` using only the customer's stated name, leading to misidentified accounts. What change most effectively addresses this?
- A) Add a programmatic prerequisite that blocks `lookup_order` and `process_refund` until `get_customer` returns a verified customer ID.
- B) Enhance the system prompt to state that customer verification is mandatory before order operations.
- C) Add few-shot examples showing the agent always calling `get_customer` first.
- D) Implement a routing classifier that enables only appropriate tools per request type.
✅ Correct: A. Programmatic enforcement provides deterministic guarantees. Prompt-based approaches (B, C) have non-zero failure rates when financial consequences are at stake. Option D addresses tool availability, not tool ordering.
Q2. The agent frequently calls `get_customer` when users ask about orders ("check my order #12345") instead of calling `lookup_order`. Both tools have minimal descriptions. What's the most effective first step?
- A) Add 5-8 few-shot examples showing order queries routing to lookup_order.
- B) Expand each tool's description to include input formats, example queries, edge cases, and boundaries.
- C) Implement a routing layer that pre-selects tools based on detected keywords.
- D) Consolidate both tools into a single lookup_entity tool.
✅ Correct: B. Tool descriptions are the primary selection mechanism. Fixing them is lowest-effort, highest-leverage. Few-shot examples (A) add overhead without fixing the root cause. Routing layer (C) is overengineered. Consolidation (D) is a valid architectural change but too heavy as a "first step."
Q3. The agent achieves 55% first-contact resolution. It escalates straightforward cases while attempting complex ones autonomously. What's the most effective improvement?
- A) Add explicit escalation criteria with few-shot examples demonstrating when to escalate vs. resolve.
- B) Have the agent self-report a confidence score and auto-escalate below a threshold.
- C) Deploy a separate classifier trained on historical tickets.
- D) Implement sentiment analysis and escalate on high frustration.
✅ Correct: A. Explicit criteria with examples directly addresses unclear decision boundaries. Self-reported confidence (B) is poorly calibrated. Classifier (C) is over-engineered before prompt optimization is tried. Sentiment (D) solves the wrong problem — frustration doesn't correlate with case complexity.
Scenario 2: Claude Code — Questions 4–6
Q4. You want a `/review` slash command available to every developer on clone. Where should the command file live?
- A) `.claude/commands/` in the project repository
- B) `~/.claude/commands/` in each developer's home directory
- C) The CLAUDE.md file at the project root
- D) A `.claude/config.json` file with a commands array
✅ Correct: A. Project-scoped commands in `.claude/commands/` are version-controlled and available on clone. `~/.claude/commands/` (B) is personal only. CLAUDE.md (C) is for instructions, not command definitions. Option D describes a non-existent mechanism.
Q5. You've been assigned to restructure a monolithic application into microservices across dozens of files. Which approach should you take?
- A) Enter plan mode to explore the codebase, understand dependencies, and design before making changes.
- B) Start with direct execution and make changes incrementally.
- C) Use direct execution with comprehensive upfront instructions.
- D) Begin with direct execution and switch to plan mode if unexpected complexity emerges.
✅ Correct: A. Plan mode is designed for exactly this: large-scale changes, multiple valid approaches, architectural decisions. Option B risks costly rework. Option D ignores that complexity is already stated in the requirements.
Q6. Test files are spread throughout the codebase (Button.test.tsx next to Button.tsx). You want all tests to follow the same conventions regardless of location. Most maintainable approach?
- A) Create rule files in `.claude/rules/` with YAML frontmatter glob patterns (e.g., `**/*.test.tsx`).
- B) Consolidate all conventions in root CLAUDE.md under headers for each area.
- C) Create skills in `.claude/skills/` for each code type.
- D) Place a separate CLAUDE.md in each subdirectory.
✅ Correct: A. Glob patterns in `.claude/rules/` apply conventions to files by type regardless of directory location. Option B relies on inference. Option C requires manual invocation. Option D can't handle files spread across many directories.
Scenario 3: Multi-Agent Research — Questions 7–9
Q7. A research system on "impact of AI on creative industries" covers only visual arts, missing music, writing, and film. The coordinator decomposed the topic into: "AI in digital art," "AI in graphic design," "AI in photography." Root cause?
- A) The synthesis agent lacks instructions for identifying coverage gaps.
- B) The coordinator's task decomposition is too narrow.
- C) The web search agent's queries are not comprehensive enough.
- D) The document analysis agent is filtering out non-visual sources.
✅ Correct: B. The coordinator's logs directly reveal the root cause: only visual arts subtasks were assigned. All downstream agents performed their assigned tasks correctly. The problem is what they were assigned, not how they performed.
Q8. The web search subagent times out while researching a complex topic. Which error propagation approach best enables recovery?
- A) Return structured error context: failure type, attempted query, partial results, alternative approaches.
- B) Implement retry with exponential backoff; return "search unavailable" only after all retries.
- C) Catch the timeout and return an empty result set marked as successful.
- D) Propagate the exception to a top-level handler that terminates the entire workflow.
✅ Correct: A. Structured context enables intelligent coordinator recovery. Generic status (B) hides context. Empty success (C) prevents any recovery. Terminating the workflow (D) is disproportionate when recovery strategies could succeed.
Q9. The synthesis agent needs 2-3 round trips through the coordinator to verify claims, adding 40% latency. 85% are simple fact-checks; 15% need deeper investigation.
- A) Give synthesis a scoped verify_fact tool for simple lookups; complex cases continue through coordinator.
- B) Have synthesis batch all verification needs and return them to coordinator at end of its pass.
- C) Give synthesis access to all web search tools.
- D) Have web search agent proactively cache extra context anticipating verification needs.
✅ Correct: A. Principle of least privilege: give synthesis only what it needs for the 85% common case. Batching (B) creates blocking dependencies. Full tool access (C) violates separation of concerns. Speculative caching (D) can't reliably predict verification needs.
Scenario 5: CI/CD — Questions 10–12
Q10. A pipeline script runs `claude "Analyze this PR for security issues"` but hangs indefinitely. Fix?
- A) Add the -p flag: `claude -p "Analyze this pull request for security issues"`
- B) Set environment variable `CLAUDE_HEADLESS=true`
- C) Redirect stdin from /dev/null
- D) Add the --batch flag
✅ Correct: A. The `-p` (or `--print`) flag is the documented non-interactive mode for CI. Options B and D reference features that do not exist. Option C is a Unix workaround that doesn't address Claude Code's command syntax.
Q11. Two workflows: (1) blocking pre-merge check and (2) overnight technical debt report. Proposal: switch both to Message Batches API for 50% cost savings. How to evaluate?
- A) Use batch for technical debt reports only; keep real-time for pre-merge checks.
- B) Switch both to batch with status polling.
- C) Keep real-time for both to avoid batch result ordering issues.
- D) Switch both to batch with timeout fallback to real-time.
✅ Correct: A. Batch API has no guaranteed latency SLA (up to 24 hours). Pre-merge checks are blocking workflows. Technical debt reports are latency-tolerant. Option C is wrong: batch results CAN be correlated via custom_id — there is no ordering issue.
Q12. A single-pass review of a 14-file PR produces inconsistent results: detailed for some files, superficial for others, missed bugs, and contradictory findings. How to restructure?
- A) Split into focused passes: per-file local analysis, then separate cross-file integration pass.
- B) Require developers to split large PRs into 3-4 files before review runs.
- C) Switch to a higher-tier model with larger context window.
- D) Run three independent passes and only flag issues appearing in at least two runs.
✅ Correct: A. Focused passes directly address attention dilution. Option B shifts burden to developers. Option C misunderstands that larger context windows don't solve attention quality. Option D suppresses detection of real bugs by requiring multi-run consensus.
In-Scope vs. Out-of-Scope Topics
Confirmed In-Scope
- Agentic loop implementation (stop_reason, tool result handling, termination)
- Multi-agent orchestration (coordinator-subagent, parallel execution, iterative refinement)
- Subagent context management (explicit passing, state persistence, crash recovery)
- Tool interface design (descriptions, splitting vs. consolidating, naming)
- MCP configuration (project vs. user scope, environment variable expansion, resources)
- Error handling (structured responses, error categories, local recovery before escalation)
- Escalation decision-making (explicit criteria, customer preferences, policy gaps)
- CLAUDE.md hierarchy (@import, .claude/rules/ with glob patterns)
- Custom commands and skills (context:fork, allowed-tools, argument-hint)
- Plan mode vs. direct execution
- Structured output via tool_use (schema design, tool_choice, nullable fields)
- Few-shot prompting (ambiguous scenarios, format consistency, false positive reduction)
- Message Batches API (appropriateness, latency tolerance, custom_id failure handling)
- Context window optimization (trimming outputs, structured fact extraction)
- Human review workflows (confidence calibration, stratified sampling)
- Information provenance (claim-source mappings, conflict annotation)
Confirmed Out-of-Scope
- Fine-tuning or training custom models
- Claude API authentication, billing, or account management
- Deploying or hosting MCP servers (infrastructure, networking, containers)
- Claude's internal architecture or training process
- Constitutional AI, RLHF, or safety training
- Embedding models or vector databases
- Computer use (browser automation, desktop interaction)
- Vision or image analysis capabilities
- Streaming API (server-sent events)
- Rate limiting, quotas, API pricing
- OAuth, API key rotation, authentication protocols
- Cloud provider configurations (AWS, GCP, Azure)
- Performance benchmarking or model comparison
- Prompt caching implementation details
- Token counting algorithms
Technologies & Concepts Reference Glossary
Claude Agent SDK: Provides AgentDefinition, agentic loops, stop_reason handling, hooks (PostToolUse, tool call interception), and subagent spawning via the Task tool with allowedTools configuration.
Model Context Protocol (MCP): Standard for exposing tools and resources to Claude. Tools = actions. Resources = read-only content catalogs. The isError flag signals tool failures back to the agent.
Claude Code: CLI and IDE integration configured via CLAUDE.md hierarchy, .claude/rules/, .claude/commands/, .claude/skills/. Non-interactive: -p / --print, --output-format json, --json-schema. Session: --resume, fork_session. Context: /compact, /memory.
Claude API: Core API with tool_use, tool_choice options ("auto", "any", forced), stop_reason values ("tool_use", "end_turn"), max_tokens, system prompts.
Message Batches API: 50% cost savings, up to 24-hour window, no guaranteed latency SLA, no multi-turn tool calls per request, custom_id for correlation.
JSON Schema: Defines extraction output. Required vs. optional (nullable) fields, enum types, "other" + detail string patterns. Tool use enforces syntax compliance; semantic validation requires application logic.
Pydantic: Python library for schema validation in extraction pipelines. Catches structural errors; semantic errors require custom validation logic.
Built-in Tools: Grep (content search), Glob (file name matching), Read (full file load), Write (full file creation), Edit (targeted modification), Bash (system commands).
Prompt Chaining: Sequential decomposition into focused passes. Each pass receives results from prior passes.
Context Window Management: Token budget constraints managed via trimming, structured fact extraction, position-aware ordering, /compact, and subagent delegation.
Session Management: --resume (continue named sessions), fork_session (branch from shared baseline), scratchpad files (persist findings across context boundaries).
Confidence Scoring: Field-level confidence outputs calibrated via labeled validation sets. Used for human review routing and stratified sampling.
4-Week Study Plan
Week 1 — Foundation: Build a basic agentic loop with stop_reason handling and tool execution. Configure CLAUDE.md hierarchy for a real project. Read Domain 1 and Domain 3 task statements.
Week 2 — Tools & Prompts: Design 3 MCP tools with differentiated descriptions and test selection reliability with ambiguous requests. Build a structured data extraction pipeline with tool_use and JSON schema. Write 5+ few-shot examples for ambiguous scenarios.
Week 3 — Advanced Architecture: Build a multi-agent coordinator-subagent system with parallel spawning. Implement validation-retry loops and a batch processing strategy. Study context management patterns and error propagation in Domain 5.
Week 4 — Exam Readiness: Complete the official practice exam (link provided with registration). Review all 12 official sample questions and explanations. Study in-scope/out-of-scope tables. Review the anti-patterns cheat sheet.
Preparation Exercises
Exercise 1: Multi-Tool Agent with Escalation Logic
Define 3-4 MCP tools including 2 with similar functionality. Implement the full agentic loop with stop_reason control flow. Add structured error responses with errorCategory and isRetryable. Implement a tool call interception hook for a business rule. Test with multi-concern messages.
Exercise 2: Claude Code Team Workflow Configuration
Create project-level CLAUDE.md with universal standards. Add path-scoped .claude/rules/ files with YAML frontmatter glob patterns. Create a project-scoped skill with context:fork and allowed-tools restrictions. Configure an MCP server with environment variable credentials. Compare plan mode vs. direct execution across 3 task types.
Exercise 3: Structured Data Extraction Pipeline
Define an extraction tool with required/optional/enum schema fields and nullable fields for absent data. Implement a validation-retry loop with specific error feedback. Add few-shot examples for varied document structures. Design a batch strategy for 100 documents with failure handling by custom_id.
Exercise 4: Multi-Agent Research Pipeline
Build a coordinator + 2 subagents with parallel execution. Design structured output with claim-source mappings. Simulate a subagent timeout and verify structured error propagation. Test with conflicting source data — verify synthesis output preserves both values with source attribution.
Key Anti-Patterns Cheat Sheet
Parsing natural language to stop the loop → Check stop_reason == "end_turn"
Prompt-only enforcement of critical tool ordering → Programmatic prerequisite gates
Minimal tool descriptions ("Retrieves order details") → Include inputs, examples, edge cases, boundaries
Same session for generation and review → Independent review instance
Generic error status ("Operation failed") → Structured error: category, isRetryable, details
Returning empty results as success on failure → Return structured error context with partial results
Terminating workflow on single subagent failure → Local recovery first; propagate with partial results
All extraction fields required in schema → Nullable optional fields for absent data
Batch API for blocking pre-merge checks → Synchronous API for blocking workflows
Sentiment-based escalation → Explicit categorical escalation criteria
Self-reported confidence as primary routing signal → Labeled validation sets for calibration
Arbitrary iteration cap as primary stopping mechanism → stop_reason as primary termination signal
Progressive summarization of numerical data → Persistent "case facts" block outside summarized history
Team commands in ~/.claude/commands/ → Project-scoped .claude/commands/ (version-controlled)
Giving agents 15+ tools → 4-5 tools max per agent role
FAQ
Who is eligible?
You must be an employee of an organization in Anthropic's Claude Partner Network. Organizations can apply to join for free at anthropic.com.
How do I register?
Register at anthropic.skilljar.com. Partner access must be confirmed first.
What does it cost?
$99 per attempt. Anthropic offered complimentary attempts to the first 5,000 partner employees at launch.
How long is the exam?
60 questions, 120 minutes. Multiple choice, one correct answer per question. No penalty for guessing.
What is the passing score?
720 out of 1,000 (scaled). Results within 2 business days with a shareable digital badge.
Is it proctored?
Yes — online via ProctorFree. No external resources allowed.
What experience do I need?
6+ months with Claude APIs, Agent SDK, Claude Code, and MCP recommended. No CS degree or ML knowledge required.
How many scenarios will I face?
4 scenarios randomly selected from 6 possible. Prepare for all 6.
Is there a practice exam?
Yes — available through the Anthropic Skilljar portal, link provided with registration confirmation.
Does the certification expire?
No official expiry period announced as of June 2026. Check anthropic.com for the latest policy.
Conclusion
The CCA-F is the first formal signal that AI engineering as a discipline is maturing. Anthropic has defined what production-grade Claude implementation looks like — five domains, six scenarios, a scoring system designed to distinguish genuine expertise from surface familiarity.
The five domains map directly to the five layers of any serious Claude deployment: architecture, tools, configuration, prompts, and reliability. The exam tests whether you can navigate the tradeoffs in each layer under realistic production pressure.
The best preparation remains building real things: an agentic loop, an MCP server, a CLAUDE.md hierarchy, a structured extraction pipeline with validation-retry logic. Every anti-pattern in this guide comes from production failures that Anthropic saw at scale.
"The first official Anthropic certification is here. Pass it.The candidate typically has 6+ months of practical experience building with Claude APIs, Agent SDK, Claude Code, and MCP, understanding both the capabilities and limitations of large language models in production environments." — Anthropic CCA-F Exam Guide, Version 0.1
"
*Sources: Anthropic CCA-F Official Exam Guide v0.1 (February 2026) · Anthropic Claude Partner Network · agilefever.com · lowcode.agency. Last updated: June 2026.*
View in SWEN Ranking →
Claude — by ELO, price and speed
Source: Anthropic
AI Benchmark
Compare GPT, Claude, Gemini and more: pricing, speed and benchmarks.
Learn by Doing
Guias de uso do Claude, API com Python, Projects e agentes autônomos.