When two CCA-F options would both work, the one the exam grades as correct usually enforces the behavior in code: a hook instead of a line in CLAUDE.md, a JSON schema instead of an instruction to return valid JSON, the API's stop_reason field instead of reading Claude's text. Anthropic's exam guide says it plainly for workflows that need deterministic compliance, such as verifying a customer's identity before a refund: prompt instructions alone have a non-zero failure rate.
Everything here follows the task statements in Anthropic's CCA-F exam guide (version 1.0, effective July 2026). The CCA-F complete guide explains the same rules in prose.
Domain 1: Agentic Architecture & Orchestration (27%)
| If the question describes | The answer to look for |
|---|---|
| An agent that stops early or never stops | A loop that continues while stop_reason is "tool_use" and ends on "end_turn" |
| Code that checks Claude's reply for "done" or "task complete" | Read stop_reason; text parsing is one of the anti-patterns the guide names |
| An iteration cap as the main way the loop ends | Wrong as the main stop. A generous cap can stay as a safety net |
| A subagent missing findings the coordinator already has | Put the complete findings in the subagent's prompt, because subagents inherit no context |
| Subagents passing work directly to each other | Route all communication through the coordinator |
| Independent searches running one after another | Several Task tool calls in one coordinator response, so the subagents run in parallel |
| A coordinator that can't spawn subagents | Add "Task" to its allowedTools |
| A broad topic covered too narrowly | The coordinator split it too narrowly: give each subagent distinct subtopics and re-delegate to fill gaps |
| A refund that must never run before identity is checked | A programmatic prerequisite that blocks process_refund until get_customer returns a verified ID |
| Refunds above $500 must always go to a human | A hook that intercepts the tool call and redirects it to escalation |
| Tool results in mixed formats (Unix time, ISO 8601, numeric codes) | A PostToolUse hook that normalizes them before Claude sees them |
| A predictable review of many aspects | Prompt chaining: each file on its own, then a cross-file integration pass |
| An open-ended task such as adding tests to a legacy codebase | Map the structure first, then a prioritized plan that changes as you learn |
| Continuing yesterday's named investigation | --resume <session-name> |
| Comparing two approaches from the same analysis | fork_session |
| Resuming after the code changed | Tell the resumed session which files changed, or start fresh with a summary when the old tool results are stale |
| Handing off to a human who can't see the transcript | A structured summary: customer ID, root cause, refund amount, recommended action |
The loop itself:
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 # Claude has finished
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})
The API is stateless, so the assistant turn and the tool result both go back into messages before the next call.
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
Domain 2: Tool Design & MCP Integration (18%)
| If the question describes | The answer to look for |
|---|---|
| Claude choosing between two similar tools at random | Descriptions that state inputs, outputs, edge cases and when to use each tool over the other; rename tools whose purposes overlap |
A generic analyze_document tool that misfires | Split it into purpose-specific tools such as extract_data_points, summarize_content and verify_claim_against_source |
| A system prompt keyword that drags Claude to the wrong tool | Reword the system prompt so it stops overriding good tool descriptions |
| Wrong tool choices since more tools were added | Too many tools on one agent (the guide's example is 18 where 4 or 5 would do): give each subagent the tools for its role |
| A synthesis agent running its own web searches | Remove tools outside its role, and add a scoped tool such as verify_fact if it needs one often |
| The agent must call a tool and may not answer in text | tool_choice: "any" |
| One extraction must run before the enrichment steps | Forced selection: tool_choice: {"type": "tool", "name": "extract_metadata"} |
| A tool that timed out | A structured error: isError, errorCategory: "transient", isRetryable: true and a readable description |
| A request that breaks a business rule | isRetryable: false and an explanation the agent can pass to the customer |
| A search that ran and found nothing | A valid empty result returned as a success, so the agent neither retries nor reports an outage |
| An MCP server the whole team needs | .mcp.json in the project, committed, with ${GITHUB_TOKEN}-style variables for credentials |
| A personal or experimental MCP server | ~/.claude.json |
| The agent uses Grep where an MCP tool would do better | Describe the MCP tool's capabilities and outputs in more detail |
| The agent spends calls exploring what data exists | Expose the catalog as MCP resources |
| A standard integration such as Jira | An existing community MCP server; custom servers are for team-specific workflows |
| Edit fails because the anchor text isn't unique | Read the file, then Write it back |
Error categories from the exam guide:
| Category | Example | Retry? |
|---|---|---|
| Transient | Timeout, service unavailable | Yes |
| Validation | Invalid input | Only after fixing the input |
| Business | A refund above the policy limit | No: explain the rule to the customer |
| Permission | Caller not authorized | No |
Built-in tools in Claude Code and the Agent SDK:
| Tool | Use it to |
|---|---|
| Grep | Search file contents for function names, error messages or imports |
| Glob | Find files by name or extension, such as **/*.test.tsx |
| Read and Write | Load or write a whole file |
| Edit | Change part of a file by matching unique text |
| Bash | Run shell commands |
To learn an unfamiliar codebase, start with Grep to find entry points and Read to follow the imports from there, instead of reading every file up front.
Project-level MCP configuration:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "${GITHUB_TOKEN}"
}
}
}
}
Domain 3: Claude Code Configuration & Workflows (20%)

Where configuration lives:
| File | Applies to | Shared through Git |
|---|---|---|
~/.claude/CLAUDE.md | You, in every project | No |
CLAUDE.md or .claude/CLAUDE.md in the project | Everyone on the project | Yes |
CLAUDE.md in a subdirectory | Work inside that directory | Yes |
.claude/rules/*.md with a paths field | Files that match the globs, wherever they are | Yes |
.claude/commands/ | The team's slash commands | Yes |
~/.claude/commands/ | Your personal slash commands | No |
.claude/skills/<name>/SKILL.md | The project's skills | Yes |
~/.claude/skills/ | Your personal skills, including variants of team skills | No |
.claude/settings.json | The project's hooks and settings | Yes |
~/.claude/settings.json | Your own hooks and settings | No |
| If the question describes | The answer to look for |
|---|---|
| A new teammate's sessions ignore the team's standards | The standards sit in someone's ~/.claude/CLAUDE.md. Move them to the project CLAUDE.md |
| One huge CLAUDE.md | Split it into topic files in .claude/rules/, or pull standards files in with @import |
| Conventions for test files spread across the codebase | A rules file with paths: ["**/*.test.tsx"], since a subdirectory CLAUDE.md covers only its own directory |
| Unsure which memory files a session loaded | Run /memory |
| A skill whose output floods the conversation | context: fork runs it in an isolated sub-agent context |
| A skill that must not make destructive changes | Limit its tools with allowed-tools |
| A skill that needs a parameter | argument-hint prompts for it |
| Standards that always apply versus a workflow run on demand | CLAUDE.md for the standards, a skill for the workflow |
| A guarantee, such as running tests before every commit | A hook: PreToolUse on Bash with an if filter on git commit |
| A library migration across 45+ files, or a choice between architectures | Plan mode, then direct execution of the agreed plan |
| A single-file bug with a clear stack trace | Direct execution |
| Discovery output filling the context | The Explore subagent, which returns a summary |
| Prose instructions that Claude reads inconsistently | Two or three concrete input and output examples |
| Several problems whose fixes interact | One detailed message covering all of them (independent problems can go one at a time) |
| An unfamiliar domain with open design questions | The interview pattern: Claude asks questions before implementing |
| A CI job that hangs waiting for input | claude -p (or --print) |
| CI findings posted as inline PR comments | --output-format json with --json-schema |
| A re-review that repeats comments already made | Include the prior findings and ask only for new or still-unaddressed issues |
| Claude reviewing code it wrote in the same session | A separate, independent review instance |
| Generated tests that duplicate existing ones | Put the existing test files in context |
A hook that blocks a destructive command and a hook that lints after edits:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [
{ "type": "command", "if": "Bash(rm *)", "command": ".claude/hooks/block-destructive.sh" }
]
}
],
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{ "type": "command", "command": "npx eslint --fix" }
]
}
]
}
}
The hook script allows the call by exiting 0 and blocks it by exiting 2, or by printing permissionDecision: "deny" in its JSON output.
Skill frontmatter in SKILL.md:
---
name: "security-review"
description: "Reviews changed files for security issues"
context: fork
allowed-tools:
- Read
- Grep
- Glob
argument-hint: "path to review"
---
A path-scoped rule:
# .claude/rules/test-standards.md
---
paths:
- "**/*.test.ts"
- "**/*.spec.ts"
---
Use describe/it blocks. Mock external dependencies.
Test both the happy path and the error cases.
A CI review that returns findings as JSON, with the session limited to read-only tools:
claude -p "Review the changes in this PR for security issues" \
--output-format json \
--json-schema "$(cat review-findings.schema.json)" \
--tools "Read,Grep,Glob"
--tools limits which tools exist in the session. The similar-looking --allowedTools only lets the listed tools run without asking for permission.
Domain 4: Prompt Engineering & Structured Output (20%)
| If the question describes | The answer to look for |
|---|---|
| A review that flags too many false positives | Explicit criteria for what to report and what to skip. "Be conservative" and "only report high-confidence findings" don't improve precision |
| One noisy category that makes developers distrust the rest | Switch that category off for now and improve its prompt |
| Severity labels that vary from run to run | Severity criteria with a concrete code example for each level |
| Inconsistent handling of ambiguous cases | Two to four targeted few-shot examples that show why one action beat the alternatives |
| Required fields left empty on unusually formatted documents | Few-shot examples of correct extraction from varied formats |
| JSON that sometimes fails to parse | Tool use with a JSON schema |
| Valid JSON with wrong values, such as line items that don't add up to the total | Validation in code (a calculated_total next to the stated_total), then a retry with the errors |
| Several extraction schemas and an unknown document type | tool_choice: "any" |
| A field the document may not contain | Make it nullable, so the model has no reason to invent a value |
| Categories the enum doesn't cover | "unclear" for ambiguous cases, "other" with a detail field for new categories |
| Retries that fail the same way every time | The information isn't in the document, and no retry can add it |
| Developers dismissing findings and nobody knows why | A detected_pattern field on each finding, so dismissals can be analyzed |
| Overnight reports, weekly audits, nightly test generation | The Message Batches API: half the cost, results within 24 hours, no latency guarantee |
| A pre-merge check someone waits on | The synchronous API |
| A task that needs tool calls in the middle of a request | Not a batch job: a batch request can't run tools and continue |
| Some documents in a batch failed | Resubmit only those, matched by custom_id, with the fix applied (for example, chunking) |
| A large batch about to run | Refine the prompt on a sample first |
| A model reviewing its own output in the same session | An independent instance without the generator's reasoning |
| A review of many files that misses issues | Per-file passes for local issues plus an integration pass across files |
An extraction schema with room for missing and unexpected values:
{
"type": "object",
"properties": {
"company_name": { "type": "string" },
"revenue": { "type": ["number", "null"] },
"fiscal_quarter": {
"type": "string",
"enum": ["Q1", "Q2", "Q3", "Q4", "unclear"]
},
"industry": {
"type": "object",
"properties": {
"category": {
"type": "string",
"enum": ["tech", "finance", "healthcare", "manufacturing", "other"]
},
"detail": { "type": ["string", "null"] }
}
}
},
"required": ["company_name", "revenue", "fiscal_quarter", "industry"]
}
A retry request carries the original document, the failed extraction and the specific validation errors:
The following extraction failed validation.
Original document: [document]
Failed extraction: [JSON output]
Validation errors: [specific errors]
Re-extract, fixing only the identified errors.
Domain 5: Context Management & Reliability (15%)
| If the question describes | The answer to look for |
|---|---|
| Amounts, dates or order numbers lost after summarizing | A persistent "case facts" block in every prompt, kept outside the summarized history |
| Order lookups returning 40+ fields when 5 matter | Trim tool output to the relevant fields before it piles up in context |
| Findings in the middle of a long input getting missed | Key findings at the top and explicit section headers (the "lost in the middle" effect) |
| A customer who asks for a human | Escalate at once, without investigating first |
| A frustrated customer with a simple issue | Acknowledge the frustration and offer to resolve it, then escalate if they ask again |
| A request the policy doesn't cover, such as matching a competitor's price | Escalate |
| An agent making no meaningful progress | Escalate |
| Escalation based on sentiment or on Claude's own confidence | Wrong: neither tracks how complex the case is |
| Several customers matching one lookup | Ask for another identifier instead of picking one by heuristic |
| A subagent hitting a timeout | Recover locally if the failure is transient; otherwise pass up the failure type, what was attempted, the partial results and the alternatives |
| One failed step ending the whole workflow | Wrong, like hiding the failure as an empty success |
| A synthesis built on incomplete sources | Coverage notes saying which findings are well supported and where sources were missing |
| Answers that drift, citing "typical patterns" late in a long session | Context degradation: scratchpad files, subagents for exploration, /compact |
| A crash partway through a long multi-agent job | Each agent exports its state, and the coordinator loads the manifest on resume and injects it into the prompts |
| A system with 97% overall accuracy | Check accuracy by document type and by field before cutting human review |
| Measuring errors among high-confidence extractions | Stratified random sampling |
| Deciding what reviewers should look at | Field-level confidence calibrated on a labeled validation set; low-confidence or contradictory cases go to a person |
| Sources losing their attribution during synthesis | Claim-source mappings that every step keeps |
| Two credible sources that disagree | Keep both values with their sources and let the coordinator reconcile them |
| Figures from different years that look contradictory | Require publication or collection dates in each subagent's output |
A structured failure report from a subagent:
{
"status": "partial_failure",
"completed": ["repo_scan", "dependency_check"],
"failed": {
"tool": "security_scan",
"error_type": "timeout",
"attempted": "Full repository security scan",
"partial_results": "Scanned 47 of 120 files before timeout",
"alternatives": ["Retry with reduced scope", "Queue for batch processing"]
}
}
A crash-recovery manifest:
{
"workflow_id": "audit-2026-03-28",
"completed_steps": ["data_collection", "initial_analysis"],
"pending_steps": ["deep_review", "report_generation"],
"intermediate_results": {
"files_scanned": 847,
"issues_found": 23,
"critical_issues": 3
},
"checkpoint_timestamp": "2026-03-28T14:30:00Z"
}
Anti-Patterns Quick Reference
| Wrong answer | Why it fails | What the exam wants |
|---|---|---|
| Parsing Claude's text to end the loop | Text can sound final in the middle of a task | stop_reason |
| A strongly worded prompt rule for a refund limit | Prompt instructions have a non-zero failure rate | A hook that blocks the call |
| Few-shot examples to enforce the order of tool calls | Examples make the order more likely and never guarantee it | Programmatic prerequisites |
| Escalating on sentiment or self-reported confidence | Neither tracks how complex the case is | A request for a human, a policy gap, or no progress |
| The Batch API for a blocking step | Results can take up to 24 hours | The synchronous API |
| A bigger context window for attention problems | Information in the middle still gets missed | Focused passes and key facts at the top |
| An empty result when a tool failed | The agent tells the user with confidence that nothing exists | A structured error with its category and retry flag |
| Every tool on every agent | Tool selection degrades as the list grows | A few tools per agent, scoped to its role |
| "Always return valid JSON" in the prompt | The output still breaks now and then | Tool use with a JSON schema, then validation and retry |
The Six Exam Scenarios
Each exam draws four of these at random, so prepare for all six.
| Scenario | What the system does | Primary domains |
|---|---|---|
| Customer Support Resolution Agent | An Agent SDK agent resolves returns, billing disputes and account issues through MCP tools (get_customer, lookup_order, process_refund, escalate_to_human), aiming for 80%+ first-contact resolution | 1, 2, 5 |
| Code Generation with Claude Code | A team uses Claude Code with custom slash commands, CLAUDE.md files and a choice between plan mode and direct execution | 3, 5 |
| Multi-Agent Research System | A coordinator delegates search, document analysis, synthesis and report writing to subagents and produces cited reports | 1, 2, 5 |
| Developer Productivity with Claude | An Agent SDK tool explores unfamiliar codebases with Read, Write, Bash, Grep and Glob plus MCP servers | 1, 2, 3 |
| Claude Code for Continuous Integration | Claude Code runs automated reviews, generates tests and comments on pull requests, keeping false positives low | 3, 4 |
| Structured Data Extraction | A system extracts data from unstructured documents, validates it against JSON schemas and passes it downstream | 4, 5 |
Pairs to Tell Apart
| This | That | The difference |
|---|---|---|
stop_reason: "tool_use" | stop_reason: "end_turn" | Run the tool and continue, or stop |
tool_choice: "auto" | tool_choice: "any" | Claude may answer in text, or must call some tool |
tool_choice: "any" | Forced tool_choice | Any tool, or one named tool |
~/.claude/CLAUDE.md | Project CLAUDE.md | Personal, or shared through Git |
Subdirectory CLAUDE.md | .claude/rules/ with paths | One directory, or matching files anywhere |
| A skill | CLAUDE.md | Runs on demand, or always loaded |
| A hook | A CLAUDE.md instruction | Runs every time, or guidance Claude usually follows |
--resume <session-name> | fork_session | Continue a session, or branch from it |
| Resuming a session | Starting fresh with a summary | Prior context still valid, or tool results gone stale |
| Prompt chaining | Dynamic decomposition | A predictable review, or an open-ended investigation |
| Syntax errors | Semantic errors | Prevented by a schema, or caught by your validation |
| Access failure | Empty result | A retry decision, or a successful search with no matches |
| Transient error | Business rule error | Retry, or explain the rule to the customer |
| Message Batches API | Synchronous API | Half the cost and up to 24 hours, or an immediate answer |
| Self-review | Independent instance | Same reasoning context, or fresh eyes |
| Aggregate accuracy | Accuracy by type and field | Can hide a weak segment, or shows it |
Exam Day
The exam gives you 4 of the 6 scenarios at random and spreads 60 questions across them, about 15 per scenario. With 120 minutes that averages 2 minutes a question, and multiple-response items say how many options to pick. One way to pace it: answer what you know and flag the rest in the first 70 to 80 minutes, return to the flagged questions for 30 to 40, and keep 10 for a final check.
Pre-Exam Review Checklist
CCA-F Pre-Exam Checklist
0/26 completedRelated reading: the CCA-F exam domains breakdown works through each domain with examples, the 30-day study plan turns these rules into a schedule, and how to pass CCA-F on your first attempt covers exam technique.
Frequently asked questions
Do I choose which CCA-F scenarios I get?
No. Each exam draws 4 of the 6 published scenarios at random, so study all six. The exam guide lists the primary domains of each one.
Is there an official CCA-F practice exam?
Not anymore. Anthropic retired it in the move to Pearson VUE on June 30, 2026, and as of October 2026 the sample questions in the exam guide are the only official practice material. The free questions on the certificate page come from the preporato.com practice tests.
Can I use this cheat sheet during the exam?
No. CCA-F is proctored, online or at a test center, and notes, documentation and other devices aren't allowed. It works best for review in the last week.
Sources:
![Claude Certified Architect (CCA-F) Cheat Sheet: Complete Reference [2026]](/blog/claude-certified-architect-cheat-sheet-2026.webp)