CCA-F Complete Study Summary · 2026
Building with Claude —
6-Course + Exam Guide
All six courses plus the CCA-F exam format, domain breakdown, 15 mock questions with explanations, and key frameworks tested on the proctored exam.
Claude Code in ActionClaude APIMCP IntroAgent SkillsSubagentsMCP Advanced⚡ CCA-F Exam Prep
Course 1 of 6
Claude Code in Action
Terminal-based AI coding assistant — architecture, context management, custom commands, MCP servers, GitHub integration, hooks, and the SDK.
⬡What is Claude Code?

A terminal-based AI coding assistant that runs directly in the command line, reading files, writing code, executing shell commands, and chaining multiple tool calls to handle complex multi-step tasks. Core loop: LLM receives a task → picks a tool → observes result → plans next step → repeats.

  • Prerequisites: Node.js, terminal, basic Git knowledge
  • Tools available: file read/write, bash execution, web search, code analysis
  • Can chain tools automatically across many steps without re-prompting
📋Context Management
CLAUDE.md

Project-level instruction file in the root directory. Claude reads it automatically every session. Use for architecture notes, coding standards, team conventions.

@ References

Inline file or folder references during a conversation. Points Claude to specific source files without copying content.

/clear

Resets the context window. Use when shifting tasks to remove stale context. Keep CLAUDE.md concise to save tokens.

⚡Custom Commands

Markdown files in .claude/commands/ become slash commands (/command-name). Encode repetitive workflows so you define them once.

  • File name = command name (review.md → /review)
  • Can include placeholders and multi-step instructions
  • Commit to repo for team sharing
🪝Hooks

Shell commands bound to lifecycle events. Run outside the model's context window — zero token cost.

HookFires whenCommon use
PreToolUseBefore any tool callValidation, logging, blocking dangerous commands
PostToolUseAfter a tool call returnsAuto-format, notifications, audit logs
NotificationOn important model eventsSlack alerts, desktop notifications
Gotcha: Hook failures can block tool execution. Test with --dry-run before enabling in production.
🛠SDK & Thinking Mode

The SDK exposes Claude Code programmatically for custom tooling, CI scripts, and automation pipelines. Thinking mode: for complex multi-step problems, Claude reasons before acting — more tokens but better decisions.

Course 2 of 6
Building with the Claude API
Full developer curriculum — API basics, prompt engineering, tool use, RAG, extended features, MCP, and agentic architectures.
🔑API Fundamentals
import anthropic client = anthropic.Anthropic() msg = client.messages.create( model="claude-opus-4-6", max_tokens=1024, system="You are a helpful assistant.", messages=[{"role":"user","content":"Hello"}] )
  • Temperature 0–1: 0 = deterministic, 1 = creative
  • Streaming: pass stream=True for real-time tokens
  • Structured output: instruct JSON; validate with Pydantic
  • Multi-turn: send full message history each call — no server-side memory
📐Prompt Engineering — PRECISE Framework
P — Persona

Define the role Claude plays. "You are a senior Python engineer reviewing for security."

R — Role

Clarify the task context: reviewer, generator, classifier, etc.

E — Explicit instructions

State exactly what to do and what to avoid. Positive + negative instructions.

C — Context

Provide relevant background. Use XML tags: <document>, <data>.

I — Instructions format

Specify output format: JSON, markdown table, bullet list, prose.

S/E — Steps + Examples

Few-shot examples anchor tone, length, and format. Missing examples = output variance.

🔧Tool Use (Function Calling)
  • Define tools with name, description, input_schema (JSON Schema)
  • Claude returns tool_use block → you execute → send tool_result back
  • tool_choice can force or disable specific tools
  • Built-ins: web search, text editor, code execution
Multi-turn tools: send tool results with role user, type tool_result in message history.
🗂RAG Pipeline
StepWhat happens
ChunkSplit docs into overlapping segments
EmbedEncode chunks into dense vectors
IndexStore in vector DB + BM25 lexical index
RetrieveTop-k semantic + lexical hybrid search
GenerateInject chunks into context; Claude answers
✨Extended Features
Extended Thinking

Step-by-step reasoning before answering. More tokens, better logic for hard tasks.

Image & PDF

Pass base64 or URL images; PDF documents directly in messages array.

Prompt Caching

Mark stable prefixes with cache_control. Reuse KV cache — reduces latency and cost.

Files API

