Claude Certified Architect Practice Exam: 60 Questions with Detailed Explanations

A full-length CCA practice exam covering all 5 domains and 6 scenarios, with explanations that teach you why every wrong answer is wrong.

Unlock your potential with the ultimate CCA practice exam! Dive into 60 comprehensive questions that cover all domains and scenarios, complete with detailed explanations to help you master the Claude Certified Architect Foundations exam. Get ready to transform your study sessions!

Summary: A comprehensive CCA practice exam with 60 questions covering all five domains and six scenarios, designed to mirror the real Claude Certified Architect Foundations exam format. Each question includes detailed explanations to clarify why incorrect answers are wrong, helping candidates understand key concepts. The exam emphasizes a structured approach to preparation, including timed practice, scoring, and identifying weak areas for further study.

CCA Exam Prep Series

This is article 8 of 8 in the CCA Exam Prep series. The series covers every scenario, domain, and anti-pattern you need to pass the Claude Certified Architect Foundations exam on your first attempt.

How to Use This Practice Exam

This practice exam mirrors the real Claude Certified Architect (CCA) Foundations exam.

This practice exam mirrors the real Claude Certified Architect (CCA) Foundations exam: 60 multiple-choice questions distributed across all five competency domains. The question weights match the official exam blueprint:

Recommended approach:

1. Timed pass first (120 minutes) — answer without looking at explanations.
2. Score yourself.
3. Review every explanation.
4. Identify weak domains.

Aim for 50+ correct (83%+) before taking the real exam.

Scoring guidance: The real exam uses a 100–1,000 scale with 720 required to pass. On this 60-question practice exam, roughly 43 correct answers (72%) maps to a passing score. Aim for 50+ correct (83%+) before scheduling your real exam.

A note on scenarios: The real exam randomly selects 4 of 6 production scenarios. This practice exam covers all 6 so you can prepare for any combination. Scenario context is noted where relevant.

Difficulty mix: 18 Easy, 27 Medium, 15 Hard. The real exam follows a similar distribution.

A note on answer distribution: If you notice that B appears very frequently in this exam, that is intentional. The real CCA exam does not follow a predictable answer distribution. Do not fall into the trap of second-guessing correct answers because “B seems too common.” On the real exam, eliminate wrong answers by reasoning, not by position.

Recommended Resources to Study for This Claude Certified Architect Foundation Exam

Recommended Resources to Study for This Exam

To get the most out of this practice exam, study the full CCA Exam Prep series in order:

1. **Claude Certified Architect: The Complete Guide to Passing the CCA Foundations Exam** The series opener and exam roadmap. It covers the CCA Foundations format, domain weights, scenario types, and a practical study plan for passing on the first try.
2. **Claude Certified Architect — Exam Prep: Mastering the Customer Support Resolution Agent Scenario** A deep dive into the customer support scenario, focused on escalation rules, compliance workflows, and why deterministic business logic beats model self-confidence in production support systems.
3. **CCA Exam Prep: Mastering the Code Generation with Claude Code Scenario** Focuses on code-generation questions from the exam, especially context degradation, CLAUDE.md hierarchy, large-codebase refactoring, and CI/CD-safe Claude Code usage.
4. **CCA Exam Prep: Structured Data Extraction** Covers high-reliability extraction pipelines, including JSON schema enforcement, semantic validation, retry loops, and the exam’s preference for programmatic guarantees over prompt-only approaches.
5. **CCA Exam Prep: Mastering the Multi-Agent Research System Scenario** Explains the multi-agent research scenario through hub-and-spoke orchestration, context isolation, tool scoping, explicit context passing, and failure handling patterns that the CCA exam heavily tests.
6. **Claude Certified Architect: Master the CI/CD scenario for the CCA Foundations Exam** This article focuses on the CI/CD scenario in the CCA series, covering the flags and pipeline patterns that matter in production. It explains why -p, — bare, and structured JSON output are central to passing exam questions about non-interactive automation, validation loops, and reliable pipeline behavior.
7. **CCA: Master the Developer Productivity scenario for the Claude Certified Architect exam** This piece covers the Developer Productivity scenario, with emphasis on CLAUDE.md hierarchy, MCP configuration, tool scoping, and team workflow design. It frames developer productivity as a multi-domain CCA topic and highlights the exam’s preference for programmatic enforcement, clear configuration boundaries, and disciplined agent design.

These seven articles + this full-length practice exam form a complete preparation package. Start with the Complete Guide, work through the scenario deep-dives, and finish with this practice exam to test your readiness.

Domain 1: Agentic Architecture & Orchestration (Q1-Q16)

Cross-reference: Questions in this domain map primarily to the Customer Support Resolution Agent and Multi-Agent Research System articles in the CCA series.

❓ Q1. Identifying the Coordinator-Subagent Pattern

Scenario: Customer Support Resolution Agent

A team is building a customer support system using Claude Agent SDK. The design calls for one primary agent that receives all customer requests, determines the category (billing, returns, account issues), and then delegates specialized handling to purpose-built agents that each have their own tool sets and system prompts. The primary agent then combines the results before responding to the customer.

Which architectural pattern does this design describe? A) Pipeline orchestration with sequential handoffs B) Peer-to-peer multi-agent collaboration C) Coordinator-subagent pattern with task delegation D) Single-agent with dynamic tool loading

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

This is the textbook coordinator-subagent pattern. A single coordinator receives requests, decomposes them into tasks, delegates to specialized subagents, and synthesizes results. The coordinator manages workflow while subagents handle domain-specific execution. Key features: one central agent, branching delegation based on category, and result synthesis before responding.

Why the other answers are wrong :

🚫 A: Pipeline orchestration is a fixed sequential flow. This design branches based on request category — not linear. 🚫 B: Peer-to-peer means agents communicate directly without a central hub. This has a clear hub-and-spoke structure. 🚫 D: Single-agent with dynamic tool loading keeps everything in one context. This uses separate agents with their own prompts and tools.

💡 CCA Exam Tip

The coordinator-subagent pattern is the most heavily tested multi-agent pattern. Know it cold: one coordinator, multiple specialized subagents, synthesis step before final response.

❓ Q2. The Agentic Loop and Stop Reasons

An architect is debugging a Claude Agent SDK application. The agent receives a user query, generates a response that includes a tool call, and then the application needs to decide what to do next. The API response has a stop_reason field.

What does a stop_reason of “tool_use” indicate? A) The agent wants to invoke a tool and is waiting for the tool result before continuing B) The agent has finished processing and the tool was used successfully C) The tool execution failed and the agent is requesting a retry D) The agent has exceeded its maximum tool call limit

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

“tool_use” signals intent, not completion. The model has paused because it wants to call a tool. Your application must execute the tool, return the result, and let the agentic loop continue (generate → tool_use → execute → return result → generate again → end_turn).

Why the other answers are wrong :

