What the CCA-F Exam Is Really Like — and 5 Prompts to be your tutor and prepare for It
I recently cleared the Claude Certified Architect — Foundations (CCA-F) exam. This is not a trivia test about API parameter names. Every question drops you into a production scenario and asks you to make the right architectural call — agent loops, MCP tool design, Claude Code configuration, structured extraction, and context reliability all show up as real engineering decisions.
Below are the five tutor prompts I used to study — one per exam domain — plus mental models, common traps, and key things to remember for each. Work through them one domain at a time.
What the Exam Actually Tests
The exam covers 5 domains (numbered to match the study sections below):
Questions are anchored to 6 scenario contexts (Customer Support Agent, Code Generation with Claude Code, Multi-Agent Research, Developer Productivity, Claude Code for CI/CD, Structured Data Extraction). Only 4 of the 6 appear on any given sitting — study all six. Passing score is 720/1000.
Official resources and references
Start with Anthropic's own materials — they map directly to the five domains above:
Recommended Academy courses (free, align with exam domains):
Building with the Claude API — Messages API, tool use, structured output
Introduction to Model Context Protocol — MCP tools, resources, server integration
Claude Code in Action — CLAUDE.md, skills, MCP, CI/CD workflows
Claude Code 101 — Claude Code fundamentals
What surprised me about the live exam
Udemy practice exams largely reflect the question patterns from when the exam first launched in March. The live exam has grown noticeably more complex since then. If you are just starting out, Udemy practice tests are still a useful baseline — but treat them as a gate, not a guarantee. If you cannot score 100% on those practice sets, you are probably not ready for the real exam yet.
The actual exam also evolves over time and gets harder as new question pools roll in. On many live questions, I found more than one answer that looked correct. The format is no longer a clean "one right answer and three obvious anti-patterns." You often face at least two very close options, and the test rewards picking the best architectural call — not just avoiding the wrong ones.
How I Prepared
One domain per session with an AI assistant as whiteboard instructor: teach → check questions → 60-question drill (pass bar 55/60) → build exercise
Suggested study order: Domain 1 → 5 → 2 → 4 → 3 (see table above for domain numbers; heaviest first; context management cascades into other domains)
Work through the domains one by one below — paste the prompt, complete the session, then read the mental models, traps, and key things as a recap before moving on
Where to run these prompts (and why)
These prompts are plain text — they work in any chat-style AI assistant that can hold a long conversation, ask follow-up questions, and run a multi-turn drill. You are not locked into one product.
Why use an AI tutor at all? The CCA-F exam is scenario-based. Reading alone does not expose you to close-call distractors. Pasting a domain prompt turns the model into a structured instructor: it adapts to your level, walks task statements in order, runs the 60-question drill, and scores you — something static notes or flashcards cannot do.
Where you can paste them:
Practical tip: Use one fresh chat per domain (and one for the full exam). Long 60-question sessions eat context — starting clean avoids the model "forgetting" early task statements.
How to use each domain block
Open your chosen assistant (see table above) and start a new conversation
Go to the Domain N section in this guide
Copy the tutor prompt verbatim and paste it — complete the 60-question drill; if you score below 55/60, revisit weak areas before moving on
Read mental models, traps, and key things below as a recap before the next domain
Repeat for all 5 domains
After all five domain sessions, run the Full Exam Practice prompt at the end — one 60-question exam across all domains
Note: a 60-question drill may span multiple messages. Expect a mix of easy (15%), medium (20%), hard (30%), and harder trap-heavy questions (35%) — similar-looking options, but only one correct answer per question.
Domain 1 — Agentic Architecture & Orchestration (27%)
Tutor prompt
You are an expert instructor teaching Domain 1 (Agentic Architecture & Orchestration) of the Claude Certified Architect exam.
This domain is worth 27% of the total exam score.
Teach like a senior architect at a whiteboard: direct, specific, grounded in production scenarios.
No hedging. No filler.
Start by asking my familiarity with agentic systems (none / built a simple agent / built multi-agent systems).
Adapt depth accordingly.
Work through 7 task statements in order.
For each one:
explain with a concrete production example,
highlight the exam traps, ask 1-2 check questions before moving on,
connect it to the next statement.
TASK STATEMENTS:
1. AGENTIC LOOPS: Complete lifecycle (Messages API, stop_reason handling, tool result appending).
Three anti-patterns: natural language termination, arbitrary iteration caps, text-content-as-completion.
Model-driven decision-making vs pre-configured decision trees.
2. MULTI-AGENT ORCHESTRATION: Hub-and-spoke architecture. Coordinator responsibilities (task decomposition, subagent selection, context passing, result aggregation). Critical isolation principle: subagents do NOT share memory with coordinator or each other. Narrow decomposition failures and root cause tracing.
3. SUBAGENT INVOCATION AND CONTEXT PASSING: The Task tool for spawning subagents. Context passing with structured metadata (source URLs, document names, page numbers) to preserve attribution. Parallel spawning for latency. fork_session for divergent exploration.
4. WORKFLOW ENFORCEMENT AND HANDOFF: Prompt-based guidance vs programmatic hooks. Decision rule: financial/security/compliance = programmatic enforcement. Multi-concern request decomposition. Structured handoff protocols for human escalation (customer ID, conversation summary, root cause, recommended action). The human agent does NOT have access to the conversation transcript.
5. AGENT SDK HOOKS: PostToolUse hooks for data normalization. Tool call interception for policy enforcement. Decision framework: hooks = deterministic guarantees, prompts = probabilistic guidance.
6. TASK DECOMPOSITION: Fixed pipelines vs dynamic adaptive decomposition. The attention dilution problem. Multi-pass architecture fix.
7. SESSION STATE: Resume vs fork vs fresh start with summary injection. The stale context problem.
After all 7, run a 60-question practice exam.
Question difficulty mix: 15% easy, 20% medium, 30% hard, 35% harder (more traps; options look alike but exactly one answer is correct in every case).
Score me. If below 55/60, revisit weak areas.
End with a build exercise: "Build a coordinator with two subagents, proper context passing, a programmatic prerequisite gate, and a PostToolUse hook."
What this domain covers
The heaviest domain on the exam. Covers agent loops, hub-and-spoke multi-agent design, explicit context passing, programmatic enforcement vs prompt guidance, Agent SDK hooks, task decomposition, and session state management.
Mental models for this domain
Hooks and gates are deterministic; prompts are probabilistic — when money, security, or compliance is on the line, pick programmatic enforcement
Subagents never share memory — every finding must be passed explicitly in the subagent prompt
Trace failures upstream — incomplete output often means bad coordinator decomposition, not a broken subagent
Close-call temptation: a prompt instruction that "usually works" vs a hook that always blocks the wrong path
Common traps
Parsing natural language to detect loop end instead of checking stop_reason
Using arbitrary iteration caps as the primary stop condition
Treating assistant text content as completion (text and tool_use can appear in the same response)
Assuming subagents inherit the coordinator's conversation history
Prompt-only identity verification before processing a refund
Resuming a stale session after files changed without re-informing the agent
Key things to remember
Loop on tool_use; stop on end_turn; append tool results every iteration
Hub-and-spoke: all inter-agent traffic routes through the coordinator
Task tool for subagents; parallel spawn for latency; fork_session for divergent paths
Human handoff needs a structured summary — the human agent does not see the full transcript
PostToolUse for normalization; PreToolUse interception for policy enforcement
Multi-pass architecture beats single-pass attention dilution when reviewing many files
Domain 2 — Tool Design & MCP Integration (18%)
Tutor prompt
You are an expert instructor teaching Domain 2 (Tool Design & MCP Integration) of the Claude Certified Architect exam.
This domain is worth 18%.
Direct, production-grounded teaching.
Ask about my MCP experience (none / used MCP tools / built MCP servers).
Adapt depth.
Work through 5 task statements.
For each: explain with production example, highlight exam traps, ask check questions, connect to next.
1. TOOL INTERFACE DESIGN: Descriptions as PRIMARY selection mechanism. Good description components. The misrouting problem. Tool splitting. System prompt conflicts.
Practice scenario: Agent routes "check order #12345 status" to get_customer instead of lookup_order. Both say "Retrieves [entity] information." Four fixes. Walk through why better descriptions is correct.
2. STRUCTURED ERROR RESPONSES: MCP isError flag. Four categories (transient/validation/business/permission). Access failure vs valid empty result. Structured metadata. Multi-agent error propagation.
3. TOOL DISTRIBUTION AND TOOL_CHOICE: 18-tool degradation. Optimal 4-5 per agent. Auto vs any vs forced. Scoped cross-role tools (85% simple lookups).
4. MCP SERVER INTEGRATION: Project-level vs user-level config. Env var expansion. MCP resources. Build-vs-use decision.
5. BUILT-IN TOOLS: Grep (contents) vs Glob (paths). Read/Write/Edit selection. Incremental exploration patterns.
After all 5, run a 60-question practice exam.
Question difficulty mix: 15% easy, 20% medium, 30% hard, 35% harder (more traps; options look alike but exactly one answer is correct in every case).
Score me. If below 55/60, revisit weak areas.
Build exercise: "Create 3 MCP tools with one ambiguous pair. Write error responses for all four categories. Configure in .mcp.json with env var expansion."
What this domain covers
How Claude selects tools, structured MCP error responses, tool scoping and tool_choice, MCP server configuration, and built-in exploration tools (Grep, Glob, Read, Write, Edit).
Mental models for this domain
Tool descriptions are the primary routing mechanism — not function names, not the system prompt
Scope 4–5 tools per agent; giving an agent 18 tools degrades selection reliability
Access failure is not the same as a valid empty result — design errors and responses accordingly
Close-call temptation: adding few-shot routing, a classifier layer, or merging tools when lazy descriptions are the root cause
Common traps
Identical descriptions on get_customer vs lookup_order causing misrouting
Returning empty success on a permission or access failure
Giving every agent access to all tools in the system
Reading the entire codebase upfront instead of Grep → Read incrementally
Confusing Grep (searches file contents) with Glob (matches file paths)
Key things to remember
Good descriptions include purpose, inputs, example queries, and boundaries vs similar tools
MCP isError flag plus four error categories: transient, validation, business, permission
tool_choice modes: auto, any, forced — each serves a distinct use case
Project-level vs user-level MCP config; env var expansion in .mcp.json
For high-frequency simple lookups (~85%), give a scoped tool directly to the agent instead of routing everything through the coordinator
Domain 3 — Claude Code Configuration & Workflows (20%)
Tutor prompt
You are an expert instructor teaching Domain 3 (Claude Code Configuration & Workflows) of the Claude Certified Architect exam.
This domain is worth 20%.
Configuration-heavy domain.
Ask about my Claude Code experience (never used / daily user / configured for a team).
Adapt depth.
Work through 6 task statements:
1. CLAUDE.md HIERARCHY: User-level vs project-level vs directory-level. The new-team-member trap. Modular organization with @import and .claude/rules/. The /memory debugging command.
2. CUSTOM COMMANDS AND SKILLS: .claude/commands/ (shared) vs ~/.claude/commands/ (personal). Skill frontmatter: context: fork, allowed-tools, argument-hint.
3. PATH-SPECIFIC RULES: .claude/rules/ with YAML frontmatter globs. Advantage over directory-level CLAUDE.md. Token efficiency.
4. PLAN MODE VS DIRECT EXECUTION: Decision framework. Explore subagent. The hybrid pattern.
5. ITERATIVE REFINEMENT: Concrete examples beat prose. Test-driven iteration. Interview pattern.
6. CI/CD: The -p flag. Structured JSON output. Independent review instances. Incremental review context.
After all 6, run a 60-question practice exam.
Question difficulty mix: 15% easy, 20% medium, 30% hard, 35% harder (more traps; options look alike but exactly one answer is correct in every case).
Score me. If below 55/60, revisit weak areas.
Build exercise: "Set up CLAUDE.md hierarchy, .claude/rules/ with glob patterns, a skill with context: fork, and a CI script using -p with JSON output."
What this domain covers
Where instructions live (CLAUDE.md hierarchy), custom commands and skills, path-specific rules, plan mode vs direct execution, iterative refinement patterns, and non-interactive CI/CD with Claude Code.
Mental models for this domain
Project-level .claude/CLAUDE.md is team truth; user-level ~/.claude/CLAUDE.md is personal only
Path-specific rules with globs beat directory-level CLAUDE.md when conventions span the whole repo
Plan for exploration and architectural decisions; execute directly when the fix is already known
Close-call temptation: stuffing task-specific workflows into always-loaded CLAUDE.md instead of skills
Common traps
Team standards living in ~/.claude/CLAUDE.md — new hires get inconsistent output
Using directory CLAUDE.md when glob-based rules would load only relevant context
Running Claude Code in CI without the -p flag (job hangs waiting for input)
Same Claude session reviewing its own generated code
Writing standards as prose when concrete examples would be clearer and more consistent
Key things to remember
Hierarchy: user → project → directory; debug loaded instructions with /memory
.claude/commands/ is shared via git; ~/.claude/commands/ is personal
Skill frontmatter: context: fork, allowed-tools, argument-hint
.claude/rules/ with YAML globs for token-efficient, path-targeted rules
CI: -p for non-interactive mode + structured JSON output; use an independent review instance
Domain 4 — Prompt Engineering & Structured Output (20%)
Tutor prompt
You are an expert instructor teaching Domain 4 (Prompt Engineering & Structured Output) of the Claude Certified Architect exam.
This domain is worth 20%.
Ask about my prompt engineering experience (basic prompting / used few-shot / built extraction pipelines).
Adapt depth.
Work through 6 task statements:
1. EXPLICIT CRITERIA: Categorical criteria vs vague confidence instructions. The false positive trust problem. Severity calibration with code examples.
2. FEW-SHOT PROMPTING: Most effective technique for consistency. When to deploy. How to construct examples with reasoning.
3. STRUCTURED OUTPUT WITH TOOL_USE: Syntax errors eliminated, semantic errors not. tool_choice modes. Schema design: nullable fields, "unclear" enums, "other" + detail strings.
4. VALIDATION-RETRY LOOPS: Retry-with-error-feedback. Effectiveness boundary (format errors yes, missing data no). detected_pattern fields.
5. BATCH PROCESSING: Batches API constraints (50% savings, 24hr window, no multi-turn). Synchronous vs batch decision rule.
6. MULTI-INSTANCE REVIEW: Self-review limitation. Multi-pass architecture. Confidence-based routing.
After all 6, run a 60-question practice exam.
Question difficulty mix: 15% easy, 20% medium, 30% hard, 35% harder (more traps; options look alike but exactly one answer is correct in every case).
Score me. If below 55/60, revisit weak areas.
Build exercise: "Create an extraction tool with JSON schema (required, optional, nullable fields, enums). Implement validation-retry. Process 10 documents with few-shot examples."
What this domain covers
Explicit criteria over vague instructions, few-shot consistency, JSON schema design via tool_use, validation-retry loops, batch vs synchronous API decisions, and multi-instance review patterns.
Mental models for this domain
Explicit categorical criteria beat vague "be conservative" or "high confidence only" instructions
tool_use with JSON schema eliminates syntax errors — not semantic errors or fabrication
Validation-retry fixes format and placement errors; it cannot invent data missing from the source
Batch API is a latency tradeoff (up to 24-hour window), not a default cost optimization
Close-call temptation: self-review or LLM confidence scores when independent multi-pass review is required
Common traps
"High confidence only" without defining what qualifies as high confidence
Making every schema field required — the model fabricates values for missing data
Running retry loops on information that does not exist in the source document
Using the Batch API for blocking pre-merge checks developers wait on
Single-pass self-review on code the same session just generated
Using few-shot examples to enforce tool ordering when programmatic gates are needed
Key things to remember
Few-shot examples with reasoning teach generalization, not rigid pattern matching
Schema design: nullable fields, "unclear" enums, "other" + freeform detail strings
Batches API: 50% cost savings, 24-hour window, no multi-turn tool calling
Multi-instance review catches what self-review misses
High false-positive rate in one category erodes trust in all categories
Domain 5 — Context Management & Reliability (15%)
Tutor prompt
You are an expert instructor teaching Domain 5 (Context Management & Reliability) of the Claude Certified Architect exam.
This domain is worth 15%.
Smallest weighting, but these concepts cascade into Domains 1, 2, and 4.
Ask about my experience with long-context applications and multi-agent systems.
Adapt depth.
Work through 6 task statements:
1. CONTEXT PRESERVATION: Progressive summarization trap. Persistent case facts blocks. Lost-in-the-middle effect. Tool result trimming.
2. ESCALATION AND AMBIGUITY: Three valid triggers vs two unreliable ones. Frustration nuance. Ambiguous customer matching.
3. ERROR PROPAGATION: Structured error context. Silent suppression vs workflow termination. Access failure vs valid empty result.
4. CODEBASE EXPLORATION: Context degradation. Scratchpad files. Subagent delegation. Summary injection. /compact.
5. HUMAN REVIEW AND CONFIDENCE: Aggregate accuracy masking per-type errors. Stratified sampling. Field-level confidence calibration.
6. INFORMATION PROVENANCE: Claim-source mappings through synthesis. Conflict handling. Temporal awareness.
After all 6, run a 60-question practice exam.
Question difficulty mix: 15% easy, 20% medium, 30% hard, 35% harder (more traps; options look alike but exactly one answer is correct in every case).
Score me. If below 55/60, revisit weak areas.
Build exercise: "Build a coordinator with two subagents. Implement persistent case facts. Simulate a timeout with structured error propagation. Test with conflicting sources."
What this domain covers
The smallest domain by weight, but concepts here cascade everywhere — context preservation, escalation triggers, structured error propagation, codebase exploration strategies, human review sampling, and information provenance through synthesis.
Mental models for this domain
Never summarize away transactional facts — use persistent case-facts blocks injected every turn
Structured error context enables coordinator recovery; silent suppression kills it
Escalate on explicit customer request, policy gap, or stuck progress — not frustration alone
Close-call temptation: sentiment-based escalation or LLM self-reported confidence as routing signals
Common traps
Progressive summarization erasing order IDs, dollar amounts, and dates
Silent empty results from a failed subagent marked as success
Terminating the entire workflow on a single subagent timeout
Burying key facts in the middle of long aggregated context (lost-in-the-middle)
Picking one conflicting source without annotating both values and publication dates
Aggregate accuracy masking systematic failures on one document type
Key things to remember
Case facts block injected every turn; trim verbose tool outputs before they fill context
Three valid escalation triggers vs two unreliable ones (sentiment, self-confidence)
Scratchpad files and subagent delegation for codebase exploration; /compact when context degrades
Claim-source mapping must survive synthesis layers
Stratified sampling for human review — not aggregate pass rate alone
Full Exam Practice — All Domains
Run this after completing all five domain tutor sessions. One prompt, one full-length exam — same rules as the per-domain drills: 60 questions, pass bar 55/60, same difficulty mix.
Difficulty mix (all 60): 15% easy (9) · 20% medium (12) · 30% hard (18) · 35% harder (21) — trap-heavy, similar-looking options, exactly one correct answer per question.
Full exam tutor prompt
You are an expert CCA-F exam proctor for the Claude Certified Architect — Foundations certification.
Run one comprehensive practice exam covering ALL five domains. Proctor only — do not teach during the exam.
DOMAIN COVERAGE (60 questions total, weighted like the real exam):
1. Agentic Architecture & Orchestration (27%) — 16 questions
2. Tool Design & MCP Integration (18%) — 11 questions
3. Claude Code Configuration & Workflows (20%) — 12 questions
4. Prompt Engineering & Structured Output (20%) — 12 questions
5. Context Management & Reliability (15%) — 9 questions
QUESTION FORMAT:
- Scenario-based multiple choice: exactly 1 correct answer and 3 plausible distractors per question
- Question difficulty mix across all 60: 15% easy (9), 20% medium (12), 30% hard (18), 35% harder (21)
- Harder questions: more traps, similar-looking options — but exactly one answer is correct in every case
- Anchor questions to 4 of the 6 official exam scenarios (ask me to pick 4, or select 4 at random):
Customer Support Agent, Code Generation with Claude Code, Multi-Agent Research, Developer Productivity, Claude Code for CI/CD, Structured Data Extraction
EXAM FLOW:
- Present questions in batches of 10. Wait for my answers before scoring that batch or showing the next batch.
- Do not reveal correct answers until I submit my choices for each batch.
- After all 60 questions, give final score out of 60 and a breakdown by domain.
- If below 55/60, identify weak domains and task areas to revisit before retrying.
AFTER THE EXAM:
- Review every missed question: correct answer, why the trap option looked tempting, and which domain task statement it maps to.
- Offer one optional 10-question remediation set targeting my weakest domain only.
Good luck on your exam
If you have worked through all five domains — pasted the prompts, sat through the drills, scored 55/60 or above on each — and finished the Full Exam Practice at 55/60 or above, you are in a strong place. The live exam will still throw close calls at you. That is by design. Trust the mental models, trace problems to root causes, and pick the simplest intervention that actually satisfies the constraints.
You have done the hard part: building real architectural judgment, not memorizing answers. Go in confident, stay calm on the tricky two-option questions, and trust what you practiced.
Wishing you the best on exam day. You have got this.
No comments:
Post a Comment