Upload once, reference by file ID. Avoids resending large content.

Citations

Grounded citations pointing to specific source passages.

Message Batches

Process many requests asynchronously at reduced cost.

🤖Agent Workflow Patterns
PatternDescriptionWhen to use
ChainingOutput of one call → input of nextFixed linear pipelines
ParallelizationMultiple calls run concurrentlyIndependent subtasks, fan-out
RoutingClassifier decides which handler to invokeMulti-intent classification
Autonomous AgentModel picks tools and steps dynamicallyOpen-ended, unpredictable tasks
Key rule: Prefer deterministic workflows over agents when the structure is known. Agents are more powerful but harder to debug and more expensive.
Course 3 of 6
Introduction to Model Context Protocol
Build MCP servers and clients from scratch using Python SDK. Master the three core primitives — tools, resources, and prompts.
🏗MCP Architecture

MCP moves tool definition and execution out of your app into specialized reusable servers. Transport-agnostic: communicates over stdio (local) or HTTP/SSE (remote).

PrimitiveControlled byPurposeExample
ToolsModelActions with side effectscreate_task(), send_email()
ResourcesApplicationRead-only data for context injectionfile:///readme.md
PromptsUserPre-crafted prompt templates/format-document
🖥Building MCP Server (Python SDK)
from mcp.server.fastmcp import FastMCP from pydantic import Field app = FastMCP("my-server") @app.tool() def read_document(path: str = Field(description="File path")) -> str: """Read a document from disk.""" with open(path) as f: return f.read() @app.resource("file://{path}") # templated resource def get_file(path: str) -> str: with open(path) as f: return f.read()
  • Decorators auto-generate JSON schemas from type hints + Field descriptions
  • Use Server Inspector (browser UI) to test before writing a client
  • Prompts: @app.prompt() returns a list of message objects
🔌Full Request Flow
  • User sends message → MCP Client receives it
  • Client calls Claude API with message + tool definitions from MCP server
  • Claude responds with tool_use block
  • Client calls mcp_server.call_tool(name, args)
  • Client sends tool_result back to Claude
  • Claude generates final text response
Course 4 of 6
Introduction to Agent Skills
Build, configure, share, and troubleshoot Skills — reusable markdown instructions Claude automatically applies to matching tasks.
🎯What are Skills?

Skills are SKILL.md files in .claude/skills/ that teach Claude how to perform a specific task type. The frontmatter description triggers matching; the body is injected into context automatically.

--- name: code-review description: | Use when user asks to review, audit, or check code for quality, bugs, or style. allowed-tools: [Read, Grep] context: fork # isolated context window --- Check for: null pointers, security issues, naming consistency, and test coverage gaps.
🔀Skills vs Other Features
FeatureTriggerBest for
SkillsAuto description matchReusable task patterns across projects
CLAUDE.mdAlways loadedProject architecture, always-on context
HooksTool lifecycle eventsLogging, validation, notifications
Custom CommandsExplicit /command callNamed workflows invoked manually
SubagentsExplicit invocationIsolated expert tasks with own context
🌐Sharing & Troubleshooting
  • Team: commit .claude/skills/ to repo — all cloners get Skills automatically
  • Plugins: package for multi-repo distribution
  • Enterprise: deploy org-wide via managed settings
  • Won't trigger? Description too vague — add more specific task-oriented language
  • Wrong skill fires? Use priority: field to rank conflicting Skills
  • Context overflow? Split into SKILL.md + REFERENCE.md with progressive disclosure
Course 5 of 6
Introduction to Subagents
Use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.
🤝What is a Subagent?

A subagent is an isolated Claude Code instance with its own context window, spawned by a coordinator (parent) agent to handle a specific, bounded task. The subagent runs to completion and returns only its result — its internal scratchpad never pollutes the parent's context.

Key distinction: Skills configure behaviors. Subagents parallelize work in isolated context. You can combine both: a subagent equipped with a Skill is an isolated expert agent.
  • Invoked with /agents in Claude Code or programmatically via the Agent SDK
  • Each subagent has its own independent context window — no shared memory
  • Reduces context pressure on the main session dramatically
  • Can be configured with their own allowed tools and Skills
🏛Hub-and-Spoke Orchestration

The dominant multi-agent pattern on the exam. A single coordinator (hub) decomposes a task and delegates each subtask to a specialized subagent (spoke). The coordinator collects results and synthesizes the final output.