🚫 B: The tool has not been used yet — it is a request for your application to call it. 🚫 C: “tool_use” is a normal invocation request. Tool errors surface after your application attempts execution. 🚫 D: There is no standard stop_reason for exceeding tool limits (enforced at application layer).

💡 CCA Exam Tip

Memorize the agentic loop: generate → tool_use stop → execute tool → return result → generate again → end_turn. stop_reason signals the model’s intent for the next step.

❓ Q3. Subagent Context Isolation

Scenario: Multi-Agent Research System

A multi-agent research system has a coordinator agent conducting a detailed conversation about quantum computing. The coordinator delegates a subtask (finding recent papers on quantum error correction) to a research subagent using the Claude Agent SDK’s Agent tool.

What context does the research subagent have access to? A) The full conversation history between the coordinator and the user B) A summarized version of the conversation history, automatically generated by the SDK C) The conversation history plus the coordinator’s system prompt D) Only the prompt string passed through the Agent tool, plus its own system prompt and tool definitions

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

Subagents run in their own fresh conversation. They receive only: their own system prompt (from AgentDefinition), the prompt string passed via the Agent tool, project-level CLAUDE.md (if configured), and their own tool definitions. Parent conversation history and system prompt are not automatically passed. This context isolation is deliberate.

Why the other answers are wrong :

🚫 A: Subagents do not inherit parent history. Each starts with a blank slate (heavily tested concept). 🚫 B: Coordinator’s system prompt does not pass through. 🚫 C: No automatic summarization.

💡 CCA Exam Tip

Exam Trap: Many assume subagents inherit context. They do not. The only channel is the prompt string passed to the Agent tool. Explicitly include any needed context (file paths, decisions, error messages).

❓ Q4. Task Decomposition Strategy

A team needs to build an agent that processes customer refund requests:

(1) validate order exists,

(2) check refund policy,

(3) calculate refund amount,

(4) initiate refund in payment system.

Which decomposition approach is most appropriate? A) Create four separate subagents, one for each step, coordinated by a parent agent B) Use a single agent with four tools, one for each step, since the tasks are sequential and share context C) Create two subagents (validation + policy check, calculation + payment) D) Use the Batch API to process all four steps simultaneously

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

These steps are sequential, context-dependent, and total exactly four tools (within the 4–5 tool recommendation). A single agent is the right fit. Subagents add unnecessary handoff overhead for linear workflows.

Why the other answers are wrong :

🚫 A: Subagents suit independent/parallel tasks. Sequential flows pay coordination cost with no gain. 🚫 C: Still adds handoff complexity for non-parallel tasks. 🚫 D: Batch API is for non-real-time, high-volume work (up to 24h latency) — unsuitable for user-facing refunds.

💡 CCA Exam Tip

Not every workflow needs subagents. Save them for independent, parallelizable work. Sequential + shared context → single agent with focused tools.

❓ Q5. Silent Subagent Failures

Scenario: Customer Support Resolution Agent

A customer support coordinator delegates a billing dispute to a billing subagent. The subagent encounters an authentication error but returns only: “I was unable to complete the analysis.” The coordinator then tells the customer: “Your billing dispute has been reviewed and no action is needed.”

What is the root cause of this failure? A) The subagent failed silently, and the coordinator lacked the context to detect the failure and respond appropriately B) The coordinator agent’s system prompt does not include instructions for handling billing disputes C) The billing system API needs a longer timeout configuration D) The coordinator should be using the Batch API for billing operations

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

This is the silent subagent failure anti-pattern. The coordinator receives a vague message and cannot distinguish “no dispute found” from “failed to search at all.” Fix: subagents must return structured status (success/failure/partial) with specific error details.

Why the other answers are wrong :

🚫 B: Even perfect prompts cannot compensate for missing error signals. 🚫 C/D: Secondary or irrelevant — the core issue is communication design.

💡 CCA Exam Tip

Exam Trap: The exam often presents silent failures as a “prompt problem.” It is a design failure in subagent error reporting. No coordinator-side prompt engineering fully compensates.

❓ Q6. tool_choice Configuration

*An architect is building an agent with five tools. For most interactions the agent decides tool use freely, but for one workflow it must always call validate_input first.*

How should tool_choice be configured? A) Use tool_choice: “none” for general and tool_choice: “any” for validation B) Use tool_choice: “any” for general and tool_choice: “auto” for validation C) Use tool_choice: “required” for both and rely on system prompt D) Use tool_choice: “auto” for general interactions and tool_choice: {“type”: “tool”, “name”: “validate_input”} for the forced validation workflow

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

“auto” lets the model decide. The named-tool form {“type”: “tool”, “name”: “X”} guarantees a specific tool is called. Programmatic enforcement beats prompt-based guidance for critical rules.

Why the other answers are wrong :

🚫 B: “any” forces some tool but not a specific one. 🚫 C: “required” (same as “any”) does not specify which tool. 🚫 A: “none” disables tools entirely.

💡 CCA Exam Tip

tool_choice values:

• “auto” = model decides
• “any”/”required” = must use a tool (model picks)
• {“type”:”tool”,”name”:”X”} = must use tool X
• “none” = no tools allowed

Named-tool form is the only deterministic option for specific tools.

❓ Q7. Context Forking for Parallel Exploration

Scenario: Multi-Agent Research System

A research coordinator has a 15-turn conversation on market trends. The user asks: “What if we assumed the opposite market conditions?” The team wants to explore this alternative without losing the existing thread.

Which approach correctly implements this using the Claude Agent SDK? A) Create a new session with an empty history and summarize the original conversation B) Copy the full message history array into a new API call manually C) Use fork_session=True in ClaudeAgentOptions to create a branched copy of the current session D) Use context: fork as a parameter in the Agent tool

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

fork_session=True (Python) / forkSession: true (TypeScript) in ClaudeAgentOptions creates a new session with a complete copy of the original history that diverges independently. The original session remains unchanged.

Why the other answers are wrong :

🚫 A: Summarization is lossy. 🚫 B: Manual copying is fragile and bypasses SDK guarantees. 🚫 D: context: fork is not valid.

💡 CCA Exam Tip

Use fork_session=True with the resume parameter for parallel exploration while preserving exact history.

❓ Q8. Designing a Multi-Agent Research System

Scenario: Multi-Agent Research System

A system must research a topic across three independent dimensions (academic papers, industry reports, news coverage), each requiring different tools. Results need synthesis into a unified report.

Which architecture is most appropriate? A) A coordinator agent with three specialized subagents (one per dimension), each with 3 tools, that run independently before synthesis B) A single agent with all nine tools that processes each dimension sequentially C) Three independent agents writing to a shared database, with a final agent reading to produce the report D) A sequential pipeline where each agent passes findings to the next

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

Ideal coordinator-subagent pattern. Each dimension is independent/parallelizable with specialized tools. Three subagents (3 tools each) stay within limits. Coordinator handles decomposition and synthesis. Enables concurrent execution.

