CCA-FAnthropicClaudeCheat SheetQuick Reference

Claude Certified Architect (CCA-F) Cheat Sheet: Complete Reference [2026]

Preporato TeamOctober 13, 202615 min readCCA-F
Claude Certified Architect (CCA-F) Cheat Sheet: Complete Reference [2026]

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 describesThe answer to look for
An agent that stops early or never stopsA 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 endsWrong as the main stop. A generous cap can stay as a safety net
A subagent missing findings the coordinator already hasPut the complete findings in the subagent's prompt, because subagents inherit no context
Subagents passing work directly to each otherRoute all communication through the coordinator
Independent searches running one after anotherSeveral Task tool calls in one coordinator response, so the subagents run in parallel
A coordinator that can't spawn subagentsAdd "Task" to its allowedTools
A broad topic covered too narrowlyThe 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 checkedA programmatic prerequisite that blocks process_refund until get_customer returns a verified ID
Refunds above $500 must always go to a humanA 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 aspectsPrompt chaining: each file on its own, then a cross-file integration pass
An open-ended task such as adding tests to a legacy codebaseMap 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 analysisfork_session
Resuming after the code changedTell 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 transcriptA 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.

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

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

If the question describesThe answer to look for
Claude choosing between two similar tools at randomDescriptions 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 misfiresSplit 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 toolReword the system prompt so it stops overriding good tool descriptions
Wrong tool choices since more tools were addedToo 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 searchesRemove 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 texttool_choice: "any"
One extraction must run before the enrichment stepsForced selection: tool_choice: {"type": "tool", "name": "extract_metadata"}
A tool that timed outA structured error: isError, errorCategory: "transient", isRetryable: true and a readable description
A request that breaks a business ruleisRetryable: false and an explanation the agent can pass to the customer
A search that ran and found nothingA 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 betterDescribe the MCP tool's capabilities and outputs in more detail
The agent spends calls exploring what data existsExpose the catalog as MCP resources
A standard integration such as JiraAn existing community MCP server; custom servers are for team-specific workflows
Edit fails because the anchor text isn't uniqueRead the file, then Write it back

Error categories from the exam guide:

CategoryExampleRetry?
TransientTimeout, service unavailableYes
ValidationInvalid inputOnly after fixing the input
BusinessA refund above the policy limitNo: explain the rule to the customer
PermissionCaller not authorizedNo

Built-in tools in Claude Code and the Agent SDK:

ToolUse it to
GrepSearch file contents for function names, error messages or imports
GlobFind files by name or extension, such as **/*.test.tsx
Read and WriteLoad or write a whole file
EditChange part of a file by matching unique text
BashRun 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%)

CLAUDE.md three-level configuration hierarchy, user, project, and directory
CLAUDE.md three-level configuration hierarchy, user, project, and directory

Where configuration lives:

FileApplies toShared through Git
~/.claude/CLAUDE.mdYou, in every projectNo
CLAUDE.md or .claude/CLAUDE.md in the projectEveryone on the projectYes
CLAUDE.md in a subdirectoryWork inside that directoryYes
.claude/rules/*.md with a paths fieldFiles that match the globs, wherever they areYes
.claude/commands/The team's slash commandsYes
~/.claude/commands/Your personal slash commandsNo
.claude/skills/<name>/SKILL.mdThe project's skillsYes
~/.claude/skills/Your personal skills, including variants of team skillsNo
.claude/settings.jsonThe project's hooks and settingsYes
~/.claude/settings.jsonYour own hooks and settingsNo
If the question describesThe answer to look for
A new teammate's sessions ignore the team's standardsThe standards sit in someone's ~/.claude/CLAUDE.md. Move them to the project CLAUDE.md
One huge CLAUDE.mdSplit it into topic files in .claude/rules/, or pull standards files in with @import
Conventions for test files spread across the codebaseA rules file with paths: ["**/*.test.tsx"], since a subdirectory CLAUDE.md covers only its own directory
Unsure which memory files a session loadedRun /memory
A skill whose output floods the conversationcontext: fork runs it in an isolated sub-agent context
A skill that must not make destructive changesLimit its tools with allowed-tools
A skill that needs a parameterargument-hint prompts for it
Standards that always apply versus a workflow run on demandCLAUDE.md for the standards, a skill for the workflow
A guarantee, such as running tests before every commitA hook: PreToolUse on Bash with an if filter on git commit
A library migration across 45+ files, or a choice between architecturesPlan mode, then direct execution of the agreed plan
A single-file bug with a clear stack traceDirect execution
Discovery output filling the contextThe Explore subagent, which returns a summary
Prose instructions that Claude reads inconsistentlyTwo or three concrete input and output examples
Several problems whose fixes interactOne detailed message covering all of them (independent problems can go one at a time)
An unfamiliar domain with open design questionsThe interview pattern: Claude asks questions before implementing
A CI job that hangs waiting for inputclaude -p (or --print)
CI findings posted as inline PR comments--output-format json with --json-schema
A re-review that repeats comments already madeInclude the prior findings and ask only for new or still-unaddressed issues
Claude reviewing code it wrote in the same sessionA separate, independent review instance
Generated tests that duplicate existing onesPut 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 describesThe answer to look for
A review that flags too many false positivesExplicit 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 restSwitch that category off for now and improve its prompt
Severity labels that vary from run to runSeverity criteria with a concrete code example for each level
Inconsistent handling of ambiguous casesTwo to four targeted few-shot examples that show why one action beat the alternatives
Required fields left empty on unusually formatted documentsFew-shot examples of correct extraction from varied formats
JSON that sometimes fails to parseTool use with a JSON schema
Valid JSON with wrong values, such as line items that don't add up to the totalValidation in code (a calculated_total next to the stated_total), then a retry with the errors
Several extraction schemas and an unknown document typetool_choice: "any"
A field the document may not containMake 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 timeThe information isn't in the document, and no retry can add it
Developers dismissing findings and nobody knows whyA detected_pattern field on each finding, so dismissals can be analyzed
Overnight reports, weekly audits, nightly test generationThe Message Batches API: half the cost, results within 24 hours, no latency guarantee
A pre-merge check someone waits onThe synchronous API
A task that needs tool calls in the middle of a requestNot a batch job: a batch request can't run tools and continue
Some documents in a batch failedResubmit only those, matched by custom_id, with the fix applied (for example, chunking)
A large batch about to runRefine the prompt on a sample first
A model reviewing its own output in the same sessionAn independent instance without the generator's reasoning
A review of many files that misses issuesPer-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 describesThe answer to look for
Amounts, dates or order numbers lost after summarizingA persistent "case facts" block in every prompt, kept outside the summarized history
Order lookups returning 40+ fields when 5 matterTrim tool output to the relevant fields before it piles up in context
Findings in the middle of a long input getting missedKey findings at the top and explicit section headers (the "lost in the middle" effect)
A customer who asks for a humanEscalate at once, without investigating first
A frustrated customer with a simple issueAcknowledge 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 priceEscalate
An agent making no meaningful progressEscalate
Escalation based on sentiment or on Claude's own confidenceWrong: neither tracks how complex the case is
Several customers matching one lookupAsk for another identifier instead of picking one by heuristic
A subagent hitting a timeoutRecover 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 workflowWrong, like hiding the failure as an empty success
A synthesis built on incomplete sourcesCoverage notes saying which findings are well supported and where sources were missing
Answers that drift, citing "typical patterns" late in a long sessionContext degradation: scratchpad files, subagents for exploration, /compact
A crash partway through a long multi-agent jobEach agent exports its state, and the coordinator loads the manifest on resume and injects it into the prompts
A system with 97% overall accuracyCheck accuracy by document type and by field before cutting human review
Measuring errors among high-confidence extractionsStratified random sampling
Deciding what reviewers should look atField-level confidence calibrated on a labeled validation set; low-confidence or contradictory cases go to a person
Sources losing their attribution during synthesisClaim-source mappings that every step keeps
Two credible sources that disagreeKeep both values with their sources and let the coordinator reconcile them
Figures from different years that look contradictoryRequire 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 answerWhy it failsWhat the exam wants
Parsing Claude's text to end the loopText can sound final in the middle of a taskstop_reason
A strongly worded prompt rule for a refund limitPrompt instructions have a non-zero failure rateA hook that blocks the call
Few-shot examples to enforce the order of tool callsExamples make the order more likely and never guarantee itProgrammatic prerequisites
Escalating on sentiment or self-reported confidenceNeither tracks how complex the case isA request for a human, a policy gap, or no progress
The Batch API for a blocking stepResults can take up to 24 hoursThe synchronous API
A bigger context window for attention problemsInformation in the middle still gets missedFocused passes and key facts at the top
An empty result when a tool failedThe agent tells the user with confidence that nothing existsA structured error with its category and retry flag
Every tool on every agentTool selection degrades as the list growsA few tools per agent, scoped to its role
"Always return valid JSON" in the promptThe output still breaks now and thenTool 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.

ScenarioWhat the system doesPrimary domains
Customer Support Resolution AgentAn 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 resolution1, 2, 5
Code Generation with Claude CodeA team uses Claude Code with custom slash commands, CLAUDE.md files and a choice between plan mode and direct execution3, 5
Multi-Agent Research SystemA coordinator delegates search, document analysis, synthesis and report writing to subagents and produces cited reports1, 2, 5
Developer Productivity with ClaudeAn Agent SDK tool explores unfamiliar codebases with Read, Write, Bash, Grep and Glob plus MCP servers1, 2, 3
Claude Code for Continuous IntegrationClaude Code runs automated reviews, generates tests and comments on pull requests, keeping false positives low3, 4
Structured Data ExtractionA system extracts data from unstructured documents, validates it against JSON schemas and passes it downstream4, 5

Pairs to Tell Apart

ThisThatThe 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_choiceAny tool, or one named tool
~/.claude/CLAUDE.mdProject CLAUDE.mdPersonal, or shared through Git
Subdirectory CLAUDE.md.claude/rules/ with pathsOne directory, or matching files anywhere
A skillCLAUDE.mdRuns on demand, or always loaded
A hookA CLAUDE.md instructionRuns every time, or guidance Claude usually follows
--resume <session-name>fork_sessionContinue a session, or branch from it
Resuming a sessionStarting fresh with a summaryPrior context still valid, or tool results gone stale
Prompt chainingDynamic decompositionA predictable review, or an open-ended investigation
Syntax errorsSemantic errorsPrevented by a schema, or caught by your validation
Access failureEmpty resultA retry decision, or a successful search with no matches
Transient errorBusiness rule errorRetry, or explain the rule to the customer
Message Batches APISynchronous APIHalf the cost and up to 24 hours, or an immediate answer
Self-reviewIndependent instanceSame reasoning context, or fresh eyes
Aggregate accuracyAccuracy by type and fieldCan 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 completed

Related 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:

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