Coordinator role

Task decomposition, subagent spawning, result aggregation, error handling, final synthesis. Never does the actual work.

Subagent role

Executes one bounded task, returns structured output. Reports obstacles back; does not attempt to fix problems outside its scope.

Parallel execution

Independent subtasks can run simultaneously — much faster than sequential for research, data gathering, or analysis tasks.

Sequential execution

When each step depends on the previous result. Slower but necessary when outputs chain together.

Exam trap: When all subagents complete successfully but the output is incomplete — the problem is almost always in the coordinator's task decomposition, not in the subagents.
📤Context Passing & Structured Output

Subagents do not automatically inherit the coordinator's conversation history. The coordinator must explicitly include all relevant context in each subagent's prompt. This is the #1 source of missing-findings bugs.

  • Always pass complete prior findings — never assume the subagent "knows" what happened
  • Require subagents to return structured outputs (JSON with defined fields) rather than free prose
  • Include source provenance in structured outputs: URLs, document names, page numbers, timestamps
  • Require subagents to include publication_date or data collection dates for temporal accuracy
  • Content-type-appropriate rendering: financial data as tables, news as prose, technical findings as structured lists
⚠Error Handling & Escalation

Robust subagent error handling is heavily tested. Errors should be classified so the coordinator can decide the right recovery action.

Error typeisRetryableCoordinator action
Transient (timeout, unavailable)trueRetry with exponential backoff
Validation (invalid input)falseFix inputs, then retry
Permission (unauthorized)falseSurface to user — do NOT auto-escalate
Business rule (policy violation)falseReturn customer-friendly explanation
Minimal-footprint principle: Subagents should never autonomously acquire permissions or capabilities beyond what was explicitly granted. Permission errors → escalate to user, never self-resolve.
  • Structured error responses must include: errorCategory, isRetryable boolean, human-readable description
  • Generic "Operation failed" responses prevent the coordinator from making correct recovery decisions
  • Subagents should handle transient errors locally; propagate only what they cannot resolve
  • Always include partial results when available, even on failure
🔁Session Management & Agentic Loop

The agentic loop lifecycle: observe → think → act → respond → repeat until stop condition. Key stop reasons and their implications:

  • end_turn — Claude completed the task normally
  • tool_use — Claude is waiting for a tool result; must be handled and loop continued
  • max_tokens — context is full; trigger compaction or escalate
  • stop_sequence — a defined terminator was hit
  • Session resume: use session IDs to resume interrupted long-running tasks; prefer resume over fresh-start to preserve accumulated state
  • Clarify before long runs: resolve ambiguity at the start, not mid-execution — interrupting an autonomous run is costly
🧩Subagent Patterns
Explore subagent

Specialized first-pass agent that maps the codebase or problem space and returns a structured summary for the coordinator to plan with.

Iterative refinement

Multiple agents collaborate in stages: generate → review → revise → test. Each stage improves quality.

Independent review instances

Same prompt sent to multiple subagent instances simultaneously; divergent responses flag uncertainty for human review.

Skills + Subagents

Wire a Skill into a subagent's context for an isolated expert with pre-loaded domain knowledge and restricted tools.

Course 6 of 6
MCP Advanced Topics
Sampling, notifications, file system access, transport mechanisms, authentication patterns, and production MCP server architecture.
🚀Transport Layers: stdio vs SSE

Choosing the wrong transport is a common exam mistake. The rule is simple: local = stdio, remote = SSE.

TransportUse caseNetworkStreaming
stdioLocal subprocess (same machine)No — IPC onlyNot applicable
SSE (HTTP)Remote/cloud serversYes — crosses network boundariesReal-time via HTTP
Exam rule: If the scenario mentions cloud deployment, distributed system, or network boundary → SSE is always correct. WebSocket is NOT a supported MCP transport.
📡Sampling

Sampling allows an MCP server to request LLM completions from the client (reverse direction). This enables servers to be "AI-aware" — they can ask the model to process data before returning a result.

  • The server sends a sampling/createMessage request to the client
  • The client (which holds the API key) performs the LLM call and returns the result
  • Servers never need their own API keys — the client mediates all model access
  • Use for: summarizing content, classifying data, generating text within a tool response
🔔Notifications & Progress