Why the other answers are wrong :

🚫 B: Nine tools overloads the agent and degrades selection reliability (classic tool-overload example). 🚫 C: Shared database adds unnecessary infrastructure complexity. 🚫 D: Pipeline forces artificial sequential dependencies on independent tasks.

💡 CCA Exam Tip

Exam Trap: Pipelines look “structured” but hurt performance on independent tasks. Use coordinator + parallel subagents for speed and flexibility.

❓ Q9. Escalation Design

A customer support agent has attempted resolution three times on a rare edge case it cannot handle. The agent self-reports “85% confident” the issue is resolved.

What should the system do next? A) Trust the 85% confidence and close the ticket B) Retry a fourth time with additional prompt instructions C) Escalate to a human agent, providing full interaction history and attempted tools D) Switch to a model with a larger context window

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

After 2–3 failed attempts, escalate to a human with full context. LLM confidence scores are poorly calibrated, especially when the agent lacks the necessary tools. Use bounded retry with escalation.

Why the other answers are wrong :

🚫 A: Self-reported confidence trap — unreliable when tools are missing. 🚫 B: Fourth retry with same tools solves nothing. 🚫 D: Larger context does not create missing tool capabilities.

💡 CCA Exam Tip

Bounded retry (2–3 attempts) then escalate. Never use self-reported confidence as the sole criterion.

❓ Q10. When to Split Agents vs. Add Tools

Scenario: Multi-Agent Research System

A research agent currently has 4 tools. The team wants to add capabilities for patent searching, regulatory lookup, financial data, and social media monitoring.

What is the best approach? A) Add all four new tools (total 8) B) Add the four tools and improve descriptions C) Create two new specialized subagents (patent/regulatory and financial/social) with 2 tools each; keep original agent as coordinator with its 4 tools D) Replace with one agent having all 8 tools + few-shot examples

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

Eight tools exceed the 4–5 tool recommendation. Distribute across specialized subagents. Coordinator retains core tools and delegates new domains.

Why the other answers are wrong :

🚫 A/B: Tool overload degrades selection reliability regardless of descriptions. 🚫 D: Combines tool overload with the few-shot-for-ordering anti-pattern.

💡 CCA Exam Tip

Exam Trap: Few-shot examples demonstrate output format/quality, not tool execution order.

❓ Q12. Hook-Based vs. Prompt-Based Enforcement

An architect must enforce that an agent never processes PII before it has been anonymized by a preprocessing tool.

Which enforcement approach is most reliable? A) System prompt + few-shot examples showing correct order B) Create a single combined anonymize_and_process tool C) Use tool_choice to force anonymize_data first, then switch to auto D) Register a PreToolUse hook on process_request that verifies anonymization and blocks if not completed

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

A PreToolUse hook creates a programmatic prerequisite. It inspects state and blocks execution if the condition is not met. Deterministic and bypass-proof.

Why the other answers are wrong :

🚫 A: Two probabilistic mechanisms do not equal one deterministic one. 🚫 B: Does not persist across conversation turns. 🚫 C: Becomes rigid for varying workflows.

💡 CCA Exam Tip

Exam Trap: Prompt + few-shot sounds robust. It is still probabilistic. Security-critical rules require programmatic enforcement (hooks).

❓ Q13. Designing Bounded Retry with Escalation

Scenario: Customer Support Resolution Agent

A returns agent retries indefinitely during API outages (47 retries in one case). Leadership wants a better design.

Which design correctly implements bounded retry with escalation? A) Maximum of 10 retries with exponential backoff, then generic error to customer B) Maximum of 2–3 retries with specific error feedback on each retry, then escalate to human with full context C) Maximum of 5 retries, increasing context window each time D) Remove retries entirely and escalate on first failure

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Bounded retry (recommended 2–3 attempts) with specific error feedback on each retry, followed by escalation to human with complete interaction history and attempted actions.

Why the other answers are wrong :

🚫 A: Too many retries; generic error dead-ends the customer. 🚫 C: Context window does not fix API availability. 🚫 D: Over-escalates transient failures.

💡 CCA Exam Tip

Magic number across domains: 2–3 retries with specific feedback. Goldilocks range — not too few, not too many.

❓ Q14. Multi-Agent Session State

Scenario: Multi-Agent Research System

A coordinator delegates to three subagents in parallel. Subagent B fails silently and returns “I could not complete the research.”

Where does the coordinator’s conversation state live, and what is the impact of Subagent B’s silent failure? A) State lives in a shared database; coordinator can query error logs B) State lives in each subagent’s conversation; coordinator reads all sessions C) State lives in the coordinator’s conversation; coordinator cannot distinguish failure from “no results found” without structured error reporting D) State is managed by the SDK’s built-in state store

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

Each agent has its own isolated conversation. The coordinator only sees the final messages returned by subagents. Without structured error reporting, vague responses look identical to legitimate “no results” outcomes.

Why the other answers are wrong :

🚫 A: No shared database or cross-session access in default SDK architecture. 🚫 B: The coordinator cannot read subagent sessions. 🚫 D: The Claude Agent SDK does not have a built-in cross-agent state store.

💡 CCA Exam Tip

Coordinator sees only final subagent output. Design subagents to return structured status (success/failure/partial + details).

❓ Q15. The Agentic Loop and tool_choice: any

A system uses tool_choice: “any” in its API calls. A user sends: “Hello, how are you today?”

What will happen? A) The model is forced to call one of its available tools B) The model responds with a friendly greeting C) The model throws an error D) The model responds “I cannot help with that”

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

“any” forces the model to call some tool on every turn, even for pure conversational messages. No exception for natural responses.

Why the other answers are wrong :

🚫 B: Plain text response is impossible under “any”. 🚫 C: Model will pick the “least bad” tool rather than error or refuse. 🚫 D: The model will not refuse.

💡 CCA Exam Tip

Use “any” only when every request genuinely requires a tool call. Prefer “auto” for mixed conversational/tool workflows.

❓ Q16. AI Fluency: The Four D’s

An organization is training its team on effective AI collaboration. The framework covers: knowing when/what to delegate, writing clear task descriptions, exercising discernment on outputs, and practicing diligence in verification.

What is this framework called? A) The DACI framework B) The RACI matrix adapted for AI C) The Four Pillars of Prompt Engineering D) The AI Fluency framework: Delegation, Description, Discernment, Diligence

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

The AI Fluency framework defines four key competencies: Delegation, Description, Discernment, and Diligence. It is foundational CCA knowledge for the human side of human-AI systems.

Why the other answers are wrong :

🚫 A: DACI is a general decision-making framework from project management, not an AI-specific competency framework. 🚫 B: The framework is broader than prompt engineering. 🚫 C: RACI is a responsibility assignment matrix from project management.

💡 CCA Exam Tip

Know the 4 D’s cold. The Description–Discernment loop is particularly emphasized.

