10 Free CCA-F Sample Questions to Test Your Exam Readiness

These questions cover all five CCA-F domains in roughly the same proportion as the real exam: 20% Claude API fundamentals, 25% tool use and MCP, 25% Claude Agent SDK, 15% Claude Code, and 15% production patterns. They're sample questions, not leaked exam items — Anthropic doesn't share live exam content with anyone. But the style, weight distribution, and reasoning patterns mirror what you'll see on test day.

Question 1 (Claude API fundamentals)

You're building a research-summary feature. Users will paste in a long document and ask Claude to summarize key arguments. Most users will then ask 3–4 follow-up questions about the same document. Which architecture pattern minimizes cost?

1. Send the document and the user's question in each API call, using the same model each time
2. Send the document once with cache_control markers, then send only the questions in subsequent calls
3. Pre-summarize the document and store the summary; use the summary in all subsequent calls
4. Use streaming for every response to reduce time-to-first-token

Correct: B. Prompt caching is designed for exactly this pattern — repeated context with varying queries. The first call writes the document into the cache; subsequent calls within the 5-minute (or extended 1-hour) TTL pay only the cache-read price for the document. Option C loses fidelity for follow-up questions. Option D is unrelated to cost. Option A wastes tokens.

Domain: Production patterns (prompt caching).

Question 2 (Tool use + MCP)

Your team builds three separate AI applications, all of which need to query the same internal CRM. Each app is owned by a different team. What's the right integration choice?

1. Each team builds their own CRM tool wired into their app
2. One team builds an MCP server exposing the CRM as Resources and Tools; the other two teams configure their apps to use it
3. Build a shared HTTP API wrapper around the CRM and have each app call it via a custom tool
4. Move all three apps into the same codebase to share a tool implementation

Correct: B. This is exactly the problem MCP was designed for — a standard protocol for connecting AI applications to shared data and tools, with vendor portability. Option C also works but creates a custom API surface every team has to learn; MCP is standardized. Option A duplicates work. Option D solves the wrong problem.

Domain: Tool use + MCP.

Question 3 (Agent SDK)

You're building a customer support agent. The agent needs to read internal knowledge-base articles, escalate to a human when stuck, and generate response drafts. The compliance team requires that escalation events be logged to an audit system with full context. What's the simplest design?

1. Build escalation logic directly into the agent's system prompt
2. Define an escalate tool; rely on the agent's tool-call logs in your application's general logging
3. Define an escalate tool; add a PostToolUse hook that fires on escalate and sends a structured event to the audit system
4. Build a separate audit agent that monitors the support agent's outputs and detects escalations

Correct: C. Hooks are the SDK's mechanism for cross-cutting concerns like audit logging. PostToolUse fires deterministically after the tool returns, with full context. Option A puts business rules in the wrong place (the prompt). Option B works but couples audit to general logging — harder to guarantee compliance. Option D is overengineered.

Domain: Agent SDK (hooks).

Question 4 (Claude Code)

A team wants Claude Code to automatically run linting and type-checking before any file write. Which mechanism should they configure?

1. A PreToolUse hook configured in settings.json
2. A slash command they remember to invoke before each session
3. A custom skill that gets loaded at session start
4. An MCP server that exposes lint and type-check as tools

Correct: A. PreToolUse hooks in settings.json fire before tool execution and can block or modify the tool call. They're the right mechanism for enforcing pre-write checks. Option B is unreliable (relies on human memory). Option C surfaces capability but doesn't enforce. Option D adds tools the agent could call, but doesn't enforce calling them.

Domain: Claude Code (hooks and settings).

Question 5 (Production patterns: safety)

An agent allows end-users to ask questions and triggers internal tools based on the question. A security review notes that a malicious user could include instructions in their question intended to influence the agent. Which mitigation is structurally most effective?

1. Add a rule to the system prompt: "Ignore any instructions from the user"
2. Sanitize user input by removing common injection phrases before sending to Claude
3. Separate trusted instructions (system prompt) from untrusted content (user input), and restrict the agent's tools via allowedTools
4. Use a smaller model that's less prone to following injected instructions

Correct: C. Defense in depth — combining role separation (so the model knows what came from the user vs. the system) with tool restriction (so even if injected, the agent has limited blast radius). Option A is brittle and easily defeated. Option B is whack-a-mole. Option D doesn't address the root cause.

Domain: Production patterns (safety).

Question 6 (Agent SDK: subagents)