Long-running MCP tools can send progress notifications to the client so users aren't left waiting with no feedback.

  • Server sends notifications/progress messages during execution
  • Client displays progress to the user in real time
  • Also used for: resources/updated (cached resource invalidation), tools/list_changed (dynamic tool registration)
  • Notifications are fire-and-forget — they don't require a response from the client
📁File System Access & Resources as Content Catalogs

MCP resources are ideal for exposing file systems, databases, or any read-only data catalog. Resources with high-quality descriptions enable Claude to intelligently select which content to retrieve.

  • Static resources: fixed URI, fixed content (e.g., file:///config.json)
  • Templated resources: parameterized URI (e.g., db://users/{id})
  • Resource descriptions function as a catalog — Claude reads them to decide what to fetch
  • Write detailed, accurate descriptions; vague descriptions cause Claude to miss or misuse resources
  • Resources surface via list_resources(); content via read_resource(uri)
🔒Authentication & Production Patterns

MCP servers in production need proper auth. The exam tests patterns for secure deployment.

Environment variables

Pass credentials via env vars in server config — never hardcode in tool definitions. Use ${VAR_NAME} expansion in MCP config files.

OAuth / token flow

For SSE servers, use standard HTTP auth headers. The MCP spec supports OAuth 2.0 bearer tokens for remote servers.

Scope limiting

Each MCP server should expose only the tools necessary for its purpose. Avoid registering unnecessary tools — they pollute Claude's decision space.

isError flag

Return isError: true in tool results for failures. Claude recognizes this and handles it appropriately without confusing errors with valid empty results.

✍Writing Tool Descriptions That Work

Tool descriptions are the primary mechanism by which Claude decides which tool to call. Poor descriptions are the #1 cause of tool misrouting.

  • Start with a verb: "Searches for…", "Returns…", "Creates…", "Deletes…"
  • Distinguish similar tools explicitly: "Use this for X, not Y. For Y use get_user_profile."
  • Describe what the tool does NOT do when there's risk of confusion
  • Include expected input format and what the return value looks like
  • Test: send Claude a task and verify it picks the right tool — iterate on descriptions if it doesn't
Exam pattern: Questions often present a broken or suboptimal tool schema and ask you to identify the flaw. Look for: missing descriptions, ambiguous names, overlapping tool scopes, missing nullable fields in JSON Schema.
⚙Multi-Server Configuration in Claude Code
  • Configure multiple MCP servers in .claude/settings.json or settings.local.json
  • Each server listed under mcpServers with its command or URL + env vars
  • Project-level settings apply to all contributors; local settings are machine-specific (not committed)
  • Tools from all servers are available simultaneously; Claude must distinguish them by name and description
  • Use namespacing in tool names if servers overlap: filesystem_read vs database_read
CCA-F Exam Preparation
Claude Certified Architect — Foundations
Exam format, 5 domain weightings, key frameworks, 8 verified common traps, 15 mock questions with full explanations, and a study timeline.
📋Exam Format
DetailValue
Total questions60 scenario-based multiple choice
Time limit120 minutes (~2 min/question)
Passing score720 / 1000 (≈ 75% — 45 of 60 correct)
ScoringDomain-weighted (heavier domains count more)
FormatClosed-book, proctored, no AI assistance
DeliveryProctorFree online
Fee$99 (free for first 5,000 Claude Partner Network employees)
Validity2 years from passing date
Registration: anthropic.skilljar.com/claude-certified-architect-foundations-access-request — requires Claude Partner Network membership (free to join).
📊5 Domains & Weightings
DomainWeight~QuestionsKey topics
1. Agentic Architecture 27%~16 Agentic loops, hub-and-spoke orchestration, subagent patterns, minimal-footprint, human-in-the-loop, error recovery, stop_reason handling
2. Claude Code Configuration 20%~12 CLAUDE.md hierarchies, .claude/rules/, settings.json vs settings.local.json, slash commands, MCP server config, CI/CD with -p flag
3. Prompt Engineering 20%~12 PRECISE framework, few-shot examples, chain-of-thought, extended thinking, structured output (JSON Schema, nullable fields), validation-retry loops, prompt injection defense
4. Tool Design & MCP 18%~11 MCP primitives, tool descriptions, JSON Schema, stdio vs SSE transport, isError flag, structured error responses, authentication, resource catalogs
5. Context Management 15%~9 CALM framework, prompt caching with cache_control, conversation compaction, token budgeting, scratchpad files, subagent delegation for context relief
🧠Key Frameworks to Memorize
PRECISE (Prompt Eng.)

Persona, Role, Explicit instructions, Context, Instructions format, Steps, Examples. Missing the Examples component = tone/length variance.

CALM (Context Mgmt)

Context-Aware LLM Management. Covers prompt caching, conversation compaction, token estimation, and multi-turn quality maintenance.

Minimal-footprint

Agents should not acquire permissions or capabilities beyond what was explicitly granted. Permission errors → escalate to user, never self-resolve.

Hub-and-spoke

Coordinator decomposes → spawns specialized subagents → aggregates results. Coordinator never does the actual work.

isError + isRetryable

Structured MCP error responses must classify error type and retryability. Generic errors block correct coordinator recovery.

SSE for remote

Any cloud / cross-network MCP deployment = SSE transport. stdio = local subprocess only. WebSocket is not a valid MCP transport.

⚠Common Exam Traps (Anti-Patterns)

Verified from people who passed — these distractors look reasonable but are always wrong:

  • ❌ Add few-shot examples to enforce tool ordering — Ordering is a compliance concern; use programmatic prerequisites (hooks, gates), not demonstrations.
  • ❌ Self-reported confidence scores for escalation routing — LLM confidence is poorly calibrated. The model is confidently wrong on hard cases.
  • ❌ Route all workflows to Batch API for cost savings — Batch has no SLA (up to 24h). Blocking/live workflows must use real-time API.
  • ❌ A larger context window fixes attention dilution — Window size ≠ attention quality. Split into focused per-file passes instead.
  • ❌ Return empty results on subagent failure — Silently suppressing errors prevents coordinator recovery. Always return structured error context.
  • ❌ Give all agents access to all tools — Too many tools (18 vs 4–5) degrades selection reliability. Scope tools to each agent's role.
  • ❌ "Be conservative" to reduce false positives — Vague instructions don't reduce FP. Write explicit categorical criteria with concrete code examples.
  • ❌ Resume a session when prior tool results are stale — Starting fresh with an injected structured summary is more reliable than resuming stale context.
❓15 Mock Questions with Verified Explanations

All questions cross-checked against the official CCA-F Exam Guide PDF and domain knowledge from verified pass-holders. Covers all 5 domains proportionally.

Sources: Official CCA-F Exam Guide PDF, claudecertifiedarchitects.com exam guide, certsafari.com domain breakdown, and verified pass-holder domain cheatsheet.
D1 · Agentic Architecture — Agentic Loop
Your agentic loop code checks whether the assistant's message contains the text "Task complete" to decide when to stop. During testing, the loop occasionally terminates early or runs indefinitely. What is the root cause?
AThe model's temperature is too high, causing inconsistent phrasing of completion signals
BThe system prompt doesn't instruct Claude to say "Task complete" consistently
C ✓Parsing natural language signals to determine loop termination is an anti-pattern; the loop should check stop_reason instead
DThe max_tokens parameter is too low, cutting off the completion message
Why C is correct
The official exam guide explicitly lists "parsing natural language signals to determine loop termination" as an anti-pattern. The correct approach is to inspect stop_reason: continue when it is "tool_use", terminate when it is "end_turn". Natural language signals are unreliable by design — text content varies with every generation.
D1 · Agentic Architecture — Multi-Agent Orchestration
Your multi-agent research system produces a report on "the impact of AI on creative industries" but the final output only covers visual arts, missing music, writing, and film. All subagents completed successfully. What is the most likely root cause?
AThe synthesis subagent's context window was too small to include all research findings
B ✓The coordinator's task decomposition was too narrow — it assigned all subagents to research only visual arts categories
CThe web search subagent's queries were biased toward visual arts content
DThe report subagent's output template only had sections for visual arts
Why B is correct
When all subagents complete successfully but output is incomplete, the problem lies in the coordinator's task decomposition. If the coordinator decomposed "creative industries" narrowly and sent subagents only to visual arts categories, every subagent would diligently cover only those areas. The official exam guide specifically flags "overly narrow task decomposition leading to incomplete coverage" as a coordinator-level failure mode.
D1 · Agentic Architecture — Hooks & Enforcement
A customer support agent must verify a customer's identity before processing any refund. The current prompt says "Always call get_customer before process_refund." During a security audit, testers find the agent occasionally processes refunds without verification. What is the correct fix?
ARewrite the system prompt to be more emphatic — use bold text and repeat the rule three times
BAdd few-shot examples showing the correct get_customer → process_refund sequence
CLower the temperature to make Claude more deterministic and rule-following
D ✓Implement a programmatic prerequisite gate or PreToolUse hook that blocks process_refund unless get_customer has returned a verified customer ID
Why D is correct
This is the single most-tested concept on the exam. When something must happen — especially with financial or security consequences — prompt instructions have a non-zero failure rate and are insufficient. Programmatic enforcement (hooks, prerequisite gates) provides deterministic compliance. The exam guide states: "when deterministic compliance is required, prompt instructions alone have a non-zero failure rate." A, B, and C are all probabilistic approaches.
D1 · Agentic Architecture — Session Management
After a long Claude Code session analyzing a codebase, a developer modifies 3 source files and wants to resume the session to continue their refactoring task. What is the most reliable approach?
AUse --resume with the session name — the agent will automatically detect file changes
B ✓Resume the session with --resume, then explicitly inform Claude which files were modified so it can re-analyze those specifically
CStart a fresh session with the original task prompt — resuming with stale tool results is always unreliable
DUse fork_session to create a branch from the prior session and continue there
Why B is correct
The official exam guide states: "After file edits, explicitly inform the agent about changes to previously analyzed files when resuming sessions — for targeted re-analysis rather than requiring full re-exploration." Session resumption is reliable when the prior context is mostly valid; A is wrong because the agent does NOT auto-detect file changes. C (fresh start) is the right choice only when prior tool results are stale across the board. D (fork_session) is for exploring divergent approaches from a shared baseline.
D2 · Claude Code Config — CLAUDE.md Hierarchy
A new engineer joins the team and reports that Claude Code doesn't follow the team's coding standards. Other team members have no issues. The standards are written in the tech lead's ~/.claude/CLAUDE.md. What is the problem?
AThe new engineer's Claude Code version is outdated and doesn't support user-level configuration
B ✓User-level ~/.claude/CLAUDE.md applies only to that user's machine — it is not shared with teammates via version control
CThe new engineer needs to run /memory to load the tech lead's configuration file
DThe tech lead should add the standards to the project's root CLAUDE.md instead of using the ~/.claude/ directory
Why B is correct (and D is also needed but B explains the root cause)
User-level ~/.claude/CLAUDE.md is machine-specific and not committed to version control. It only applies to the user whose home directory it lives in. D describes the correct fix, but B is the root cause. Team-wide standards must go in the project-level .claude/CLAUDE.md or root CLAUDE.md, committed to the repository.
D2 · Claude Code Config — CI/CD Integration
You are integrating Claude Code into a GitHub Actions pipeline to review pull requests for security issues. The pipeline hangs indefinitely whenever Claude Code is invoked. What is the most likely cause and fix?
AThe ANTHROPIC_API_KEY secret is not set correctly in the repository settings
BGitHub Actions doesn't support Claude Code — use the Claude API directly instead
C ✓Claude Code is running in interactive mode by default; add the -p flag to run in non-interactive (print) mode
DThe pipeline needs a PTY (pseudo-terminal) allocation to run Claude Code correctly
Why C is correct
The official exam guide explicitly covers this: "Use the -p (or --print) flag to run Claude Code in non-interactive mode. This prevents the pipeline from hanging waiting for user input." Without -p, Claude Code waits for terminal input that never comes in a CI environment. Add --output-format json for machine-parseable findings as inline PR comments.
D2 · Claude Code Config — Skills & Context Isolation
A developer creates a skill that performs a comprehensive codebase analysis before every task. After enabling it, they notice the main conversation context fills up quickly even for simple tasks. What frontmatter option should they add?
Amax-tokens: 1000 — limit the skill's output length
B ✓context: fork — run the skill in an isolated sub-agent, preventing its verbose output from polluting the main session
Clazy: true — defer skill loading until explicitly invoked
Dallowed-tools: [] — restrict the skill from using any tools, reducing its output
Why B is correct
The context: fork frontmatter option runs the skill in an isolated sub-agent context. The verbose analysis output stays in that isolated context and only the final result is returned to the main session. The exam guide explicitly states this is used for "skills that produce verbose output (e.g., codebase analysis) or exploratory context." D would break the skill's functionality; A and C are not valid skill frontmatter keys.
D3 · Prompt Engineering — Structured Output
You use tool_use with a JSON schema to extract financial data from invoices. The schema validation passes every time, but line items occasionally don't sum to the stated total field. What additional schema design would catch this?
ASwitch from tool_use to direct JSON output with stricter parsing
B ✓Add a calculated_total field alongside stated_total and flag discrepancies in a validation_error field
CAdd more detailed instructions in the system prompt about summing line items correctly
DUse extended thinking mode to give Claude more reasoning time for arithmetic
Why B is correct
The official exam guide covers "self-validating schema fields" as the pattern for this exact problem: "extract both calculated_total and stated_total, flag discrepancies." tool_use guarantees schema compliance but does NOT prevent semantic errors. The self-validation pattern makes the model surface its own inconsistencies rather than silently pass them. C and D are probabilistic and unreliable for arithmetic.
D3 · Prompt Engineering — Batch vs Real-Time API
Your team wants to use the Message Batches API for all Claude workloads to reduce costs by 50%. Which use case is NOT appropriate for the Batch API?
ANightly generation of test cases for the entire codebase
BWeekly audit of compliance documents across 10,000 records
C ✓Pre-merge security review that blocks a pull request from being merged until complete
DOvernight summarization of customer support transcripts
Why C is correct
The Batch API has a processing window of up to 24 hours with no guaranteed SLA. A blocking pre-merge check cannot wait up to 24 hours — it must use the real-time API. The exam guide's framework: "Synchronous (real-time) API → blocking pre-merge checks, live customer interactions. Batches API → overnight reports, weekly audits, nightly test generation." A, B, and D are all non-blocking background workloads that tolerate latency.
D3 · Prompt Engineering — Code Review Anti-Pattern
A code review agent is consistently missing subtle bugs. A developer suggests running the review in the same Claude session that generated the code, giving it full context of its own decisions. What does the exam guide say about this approach?
AThis is the recommended approach — shared context improves review accuracy
BThe full context will exceed the context window, causing the model to miss content
C ✓A model reviewing code it generated retains its own reasoning context, making it less likely to question its decisions — an independent review session without prior context is more effective
DUse extended thinking in the same session to force deeper self-analysis
Why C is correct
The official exam guide explicitly states: "The same Claude session that generated the code is less effective at reviewing its own changes — use an independent session." This is the "independent review instances" pattern. A model that generated the code carries the same reasoning context and is less likely to challenge its own decisions. Independent review instances (without the generator's prior context) catch more subtle issues.
D4 · Tool Design & MCP — Tool Description Quality
Your agent has two tools: analyze_content (description: "Analyzes content") and analyze_document (description: "Analyzes document content"). Claude frequently calls the wrong tool. What is the best fix?
AAdd a system prompt instruction: "Always prefer analyze_document over analyze_content for documents"
BMerge the two tools into one generic tool that handles both cases
C ✓Rename and rewrite descriptions to eliminate overlap — e.g., rename analyze_content to extract_web_results specifying it handles web scrape output, and update analyze_document to specify it handles uploaded PDF/DOCX files with input format details
DUse tool_choice: "any" to force Claude to always pick a tool rather than returning text
Why C is correct
The official exam guide states: "Tool descriptions are the primary mechanism LLMs use for tool selection. Minimal, overlapping descriptions cause misrouting." The fix is to make descriptions unambiguous — rename to eliminate name overlap and write descriptions that include input formats, example queries, edge cases, and explicit boundaries vs. similar tools. A is a system prompt workaround; B reduces capability; D addresses a different problem.
D4 · Tool Design & MCP — Error Response Structure
An MCP tool that queries a customer database returns "Operation failed" when the customer ID doesn't exist. The coordinator agent retries the call repeatedly. What is wrong, and what is the correct fix?
AThe tool should return an empty array [] instead of an error string for missing records
BThe coordinator's retry logic is the bug — it should not retry on any error
C ✓The generic error string prevents the agent from distinguishing a retriable service failure from a non-retriable "customer not found" result. Return structured metadata: isError: true, errorCategory: "validation", isRetryable: false, with a human-readable description
DSet a maximum retry count of 3 in the coordinator to prevent infinite loops
Why C is correct
The exam guide distinguishes between a retriable service failure (timeout, unavailability) and a non-retriable validation error (customer not found). Generic errors like "Operation failed" look identical to transient failures, so a well-designed coordinator retries them. The fix is structured error metadata with isRetryable: false for non-retriable cases. Note: A is wrong because returning empty results can't be distinguished from a successful query with no matches.
D4 · Tool Design & MCP — Tool Count & tool_choice
A synthesis subagent has access to 18 tools: web search, database queries, file operations, email sending, calendar access, and more. The agent frequently calls the wrong tool. What is the most effective architectural fix?
AImprove all 18 tool descriptions to be more precise and specific
B ✓Restrict the synthesis subagent to only the 4–5 tools needed for its role; route complex cross-domain needs through the coordinator
CUse tool_choice: "auto" to give Claude maximum flexibility in tool selection
DAdd a system prompt listing the tools in priority order
Why B is correct
The exam guide states: "Giving an agent access to too many tools (e.g., 18 instead of 4–5) degrades tool selection reliability by increasing decision complexity. Agents with tools outside their specialization tend to misuse them." The synthesis agent should only have synthesis tools. A is a partial improvement but doesn't address the fundamental decision-complexity problem.
D5 · Context Management — Prompt Caching
Your application sends the same 50,000-token system prompt (containing policy documents and examples) with every API request. Response latency is high. What is the most effective strategy to reduce both latency and cost without changing prompt content?
AMove the policy documents to a RAG system and retrieve only relevant sections per request
B ✓Add cache_control breakpoints to the stable prefix (policy documents + examples), enabling the KV cache to be reused across requests
CCompress the system prompt by summarizing the policy documents to reduce token count
DSplit the 50,000-token prompt across multiple shorter API calls and aggregate the results
Why B is correct
Prompt caching with cache_control breakpoints allows stable prompt prefixes to be cached and reused, dramatically reducing both latency and cost. This is the CALM framework's primary tool for large static prompts. A changes the architecture unnecessarily. C risks losing information. D introduces coordination complexity and potential inconsistencies.
D5 · Context Management — "Lost in the Middle" Effect
A research agent aggregates findings from 8 subagents into a single large context before synthesis. The synthesis output consistently misses findings from subagents 3, 4, and 5 (the middle of the aggregated input). What is the correct architectural fix?
AIncrease the context window by upgrading to a model with a larger token limit
BReduce the number of subagents from 8 to 4 so the aggregated input is shorter
C ✓Place key summaries at the beginning of each subagent's findings, use explicit section headers, and trim verbose tool outputs before aggregation so important content isn't buried in the middle
DUse extended thinking mode for synthesis so Claude has more tokens to reason through all the findings
Why C is correct
The "lost in the middle" effect is a documented design constraint: models reliably process content at the beginning and end of long contexts, but findings buried in the middle get missed — regardless of context window size. A is wrong because window size ≠ attention quality. The fix is structural: key summaries at the top of each section, explicit headers, and trimmed verbose output. D (extended thinking) doesn't change where in the context findings appear.
📅Study Timeline
TimelinePlan
1 week sprintDays 1–2: Official exam guide PDF. Days 3–5: 40–50 practice questions/day in domain order (heaviest first). Day 6: Full 60-question timed simulation. Day 7: Targeted review of 2 weakest domains only.
2 weeksWeek 1: Cover each domain in weight order with 20–30 questions each. Week 2: Two full timed simulations 3 days apart; final 24h = personal notes only, no new questions.
Tip from people who passed: The domain score breakdown from a timed simulation is your most valuable data. It tells you where you actually need work — not where you think you do. Treat every practice question like a real production decision. The distractors are very plausible.
  • Download the official CCA-F Exam Guide PDF from the Anthropic Academy platform — community calls it the best single study document
  • Take the official practice exam before scheduling the real thing — aim for 900+/1000
  • Free mock exams online: certsafari.com/anthropic/claude-certified-architect (611 questions, no signup) · claudecertifiedarchitects.com (300 scenario questions + timed sim) · certstud.com/certifications/anthropic/claude-architect (300+ free)
  • Paid mock exams: Tutorials Dojo on Udemy (240 questions, 4 sets — most rigorous) · Udemy "CCAF Exams 2026" by Balaji Ashok Kumar (360 questions across 6 scenarios)
  • Build at least one real project touching 3+ domains: RAG pipeline, tool-using agent, or multi-MCP workflow
  • Master MCP tool descriptions and error response structure — many points are lost here
  • Practice writing CLAUDE.md hierarchies and path-specific rules in .claude/rules/
CCA-F Study Guide · 6 Courses + Exam Prep · May 2026claude-code · api · mcp · skills · subagents · mcp-advanced