❓ Q17. CLAUDE.md File Location

Scenario: Code Generation with Claude Code

A team is setting up Claude Code for a new project. They want to define coding standards, preferred libraries, and project-specific conventions that will apply to everyone who works on the repository.

Where should they place the CLAUDE.md file? A) In ~/.claude/CLAUDE.md so it applies to all team members B) In the project root as ./CLAUDE.md or ./.claude/CLAUDE.md so it is shared via source control C) In /etc/claude-code/CLAUDE.md for system-wide enforcement D) In each team member’s home directory as ~/CLAUDE.md

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Project-level CLAUDE.md belongs in the project root (./CLAUDE.md or ./.claude/CLAUDE.md). This location is tracked by version control and shared with the entire team.

Why the other answers are wrong :

🚫 A: ~/.claude/CLAUDE.md is the user-level location (personal, not shared). 🚫 C: The managed/org level is for organization-wide policies. 🚫 D: Not a recognized location.

💡 CCA Exam Tip

Project CLAUDE.md = repo root or .claude/ (shared, versioned). User CLAUDE.md = ~/.claude/ (personal, local).

❓ Q18. CLAUDE.md Hierarchy and Precedence

Scenario: Developer Productivity with Claude

A developer has the following CLAUDE.md files: organization managed, project, user, and local.

Which describes the CLAUDE.md hierarchy correctly? A) User-level always overrides project-level B) All four levels are loaded and combined; the managed/org level cannot be overridden C) Only the project-level file is loaded D) The most recently modified file takes priority

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

CLAUDE.md has four levels: managed/organization, project, user, and local. All levels are loaded and combined. The managed/org level provides non-overridable baseline policies. CLAUDE.local.md is gitignored for personal overrides.

Why the other answers are wrong :

🚫 A: No strict user-beats-project override. 🚫 C: All levels load. 🚫 D: Priority is structural, not temporal.

💡 CCA Exam Tip

Exam Trap: Many miss CLAUDE.local.md (gitignored local overrides).

❓ Q19. CI/CD: The -p Flag

Scenario: Claude Code for CI/CD

A team adds Claude Code to their GitHub Actions workflow. The pipeline hangs indefinitely at the Claude Code step.

What is the most likely cause? A) Claude Code is running in interactive mode and the -p flag was not used B) The ANTHROPIC_API_KEY environment variable is not set C) The CI runner does not have enough memory D) Claude Code requires a GUI terminal

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

Without the -p ( — print) flag, Claude Code starts in interactive mode and waits for terminal input. In CI there is no human, so the pipeline hangs.

Why the other answers are wrong :

🚫 B: Missing API key causes fast authentication error. 🚫 C: Insufficient memory causes a crash. 🚫 D: Claude Code works headless with the -p flag.

💡 CCA Exam Tip

Pipeline hanging in CI = missing -p flag. This is the single most common CI/CD trap.

❓ Q20. The — bare Flag for CI/CD

Scenario: Claude Code for CI/CD

A team needs consistent, reproducible behavior across all CI runners.

Which flag should they add? A) — deterministic B) — no-context C) — bare D) — reproducible

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

The — bare flag skips auto-discovery of hooks, skills, plugins, MCP servers, and CLAUDE.md files. Only flags passed explicitly on the command line take effect.

Why the other answers are wrong :

🚫 A: — deterministic is not a valid flag. 🚫 B: — no-context is not a valid flag. 🚫 D: — reproducible is not a valid flag.

💡 CCA Exam Tip

— bare is Anthropic’s primary recommendation for CI/CD pipelines.

❓ Q21. Custom Skills vs. CLAUDE.md

Scenario: Code Generation with Claude Code

A team has a complex code review checklist.

When should they use a custom skill (.claude/skills/code-review/SKILL.md) instead of adding instructions to CLAUDE.md? A) Skills and CLAUDE.md are interchangeable B) Use a skill when the instructions are task-specific and do not need to be in context for every session C) Use CLAUDE.md for long instructions and skills for short instructions D) Skills are only for slash commands

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Skills load on demand; CLAUDE.md loads every session. A complex code review checklist is task-specific and should not consume context on every interaction.

Why the other answers are wrong :

🚫 A: Skills and CLAUDE.md serve different purposes. 🚫 C: Length is not the distinguishing factor. 🚫 D: Skills load automatically when relevant.

💡 CCA Exam Tip

Skills = on-demand, task-specific.

CLAUDE.md = always-loaded, broadly applicable.

❓ Q22. MCP Configuration Scoping

Scenario: Developer Productivity with Claude

A team has a shared PostgreSQL MCP server and each developer has a personal GitHub MCP server.

Where should each MCP server be configured? A) Both in .mcp.json B) The PostgreSQL server in CLAUDE.md C) Both in ~/.claude.json D) The PostgreSQL server in .mcp.json (project level) and the GitHub server in ~/.claude.json (user level)

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

Project-level MCP servers go in .mcp.json (committed to source control). User-level/personal MCP servers with individual tokens go in ~/.claude.json (local, never committed).

Why the other answers are wrong :

🚫 A: Putting personal tokens in .mcp.json exposes credentials. 🚫 B: Shared server would not be version-controlled. 🚫 C: Wrong format for MCP config.

💡 CCA Exam Tip

.mcp.json = project/shared/committed.

~/.claude.json = user/personal/never committed.

❓ Q23. Machine-Parseable Output in Pipelines

Scenario: Code Generation with Claude Code

A CI pipeline needs to extract results programmatically using jq.

Which approach produces machine-parseable output? A) Use claude -p and parse plain text with regex B) Use claude -p with — output-format json C) Use a prompt instruction “return as JSON” D) Use — format structured

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

The — output-format json flag produces a structured JSON response with guaranteed fields. This can be reliably piped to jq.

Why the other answers are wrong :

🚫 A: Plain text has no guaranteed structure. 🚫 C: Prompt-based JSON is probabilistic. 🚫 D: — format structured is not a valid flag.

💡 CCA Exam Tip

— output-format json for machine-parseable output.

Never rely on “return JSON” in the prompt for pipelines.

❓ Q24. JSON Schema Enforcement in Claude Code

Scenario: Claude Code for CI/CD

A CI pipeline needs Claude Code to return a specific structure with passed (boolean), failures (array), and summary (string).

Which approach guarantees schema compliance? A) Include the schema in the prompt B) Use — output-format json then validate in post-processing C) Use — output-format json — json-schema “{…}” D) Use — output-format json and add few-shot examples

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

The — json-schema flag combined with — output-format json enforces the schema at generation time. Non-compliant output cannot be generated.

Why the other answers are wrong :

🚫 B: Post-validation is too late. 🚫 A: Prompt-based description is not enforcement. 🚫 D: Few-shot demonstrates but does not guarantee.

💡 CCA Exam Tip

Generation-time enforcement ( — json-schema) prevents failures.