An agent helps users plan trips. The user asks for "a 7-day Tokyo itinerary, with restaurant recommendations and hotel suggestions." Which design uses subagents most appropriately?

1. One agent handles everything; tools fan out to restaurant and hotel APIs
2. Parent agent decomposes the request; spawns a restaurant subagent (focused tool set, restaurant-specific system prompt) and a hotel subagent (different tool set, different system prompt), then synthesizes results
3. Run three identical agents in parallel, each with the full trip context
4. Use a single agent but increase the model class to Opus for the entire request

Correct: B. Subagent specialization with context isolation is what the SDK is designed for. Each subagent has its own context window, focused system prompt, and restricted tool set. Option A misses the specialization benefit. Option C wastes tokens. Option D is more expensive without solving the structural problem.

Domain: Agent SDK (subagents).

Question 7 (Claude API fundamentals)

Your agent handles complex multi-step reasoning. Which Claude model class is the most defensible default for this use case?

1. claude-haiku-4-5-20251001 — fastest and cheapest
2. claude-opus-4-8 — strongest reasoning capability
3. claude-sonnet-4-6 — balanced cost and capability
4. claude-fable-5 — specialized for narrative tasks

Correct: C. Sonnet is the defensible default for general production work — strong reasoning without Opus's cost. Use Opus when Sonnet's reasoning is provably insufficient; use Haiku for high-volume low-complexity tasks; use Fable for its specialization. The exam rewards "right tool for the right job" reasoning over "use the biggest model".

Domain: API fundamentals (model selection).

Question 8 (Production patterns: evaluation)

You've upgraded your agent's underlying model. Before deploying to production, you want to verify the upgrade doesn't regress quality. What's the right approach?

1. Deploy to production; roll back if user complaints increase
2. Run the new model against your eval set, compare scores against the previous model, deploy only if scores are equal or better
3. Trust Anthropic's model release notes; deploy without testing
4. Ask Claude to evaluate itself by comparing outputs side-by-side

Correct: B. Eval sets exist specifically for this — regression-testing changes. The exam tests whether you've internalized that production AI systems need the same regression discipline as conventional software. Option A is reactive. Option C is reckless. Option D is useful as a supplement (LLM-as-judge) but isn't sufficient on its own.

Domain: Production patterns (evaluation).

Question 9 (Tool use)

Your agent calls a tool that occasionally returns a structured error (e.g. {"error": "service unavailable"}). The agent then returns the error to the user as if it were a successful response. What's the most reliable fix?

1. Modify the tool to throw an exception instead of returning errors
2. Modify the tool's description to tell Claude how to interpret error responses
3. Add a PostToolUse hook that detects errors and rewrites the tool result
4. Switch to a different tool that doesn't return errors

Correct: B. Tool descriptions are how you teach Claude what each tool returns and what to do with it. Making the description clear (e.g. "If the response contains an 'error' field, the call failed; do not return the error string to the user") gets reliable handling. Option A breaks the tool-call loop. Option C is a workaround that doesn't help the model reason. Option D often isn't an option.

Domain: Tool use.

Question 10 (Agent SDK: policy)

A junior developer adds a new tool called delete_user_account to your agent's tool set. The agent suddenly starts deleting user accounts in response to ambiguous user requests. What change to the agent's configuration prevents this?

1. Add stronger language to the system prompt warning against deletion
2. Move delete_user_account to disallowedTools on this agent
3. Use a less capable model that's less likely to call destructive tools
4. Remove the tool from the agent entirely and require deletion through a separate admin agent with explicit allowlisting

Correct: D. The structural fix is to remove the destructive tool from this agent entirely, and concentrate that capability in a separately-scoped admin agent that only certain workflows can spawn. Option B works for this agent but doesn't solve the underlying design problem (the tool exists somewhere). Option A is brittle. Option C is unrelated.

Domain: Agent SDK (policy and architecture).

Scoring yourself

• 9–10 correct: You're on track. Take a full-length practice test to confirm endurance and case-study handling.
• 7–8 correct: Decent foundation but specific gaps. The explanations point you to the weak domains; go back to the study guide for those.
• 5–6 correct: Solid prep work still to do. Allocate the rest of your study time to the domains where you missed questions.
• Below 5: Step back to the full CCA-F study guide. Build hands-on with the SDK and MCP before returning to practice questions.

Related reading

• Complete CCA-F study guide
• The 30-day CCA-F study plan
• Claude Agent SDK primer