Post-generation validation only detects them.

❓ Q25. CLAUDE.md for Team Coding Standards

Scenario: Code Generation with Claude Code

A tech lead wants to enforce TypeScript strict mode, functional React components, and Zod validation for the entire team, versioned with the project.

Which CLAUDE.md configuration is correct? A) Each developer adds these rules to ~/.claude/CLAUDE.md B) The tech lead adds these rules to the organization-managed location C) The tech lead adds these rules to ./CLAUDE.md in the project repository D) The tech lead emails the rules to each developer

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

Project-specific coding standards belong in the project-level ./CLAUDE.md. This file is committed to the repository and automatically shared with every team member.

Why the other answers are wrong :

🚫 A: User-level is personal and not shared. 🚫 B: Organization level is for org-wide policies. 🚫 D: Manual distribution is not version-controlled.

💡 CCA Exam Tip

Team coding standards = project-level CLAUDE.md (./CLAUDE.md).

Personal preferences = user-level (~/.claude/CLAUDE.md).

❓ Q26. CI Pipeline Design with Claude Code

Scenario: Claude Code for CI/CD

An architect is designing a GitHub Actions workflow where Claude Code performs three tasks on every pull request: security review, test generation, and code style remediation.

Which pipeline design is correct? A) A single Claude Code call with all three tasks in one prompt B) Three separate Claude Code calls, each with — bare -p and task-specific — json-schema C) A single Claude Code call in interactive mode D) Three parallel calls without the -p flag

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Three separate calls provide isolation, focused schemas, and scoped tool access per task. — bare ensures reproducible behavior.

Why the other answers are wrong :

🚫 A: One prompt for three different tasks makes clean structured output impossible. 🚫 C: Interactive mode hangs the pipeline. 🚫 D: Without -p the pipeline hangs.

💡 CCA Exam Tip

CI/CD best practice:

— bare -p “prompt” — allowedTools “…” — json-schema “…”

for each separate concern.

❓ Q27. Using — output-format json vs. Prompt-Based JSON

Scenario: Claude Code for CI/CD

A developer argues that adding “Please return your response as JSON” to the prompt is equivalent to using — output-format json.

Is this correct? A) Yes, both approaches produce identical, reliable JSON output B) Yes, but the flag is faster C) No, prompt-based JSON is actually more reliable D) No, prompt-based JSON may include markdown or extra text while the flag provides a guaranteed JSON envelope

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

The flag — output-format json is a programmatic constraint that guarantees the output is a valid JSON object with known fields. Prompt-based JSON is probabilistic and often includes extra text or markdown.

Why the other answers are wrong :

🚫 A: The approaches are not equivalent. 🚫 B: Prompt-based is less reliable. 🚫 C: Speed is not the main differentiator.

💡 CCA Exam Tip

Programmatic flags ( — output-format, — json-schema) are always more reliable than prompt instructions for structured output.

❓ Q28. Configuring Claude Code for a New Team Member

Scenario: Developer Productivity with Claude

A new developer joins a project that has ./CLAUDE.md, .mcp.json, and skills. The developer also has personal MCP servers.

What should the developer configure? A) Add their personal MCP servers to ~/.claude.json and optionally set personal preferences in ~/.claude/CLAUDE.md B) Nothing; all configuration is automatic C) Copy the project .mcp.json and add personal servers D) Edit the project .mcp.json to add personal servers

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

Project-level configuration loads automatically. The developer only needs to add personal MCP servers to ~/.claude.json and optionally set preferences in ~/.claude/CLAUDE.md.

Why the other answers are wrong :

🚫 B: Personal MCP servers require manual user-level configuration. 🚫 C: Copying creates divergence. 🚫 D: Adding personal tokens to project config exposes credentials.

💡 CCA Exam Tip

Project config loads automatically; personal MCP servers require manual setup in ~/.claude.json.

❓ Q29. Strict JSON Schema Enforcement

Scenario: Structured Data Extraction

A team uses Claude’s structured output feature with a JSON schema to extract invoice data.

What does strict JSON schema enforcement guarantee? A) The extracted values will be factually correct B) The output will be valid JSON C) The output will conform to the specified structure but does not guarantee semantic accuracy D) Both structural compliance and semantic accuracy

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

Strict JSON schema enforcement guarantees structure: correct field names, types, and required fields. It does not guarantee that the values are semantically accurate.

Why the other answers are wrong :

🚫 A/D: Schema enforcement is structural, not semantic. 🚫 B: Strict schemas constrain specific field names, types, and requirements.

💡 CCA Exam Tip

Schema = structure guarantee.

Validation = semantic guarantee.

You need both layers for reliable extraction.

❓ Q30. The “Always Return JSON” Prompt Trap

Scenario: Structured Data Extraction

A system prompt includes “Always return your response as valid JSON.” Approximately 15% of responses include markdown or extra text.

What is the correct fix? A) Make the instruction more emphatic B) Use programmatic enforcement through — json-schema or tool_choice C) Add few-shot examples showing raw JSON D) Switch to a more capable model

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Prompt-based JSON instructions are inherently unreliable. Programmatic enforcement makes non-compliance impossible.

Why the other answers are wrong :

🚫 A: More emphatic instructions still probabilistic. 🚫 C: Few-shot reduces failures but does not eliminate them. 🚫 D: The problem is the enforcement mechanism.

💡 CCA Exam Tip

“Always return JSON” in the prompt is the classic trap. Escalate to programmatic enforcement.

❓ Q31. Validation-Retry Loops with Specific Feedback

Scenario: Structured Data Extraction

An extraction pipeline retries when validation fails with the generic message “The output was invalid. Please try again.”

What is the most effective improvement? A) Replace the generic error message with specific feedback B) Increase the retry count to 10 C) Switch to a larger model for retries D) Skip the retry and escalate on first failure

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

Specific feedback identifies the exact field that failed and tells the model precisely what to do differently. Generic messages give no new information.

Why the other answers are wrong :

🚫 B: More retries with generic messages produce the same errors. 🚫 C: Feedback quality matters more than model size. 🚫 D: Wastes opportunity to auto-correct simple errors.

💡 CCA Exam Tip

Specific feedback is the key variable in retry loop effectiveness.

❓ Q32. Few-Shot Examples: Purpose and Anti-Patterns

A developer includes three few-shot examples and believes they also control the order in which the model calls tools.

Which statement is correct? A) Few-shot examples effectively control both output format and tool execution order B) Few-shot examples are deprecated in favor of JSON schema C) Few-shot examples are only useful for simple tasks D) Few-shot examples demonstrate output format and quality, but do not reliably control tool execution order

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

Few-shot examples excel at demonstrating desired output format and quality. Using them to control tool execution order is an anti-pattern.

Why the other answers are wrong :

🚫 A: Few-shot does not reliably bind execution behavior. 🚫 B: Valuable at all complexity levels. 🚫 C: Complementary to schemas, not deprecated.

💡 CCA Exam Tip

Few-shot = format and quality demonstration. Tool ordering = programmatic enforcement.

❓ Q33. Batch API for Bulk Extraction

Scenario: Claude Code for CI/CD

A team needs to analyze 5,000 code files for security vulnerabilities as part of a nightly audit.

Which processing approach is most cost-effective? A) Process through the real-time API with parallel requests B) Use the Message Batches API for 50% cost savings C) Process files sequentially through Claude Code with -p flag D) Use the Batch API with Zero Data Retention

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

The Message Batches API offers a 50% cost discount for non-blocking, high-volume workflows with no real-time requirement.

Why the other answers are wrong :

🚫 A: Real-time API costs twice as much for a non-real-time use case. 🚫 C: Sequential processing is slow. 🚫 D: Batch API is not eligible for Zero Data Retention.

💡 CCA Exam Tip

Exam Trap: Batch API and Zero Data Retention are mutually exclusive.

❓ Q34. Validation Pipeline for Invoice Extraction

Scenario: Structured Data Extraction

Schema enforcement produces correct structure, but extracted values sometimes have wrong totals or misspellings.

Which approach addresses this gap? A) Add a semantic validation layer with cross-referencing and business rule checks B) Use a more restrictive JSON schema C) Switch to a larger model D) Add more few-shot examples

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

This is the schema-validates-structure-not-semantics gap. Add a semantic validation layer: cross-reference vendor names, verify mathematical relationships, and flag discrepancies for human review.

Why the other answers are wrong :

🚫 B: JSON schemas cannot express business logic like “total must equal sum of line items.” 🚫 C: Model substitution does not guarantee correctness. 🚫 D: Examples provide marginal improvement but no guarantee.

💡 CCA Exam Tip

Schema enforces structure. Business rules enforce semantics. You always need both layers.

❓ Q35. Prompt-Based vs. Programmatic Enforcement

An architect must ensure amounts never exceed $1,000,000.

Three proposals: A) Add to the system prompt B) Use a PostToolUse hook C) Use a JSON schema with “maximum”: 1000000

Which is most reliable? A) A alone B) B and C combined C) C alone D) All three

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Schema provides generation-time constraint. PostToolUse hook adds independent validation, logging, and custom error handling.

Why the other answers are wrong :

🚫 A: Prompt instructions are probabilistic. 🚫 C: Schema alone lacks operational capabilities. 🚫 D: Prompt adds only marginal value.

💡 CCA Exam Tip

Ranking: prompt (lowest) < schema < programmatic hooks.

Use multiple programmatic layers.

❓ Q36. Maximum Retry Count Before Escalation

A data extraction pipeline retries when validation fails.

What is the recommended maximum retry count before escalation? A) 1 retry B) 5–7 retries C) 2–3 retries with specific feedback D) Unlimited retries

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

Recommended range is 2–3 retries with specific error feedback. After that, escalate to human with full context.

Why the other answers are wrong :

🚫 A: One retry may not be sufficient for fixable errors. 🚫 B: Five to seven retries wastes resources. 🚫 D: Risks infinite loops.

💡 CCA Exam Tip

2–3 retries is the universal bounded retry range across CCA domains.

❓ Q37. Prompt Design for CI/CD Code Review

Scenario: Claude Code for CI/CD

Initial prompt: “Review this code for security issues.” Reviews are inconsistent.

What is the most effective improvement? A) Restructure with specific categories, severity levels, and required output format B) Add “Be very thorough and detailed” C) Add 10 few-shot examples D) Switch to Claude Opus 4.6

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

Vague prompts produce variable results. Structured prompts with specific categories and required output format remove ambiguity and improve consistency.

Why the other answers are wrong :

🚫 B: “Thorough” is still vague. 🚫 C: Examples consume tokens and do not guarantee consistency. 🚫 D: Model capability does not fix vague prompts.

💡 CCA Exam Tip

Inconsistent output = vague prompt.

Consistent output = structured prompt with specific categories and output requirements.

❓ Q38. Long Document Extraction and “Lost in the Middle”

Scenario: Structured Data Extraction

A 50-page contract extraction system has high error rates on pages 20–30 while edges are accurate.

What is this problem called and what is the correct mitigation? A) Context overflow — use larger context window B) Attention decay — repeat instructions C) Token exhaustion — use prompt caching D) The “lost in the middle” effect — split into smaller chunks and merge results

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

The “lost in the middle” effect describes reduced attention to middle content in long contexts. Mitigation: chunk the document into smaller sections, process each independently, then merge results.

Why the other answers are wrong :

🚫 A: Larger window increases capacity but does not fix attention distribution. 🚫 B: Prompt caching reduces cost but not accuracy issue. 🚫 C: Repeating instructions provides only marginal help.

💡 CCA Exam Tip

Larger context window does NOT fix “lost in the middle.” Correct fix is always chunking + merging.

❓ Q39. Structured Output via the API

A developer needs typed Pydantic objects from the Claude API.

Which approach provides the strongest type guarantees? A) System prompt + manual parsing B) client.messages.parse() with Pydantic model and structured-outputs beta header C) Regular messages.create() + JSON.parse() D) Batch API with JSON schema

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

client.messages.parse() with Pydantic returns a fully typed object with compile-time and runtime validation.

Why the other answers are wrong :

🚫 A/C: No structural guarantees. 🚫 D: Batch API is for non-interactive bulk work.

💡 CCA Exam Tip

messages.parse() + Pydantic = strongest types (beta). tool_choice with structured tool = strongest stable option.

❓ Q40. Extraction Accuracy: Valid JSON with Wrong Values

Scenario: Structured Data Extraction

The pipeline produces 98% schema-compliant JSON, but 12% of records have incorrect values.

What does this indicate? A) The JSON schema needs to be more restrictive B) The model is hallucinating — replace with rule-based extraction C) Schema ensures structural correctness but not semantic accuracy; add semantic validation layer D) 12% error rate is acceptable

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

This is the structure-vs-semantics gap. Schema works for structure; semantic validation with business rules and cross-referencing is missing.

Why the other answers are wrong :

🚫 A: Schemas cannot enforce semantic rules. 🚫 B: 12% value errors are fixable with validation. 🚫 D: Too high for production financial/legal data.

💡 CCA Exam Tip

98% structural + 12% semantic errors = your schema is working; your validation layer is missing.

❓ Q41. MCP Primitives

The Model Context Protocol (MCP) defines three core primitives.

Which answer correctly names all three? A) Functions, Variables, and Callbacks B) Actions, Data, and Templates C) Endpoints, Schemas, and Handlers D) Tools, Resources, and Prompts

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

MCP’s three primitives are Tools (executable functions), Resources (data for context), and Prompts (predefined workflow templates).

Why the other answers are wrong :

🚫 A/C: General programming or REST concepts. 🚫 B: Plausible but incorrect terminology.

💡 CCA Exam Tip

Memorize exact names: Tools, Resources, Prompts.

❓ Q42. Tools vs. Resources in MCP

Scenario: Developer Productivity with Claude

An MCP server provides search capability and full text of static API reference.

Which primitive for each? A) Both as Tools B) Search as Tool, API reference as Resource C) Both as Resources D) Search as Prompt, reference as Resource

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Tools = actions with parameters and dynamic results. Resources = static data loaded persistently into context.

Why the other answers are wrong :

🚫 A: Treating static reference as Tool wastes calls. 🚫 C: Search requires parameters — cannot be a Resource.

💡 CCA Exam Tip

Tools = actions/dynamic.

Resources = data/persistent.

This boundary is heavily tested.

❓ Q43. Tool Descriptions as the Routing Mechanism

Two tools have vague descriptions and 25% of requests are routed incorrectly.

Root cause and fix? A) Tool descriptions are the primary routing mechanism; rewrite them to be specific B) Fine-tune the model C) Add keyword-based routing layer D) Combine the two tools

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

Tool descriptions drive model selection. Vague descriptions create ambiguity. Specific, differentiated descriptions fix routing.

Why the other answers are wrong :

🚫 B: Fine-tuning is unnecessary and expensive. 🚫 C: Adds complexity. 🚫 D: Loses distinct functionality.

💡 CCA Exam Tip

Every tool description should include:

what it does,

when to use it, and

how it differs from similar tools.

❓ Q44. Tool Count per Agent

Scenario: Code Generation with Claude Code

An agent has 18 tools and frequently selects the wrong one.

Recommended solution? A) Improve descriptions of all 18 tools B) Reduce to 4–5 tools per agent by using specialized subagents C) Remove least-used tools D) Add few-shot examples

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

18 tools exceed the 4–5 tool recommendation. Distribute across specialized subagents with a coordinator.

Why the other answers are wrong :

🚫 A: Descriptions cannot overcome fundamental overload. 🚫 C: May remove needed functionality. 🚫 D: Few-shot does not reliably control selection.

💡 CCA Exam Tip

The 4–5 tool limit is one of the most consistent principles in this domain.

❓ Q45. MCP Project Configuration

Where is project-level MCP server configuration stored? A) In ~/.claude.json B) In CLAUDE.md as text C) In .mcp.json at the project root D) In ~/.mcp/config.json

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

Project-level MCP servers are configured in .mcp.json at the project root and committed to source control.

Why the other answers are wrong :

🚫 A: User-level. 🚫 B: Wrong format. 🚫 D: Not a recognized path.

💡 CCA Exam Tip

.mcp.json = project/shared/committed.

❓ Q46. Personal API Keys in MCP Configuration

Scenario: Developer Productivity with Claude

A developer has a personal GitHub API token. A teammate asks to add it to the project .mcp.json.

Why is this a problem? A) It is not a problem B) The token would be committed to source control C) .mcp.json does not support authentication D) Performance issue

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

.mcp.json is committed. Personal tokens must stay in ~/.claude.json to avoid exposing credentials.

Why the other answers are wrong :

🚫 A: Major security risk. 🚫 C: .mcp.json does support authentication. 🚫 D: The issue is security, not performance.

💡 CCA Exam Tip

Personal tokens go in ~/.claude.json, never in .mcp.json.

❓ Q47. Designing MCP Config for Shared and Personal Servers

Scenario: Developer Productivity with Claude

Team needs shared PostgreSQL/Sentry servers and each developer’s personal GitHub server.

Correct configuration? A) All in .mcp.json with placeholders B) Shared in .mcp.json, personal in ~/.claude.json C) All in ~/.claude.json with setup script D) Shared as CLAUDE.md instructions

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Shared infrastructure belongs in .mcp.json (committed). Personal tools with individual tokens belong in ~/.claude.json.

Why the other answers are wrong :

🚫 A: Risk of committing real tokens. 🚫 C: Loses single source of truth. 🚫 D: Wrong format.

💡 CCA Exam Tip

Shared = .mcp.json. Personal = ~/.claude.json.

❓ Q48. Tool Error Handling in Multi-Agent Systems

Scenario: Multi-Agent Research System

A subagent calls an MCP tool that returns 503 error but returns only “I was unable to complete the research.”

What is wrong and how to improve? A) Return structured error information (tool name, error type, retryable?, partial results) B) Retry indefinitely C) Coordinator should call the tool directly D) MCP tool should handle all retries internally

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

Vague messages create silent failures. Structured error reporting lets the coordinator make informed decisions.

Why the other answers are wrong :

🚫 B: Indefinite retries block the system. 🚫 C: Breaks separation of concerns. 🚫 D: Persistent errors must surface to the agent.

💡 CCA Exam Tip

Subagents must return: tool name, error type, retryability, partial results.

❓ Q49. When to Use Resources vs. Tools

When is a Resource more appropriate than a Tool for API reference documentation? A) When data changes frequently B) When the data is too large for context C) When the client needs to execute an action D) When the data is relatively static, fits in context, and benefits from persistent availability

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

Resources suit stable data that fits in context and benefits from being persistently available.

Why the other answers are wrong :

🚫 A: Frequently changing data → Tool. 🚫 B: Actions → Tool. 🚫 C: Too large for context → Tool with search.

💡 CCA Exam Tip

Resources = static + fits context + persistent benefit. Tools = dynamic/actions.

❓ Q50. Redesigning an Agent with Tool Misrouting

Scenario: Developer Productivity with Claude

An agent with 15 tools has 30% misrouting.

Most effective redesign? A) Rewrite descriptions B) Split into coordinator + five specialized subagents (3 tools each) C) Remove API tools D) Add a separate classification model

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

15 tools create too large a decision space. Subagents reduce each agent’s choice to 3 tools.

Why the other answers are wrong :

🚫 A: Helps marginally but does not solve scale. 🚫 C: Loses functionality. 🚫 D: Adds latency and failure points.

💡 CCA Exam Tip

15 tools + high misrouting = split into subagents with 4–5 tools each.

❓ Q51. Silent Tool Failures in Multi-Agent Systems

Scenario: Multi-Agent Research System

A subagent’s MCP tool fails but the subagent fabricates a plausible summary.

What design change prevents this? A) PostToolUse hook that validates tool responses B) PreToolUse hook to check availability C) Increase retry count D) Give coordinator direct access to all tools

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

PostToolUse hook inspects actual tool response for expected patterns and detects fabrication.

Why the other answers are wrong :

🚫 B: PreToolUse prevents the call but not fabrication. 🚫 C: Does not stop fabrication after retries. 🚫 D: Breaks subagent architecture.

💡 CCA Exam Tip

Exam Trap:

PreToolUse prevents the call but not substitution.

PostToolUse detects what actually happened.

❓ Q52. The “Lost in the Middle” Effect

Scenario: Customer Support Resolution Agent

A support agent processes long account histories but misses issues in the middle.

What is this phenomenon called? A) Context overflow B) Token truncation C) The “lost in the middle” effect D) Recency bias

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

“Lost in the middle” describes reduced attention to middle content in long contexts while edges receive stronger attention.

Why the other answers are wrong :

🚫 A: Overflow means exceeding token limit. 🚫 B: Truncation removes content. 🚫 D: Recency bias would affect early content too.

💡 CCA Exam Tip

“Lost in the middle” affects accuracy, not capacity.

All content is present.

❓ Q53. Larger Context Windows and Attention Distribution

Scenario: Claude Code for CI/CD

A code review agent struggles with large PRs. Teammate suggests larger context window.

Is this the correct solution? A) Yes B) No — larger window does not fix attention distribution C) Yes if 10x larger D) No because it is slower

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Larger context increases capacity but does not change attention distribution. “Lost in the middle” still applies.

Why the other answers are wrong :

🚫 A: Classic context window size trap. 🚫 C: No size threshold fixes it. 🚫 D: Correct conclusion, wrong reason.

💡 CCA Exam Tip

More capacity ≠ better attention. Chunking is the correct fix.

❓ Q54. Self-Reported Confidence Calibration

Scenario: Structured Data Extraction

Pipeline uses Claude’s self-reported confidence for routing to human review.

What is the problem? A) LLM confidence is not reliably calibrated B) Nothing — confidence is reliable C) Confidence only works for classification D) Thresholds are too high

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

LLM self-reported confidence scores are poorly calibrated and cannot be trusted as the sole routing criterion.

Why the other answers are wrong :

🚫 B: Problem applies broadly. 🚫 C: Adjusting thresholds does not fix miscalibration. 🚫 D: Confidence trap is heavily tested.

💡 CCA Exam Tip

Never use LLM self-reported confidence as primary gatekeeper. Use programmatic validation.

❓ Q55. Prompt Caching Economics

A support agent uses the same 4,000-token system prompt for 10,000 daily requests.

What cost savings does Prompt Caching provide? A) 50% reduction on all calls B) Zero savings C) 90% reduction on all tokens D) 90% reduction on cache reads (25% premium on writes)

⬇ ⬇ ⬇ ⬇

✅ Answer: D

Explanation

Prompt Caching gives 90% savings on repeated static content (cache reads). Writes have 25% premium. Most requests hit the cache.

Why the other answers are wrong :

🚫 A: 50% is Batch API discount. 🚫 B: Only cached portion benefits. 🚫 C: 4,000 tokens meets minimum for most models.

💡 CCA Exam Tip

Prompt Caching (90% read savings)

vs

Batch API (50% discount, high latency).

❓ Q56. Batch API for Blocking Workflows

Scenario: Customer Support Resolution Agent

An engineer suggests using Message Batches API for all support interactions to save 50%.

Why is this problematic? A) Does not support conversation history B) Customer support is blocking/real-time; Batch API has no SLA (up to 24h) C) Only supports English D) Maximum 100 requests per batch

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Batch API is for non-blocking workflows. Customer support requires real-time responses.

Why the other answers are wrong :

🚫 A: Supports history. 🚫 C: Supports same languages. 🚫 D: Supports up to 100,000 requests.

💡 CCA Exam Tip

Batch API = non-blocking/offline.

Real-time API = user-facing/blocking workflows.

❓ Q57. Cross-Referencing for Extraction Reliability

Scenario: Structured Data Extraction

Medical claims system occasionally extracts wrong procedure code.

Most effective reliability layer? A) Ask Claude to double-check B) Use second model and compare C) Programmatic cross-referencing against known database D) Add more prompt detail

⬇ ⬇ ⬇ ⬇

✅ Answer: C

Explanation

Deterministic cross-referencing against authoritative sources catches invalid or wrong codes.

Why the other answers are wrong :

🚫 A/C: Still relies on LLM(s). 🚫 D: Prompt improvements are marginal.

💡 CCA Exam Tip

For critical fields, validate programmatically against authoritative sources.

❓ Q58. Context Forking for Parallel Analysis

Scenario: Multi-Agent Research System

A 50-turn conversation exists. User wants to explore two alternative strategies simultaneously while preserving full history.

Correct approach? A) Use fork_session=True twice B) Two new sessions with summary C) Process sequentially in same session D) Use Message Batches API

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation=

fork_session=True creates independent branches with exact full history. No loss, no contamination.

Why the other answers are wrong :

🚫 B: Summarization is lossy. 🚫 C: Sequential processing contaminates analyses. 🚫 D: Batch API is non-interactive.

💡 CCA Exam Tip

Fork sessions for parallel exploration with shared exact history.

❓ Q59. Observability

What improves observability in agentic systems? A) Logs and metrics B) Larger models C) More tools D) Longer prompts

⬇ ⬇ ⬇ ⬇

✅ Answer: A

Explanation

Logs and metrics provide visibility into system behavior for debugging and improvement.

Why the other answers are wrong :

🚫 B/C/D: Do not directly improve observability.

💡 CCA Exam Tip

You can’t fix what you can’t see.

❓ Q60. End-to-End Reliability

What is the key principle for reliable agentic systems? A) Perfect prompts B) System design + layered safeguards C) Larger models D) More data

⬇ ⬇ ⬇ ⬇

✅ Answer: B

Explanation

Reliability comes from engineered system design: validation, retries, hooks, escalation, and observability — not just prompts or bigger models.

Why the other answers are wrong :

🚫 A/C/D: Insufficient alone for production reliability.

💡 CCA Exam Tip

Reliability is engineered, not prompted. Build defense in depth.

Please let me know if you found this useful. Getting the formatting correct was painful. I wanted the reader to be able to answer the question. See how they did and not see the answer until they were ready. I added the three arrows betweent the question and the answer so they could scroll and answer without seeing the answer too soon.

I hope this was helpful. Let me know if there are any mistakes. And if you take the test, let me know how I can improve this from what you remember being on the test. If you see a question that you feel would never be on the test, let me know. If you see some types of questions that are clearly missing, also let me know.

— Rick Hightower

Rick Hightower is a hands-on agent architect, AI agent engineer and technical writer who builds with LangGraph, Claude Agent SDK, CrewAI, and more. He was Java assistnant editor and NoSQL editor at InfoQ, and covers agent development from a practitioner’s perspective.

He created skilz, the universal agent skill installer, supporting 30+ coding agents including Claude Code, Gemini, Copilot, and Cursor, and co-founded the world’s largest agentic skill marketplace. Connect with Rick Hightower on LinkedIn or Medium. Check out SpillWave, your source for AI expertise.

Rick has been actively developing generative AI systems, agents, and agentic workflows for years. He is the author of numerous agentic frameworks and developer tools and brings deep practical expertise to teams looking to adopt AI. He enjoys writing about himself in the 3rd person.