CCAF Question Bank

Which task is best served by a single LLM call rather than an agent?

• A. "Turn this design doc into a merged PR"
• B. "Extract the title and author from this PDF"
• C. An overnight multi-repo migration
• D. An open-ended research investigation

The Tool Runner and the Claude Agent SDK are often confused. What distinguishes them?

• A. Both ship built-in file/bash tools
• B. The Tool Runner loops over tools _you_ define; the Agent SDK is Claude Code as a library with built-in tools
• C. The Agent SDK provides managed deployment; the Tool Runner is server-hosted
• D. They are the same package

Which single option supplies _both_ the agent harness and a managed per-session deployment/sandbox?

• A. Claude API — manual loop
• B. Claude API — Tool Runner
• C. Managed Agents (CMA)
• D. Claude Agent SDK

Per the "should I promote an action to a dedicated tool?" heuristic, which is the strongest reason to build a `send_email` tool instead of routing through bash?

• A. Bash can't run `curl`
• B. A hard-to-reverse action needs a typed hook the harness can gate behind approval
• C. Dedicated tools are always faster
• D. Bash tools can't be described to Claude

In Managed Agents, where do `model`, `system`, and `tools` belong?

• A. On `sessions.create()`
• B. On the persisted Agent object (`agents.create()`)
• C. On the Environment
• D. On each event

Why is calling `agents.create()` at the top of every request an anti-pattern?

• A. It's slower but harmless
• B. It accumulates orphaned agents, pays create latency each run, and defeats versioning
• C. It's actually required per session
• D. It deletes the previous agent

A Managed Agent needs a secret to call a third-party service. What is the first-class mechanism (cloud environments)?

• A. Put the key in the system prompt
• B. A vault credential (MCP OAuth, static bearer, or `environment_variable`) substituted at egress; the sandbox never sees it
• C. Hard-code it in the container image
• D. Pass it as a user message each turn

In a session's event drain loop, when should you break?

• A. On any `session.status_idle`
• B. On `session.status_terminated`, or `session.status_idle` with a terminal `stop_reason` (not `requires_action`)
• C. On the first `agent.message`
• D. Only on a network error

The SSE event stream drops mid-session. On reconnect, how do you avoid missing events?

• A. Reopen the stream and continue from "now"
• B. Fetch event history via `events.list()` and dedupe by event ID as the live stream catches up
• C. Recreate the session
• D. Nothing — SSE replays automatically

To run a Managed Agent on a recurring cron schedule, you use…

• A. A client-side scheduler that calls `sessions.create()`
• B. A scheduled deployment (each firing creates a session autonomously)
• C. The Batches API
• D. A memory store

📋 Scenario: Customer Support Resolution Agent

Your agentic loop sends a request to Claude and receives a response with stop_reason of 'tool_use'. What is the correct control-flow decision?

• A. Execute the requested tool(s), append the results to the conversation, and send another request to Claude.
• B. Treat the response as final and return the assistant text to the user.
• C. Terminate the loop because a tool call indicates the task is complete.
• D. Parse the assistant text for a phrase like 'done' to decide whether to continue.

📋 Scenario: Customer Support Resolution Agent

You want your agentic loop to terminate reliably. Which is the correct primary termination condition?

• A. When stop_reason equals 'end_turn'.
• B. When the assistant response contains no tool calls and some text.
• C. When a fixed maximum iteration cap (e.g., 5 loops) is reached.
• D. When the last tool returns an empty result.

📋 Scenario: Customer Support Resolution Agent

Production data shows that in 12% of cases the agent skips get_customer and calls lookup_order using only a stated name, sometimes causing misidentified accounts and incorrect refunds. What most effectively fixes this?

• A. Add a programmatic prerequisite that blocks lookup_order and process_refund until get_customer has returned a verified customer ID.
• B. Enhance the system prompt to state that get_customer is mandatory before any order operation.
• C. Add few-shot examples showing the agent always calling get_customer first.
• D. Add a routing classifier that enables only tools appropriate to each request type.

📋 Scenario: Customer Support Resolution Agent

A refund policy states the agent must never issue refunds above $500 without human approval. Which implementation guarantees compliance?

• A. A tool-call interception hook that blocks process_refund calls over $500 and redirects to human escalation.
• B. A strongly-worded system prompt instruction never to exceed $500.
• C. Few-shot examples showing the agent escalating high-value refunds.
• D. An enum field in the refund tool schema limiting the amount.

📋 Scenario: Customer Support Resolution Agent

Different MCP tools return timestamps in different formats (Unix epoch, ISO 8601, numeric status codes). You want the agent to reason over normalized data without changing each backend. What is the cleanest approach?

• A. A PostToolUse hook that normalizes tool results before the model processes them.
• B. Instruct the model in the system prompt to convert all timestamps itself.
• C. Add a separate normalize_dates tool the agent must call after every lookup.
• D. Rewrite every MCP server to emit ISO 8601.

📋 Scenario: Multi-Agent Research System

Reports on 'impact of AI on creative industries' cover only visual arts. The coordinator log shows it decomposed the topic into 'AI in digital art', 'AI in graphic design', and 'AI in photography'. Subagents each executed correctly. Root cause?

• A. The coordinator's task decomposition is too narrow, omitting domains like music, writing, and film.
• B. The synthesis agent lacks gap-detection instructions.
• C. The web search agent's queries are not comprehensive.
• D. The document analysis agent filters out non-visual sources.

📋 Scenario: Multi-Agent Research System

A coordinator needs to spawn subagents via the Task tool. Which statement is correct about subagent context?

• A. Subagents do not automatically inherit the coordinator's conversation history; context must be passed explicitly in their prompt.
• B. Subagents automatically share memory with the coordinator across invocations.
• C. Subagents inherit the full parent context by default, so passing data is redundant.
• D. Subagents can read the coordinator's context only if they share the same session name.

📋 Scenario: Multi-Agent Research System

You want subagents to run in parallel to cut latency. How should the coordinator invoke them?

• A. Emit multiple Task tool calls within a single coordinator response.
• B. Invoke each subagent in a separate turn and wait for each to return.
• C. Set tool_choice to 'any' so the model parallelizes automatically.
• D. Increase max_tokens so all subagents fit in one completion.

📋 Scenario: Multi-Agent Research System

For a coordinator to be able to spawn subagents, which configuration is required?

• A. allowedTools must include 'Task'.
• B. tool_choice must be set to 'any'.
• C. fork_session must be enabled.
• D. The subagents must be declared in CLAUDE.md.

📋 Scenario: Multi-Agent Research System

The synthesis agent needs to verify facts mid-task. Currently it returns to the coordinator, which invokes web search, then re-invokes synthesis — adding 40% latency. 85% of verifications are simple fact-checks; 15% need deeper investigation. Best approach?

• A. Give the synthesis agent a scoped verify_fact tool for simple lookups; keep complex verifications routed through the coordinator.
• B. Give the synthesis agent access to all web search tools so it can verify anything directly.
• C. Batch all verification needs and send them to the coordinator at the end of the pass.
• D. Have the web search agent pre-cache extra context around every source.

📋 Scenario: Code Generation with Claude Code

You are restructuring a monolith into microservices — dozens of files, decisions about service boundaries and dependencies. Which decomposition strategy fits best?

• A. Dynamic, adaptive decomposition: map structure first, identify high-impact areas, then build a prioritized plan that adapts as dependencies are discovered.
• B. A fixed sequential pipeline that renames files alphabetically.
• C. A single prompt containing every change so the model does it all at once.
• D. Random file-by-file edits until boundaries emerge.

📋 Scenario: Customer Support Resolution Agent

A customer message contains three separate concerns (a billing dispute, a return, and an address change). What is the recommended handling pattern?

• A. Decompose into distinct items, investigate each (in parallel where possible) using shared context, then synthesize one unified resolution.
• B. Handle only the first concern and ask the customer to resubmit the others separately.
• C. Escalate immediately because multi-concern requests are inherently complex.
• D. Merge the concerns into a single tool call to reduce round-trips.

📋 Scenario: Code Generation with Claude Code

You paused a long investigation session yesterday. Since then, teammates modified two of the files you had analyzed. You resume with --resume. What is the best practice?

• A. Inform the resumed session about the specific file changes so it can re-analyze those targeted areas.
• B. Assume prior tool results are still valid and continue without changes.
• C. Always start a brand-new session and re-explore everything from scratch.
• D. Fork the session so both the old and new file versions are analyzed simultaneously.

📋 Scenario: Code Generation with Claude Code

You want to compare two different refactoring strategies that both start from the same completed codebase analysis. Which mechanism is designed for this?

• A. fork_session to create independent branches from a shared analysis baseline.
• B. --resume to continue the same named session for both strategies.
• C. Running two PostToolUse hooks in parallel.
• D. Setting tool_choice to 'any' on both attempts.

📋 Scenario: Scenario 1 — Customer Support Resolution Agent

Production data shows that in 12% of cases, your agent skips `get_customer` entirely and calls `lookup_order` using only the customer's stated name, occasionally leading to misidentified accounts and incorrect refunds. What change would most effectively address this reliability issue?

• A. Add a programmatic prerequisite that blocks `lookup_order` and `process_refund` calls until `get_customer` has returned a verified customer ID.
• B. Enhance the system prompt to state that customer verification via `get_customer` is mandatory before any order operations.
• C. Add few-shot examples showing the agent always calling `get_customer` first, even when customers volunteer order details.
• D. Implement a routing classifier that analyzes each request and enables only the subset of tools appropriate for that request type.

📋 Scenario: Scenario 3 — Multi-Agent Research System

After running on "impact of AI on creative industries," reports cover only visual arts — missing music, writing, and film production. The coordinator decomposed the topic into: "AI in digital art creation," "AI in graphic design," and "AI in photography." What is the most likely root cause?

• A. The synthesis agent lacks instructions for identifying coverage gaps in the findings it receives from other agents.
• B. The coordinator agent's task decomposition is too narrow, resulting in subagent assignments that don't cover all relevant domains of the topic.
• C. The web search agent's queries are not comprehensive enough and need to be expanded to cover more creative industry sectors.
• D. The document analysis agent is filtering out sources related to non-visual creative industries due to overly restrictive relevance criteria.

📋 Scenario: Customer Support Resolution Agent

Your agentic loop calls a tool and the API responds with stop_reason: "end_turn" instead of "tool_use". What should the loop do?

• A. Treat it as task complete — the model decided no further tools are needed — output the final text content and exit the loop.
• B. Retry the last tool call since the model forgot to request it.
• C. Reinject the previous tool result and call the API again.
• D. Abort the session and log an error — end_turn during tool use is invalid.

📋 Scenario: Customer Support Resolution Agent

Mid-processing, the agent receives stop_reason: "max_tokens" while a tool_use block is still active (the JSON arguments are incomplete). What is the correct behavior?

• A. Raise an error to the operator — the tool arguments are truncated and cannot be safely used.
• B. Extract whatever partial arguments are available and call the tool anyway.
• C. Return the partial response to the user as-is.
• D. Double max_tokens and retry automatically.

📋 Scenario: Multi-Agent Research System

You have 6 independent research topics. Using the Task tool to run parallel subagents reduces total time from 48 minutes to 12 minutes. What architectural property enables this?

• A. Each subagent has its own isolated context and executes independently, so wall-clock time equals the slowest single task, not the sum.
• B. The coordinator's context window grows as subagents finish, allowing more synthesis capacity.
• C. Parallel execution increases each subagent's token limits proportionally.
• D. The Task tool automatically deduplicates overlapping findings across subagents.

📋 Scenario: Code Generation with Claude Code

After generating code in a long session, you want an unbiased review without the generator's reasoning context influencing it. Which approach achieves genuine independence?

• A. Call fork_session to spawn a fresh instance that receives only the artifact, not the generation conversation history.
• B. Ask the same session: 'review this carefully without your generation context.'
• C. Restart the session and re-paste the code manually.
• D. Have the same agent review it after running /compact.

📋 Scenario: Multi-Agent Research System

Your 5-stage pipeline runs A→B→(C and D in parallel)→E. Stages C and D can run simultaneously after B completes. Which architecture model best describes this?

• A. A pipeline with a fork after B: B feeds C and D in parallel, then E synthesizes their outputs.
• B. A pure hub-and-spoke where every stage reports back to a central coordinator.
• C. A single monolithic agent doing all 5 stages sequentially.
• D. Five independent agents with no dependency tracking.

📋 Scenario: Developer Productivity with Claude

You want to prevent the agent from executing any destructive bash commands (e.g., rm -rf, DROP TABLE) in the production environment. Where is the most reliable enforcement point?

• A. A PreToolUse hook that inspects tool arguments before execution and blocks commands matching destructive patterns.
• B. A PostToolUse hook that reverts any destructive changes after they execute.
• C. A CLAUDE.md rule telling the agent not to run destructive commands.
• D. Setting max_tokens low to prevent long command sequences.

📋 Scenario: Developer Productivity with Claude

Compliance requires a tamper-evident log of every file write performed by the agent, including what was written, timestamp, and session ID. Which implementation point is correct?

• A. A PostToolUse hook that appends write events to an audit log after each tool execution, capturing all writes regardless of model behavior.
• B. Trust the model to self-report its writes at the end of the session.
• C. Read git diff after the session completes to reconstruct all file changes.
• D. Add a log_writes tool and instruct the model to call it after each write.

📋 Scenario: Multi-Agent Research System

A research agent has been running for 45 minutes on a large dataset. You specified 'be thorough' but it shows no sign of stopping. What is the core architectural problem?

• A. No defined stop condition — 'be thorough' provides no iteration bound, time limit, or diminishing-return threshold.
• B. The context window is too small to hold the results, causing the agent to loop.
• C. A tool_use response is pending and the API is waiting for a tool_result.
• D. A cyclic dependency in the hub-and-spoke routing graph.

📋 Scenario: Customer Support Resolution Agent

A customer requests a refund that exceeds the agent's $200 autonomous approval limit. What should the agentic loop do?

• A. Pause the loop and escalate to a human agent with structured context (customer ID, order details, exception amount).
• B. Deny the refund automatically and cite the $200 policy limit to the customer.
• C. Approve it anyway since the customer is clearly entitled to the exception.
• D. Ask the customer to call the phone line without escalating internally.

📋 Scenario: Developer Productivity with Claude

You want to ensure the agent never deploys to production during off-hours (before 9 AM or after 5 PM UTC). Which implementation is most reliable?

• A. Programmatic enforcement in the deploy tool itself — check current UTC hour and reject calls outside business hours.
• B. A CLAUDE.md rule: 'never deploy to production before 9 AM or after 5 PM UTC.'
• C. A system prompt instruction telling the agent to check the time before deploying.
• D. Setting max_tokens low to discourage long deployment sequences.

When Claude makes multiple parallel tool calls in one assistant message, how must you return the results?

• A. One `tool_result` per follow-up user message
• B. All `tool_result` blocks in a single user message
• C. As assistant messages
• D. Only the first result; drop the rest

Which `tool_choice` value forces Claude to use at least one tool but lets it pick which?

• A. `{"type": "auto"}`
• B. `{"type": "any"}`
• C. `{"type": "tool", "name": "..."}`
• D. `{"type": "none"}`

The SDK Tool Runner (`client.beta.messages.tool_runner`) automates which of the following?

• A. Hosting a sandbox with built-in file/bash tools
• B. The request → execute → loop cycle for tools _you_ define
• C. Deploying the agent to Anthropic's infrastructure
• D. Web browsing without any tool definition

How should you always read the `input` of a tool_use block produced by current models?

• A. Raw string-match the serialized JSON
• B. Parse it with `json.loads()` / `JSON.parse()`
• C. Assume ASCII-only escaping
• D. Trim trailing newlines before matching

How do you declare the built-in bash tool correctly?

• A. A custom tool named `"bash"` with your own `input_schema`
• B. `{"type": "bash_20250124", "name": "bash"}` with no `input_schema`
• C. `{"type": "custom", "name": "bash"}`
• D. A server-side tool requiring a beta header

A web search server-side tool encounters an error. How is it surfaced?

• A. A raised SDK exception
• B. HTTP 200 with a result block whose `content` is an error object (e.g. `{error_code: ...}`)
• C. HTTP 500
• D. An empty response

What does "programmatic tool calling" (PTC) change about how tool results reach Claude?

• A. Each tool result enters Claude's context individually
• B. Claude writes code that calls tools; results return to the running code, and only the final output reaches Claude's context
• C. Results are cached automatically
• D. Results are streamed token-by-token

For strict tool use guaranteeing exact schema validation, where does `strict: true` go?

• A. On `tool_choice`
• B. As a top-level field on the tool definition (with `additionalProperties: false` + `required`)
• C. In `output_config`
• D. As a beta header

Using the MCP connector on the Messages API, which two parameters must be supplied together?

• A. `mcp_servers` alone is sufficient
• B. `mcp_servers` plus a matching `mcp_toolset` entry in `tools`
• C. `tools` with a custom tool named `mcp`
• D. `output_config` plus `mcp_servers`

What is the correct mental model of MCP?

• A. A proprietary Anthropic-only tool format
• B. A standardized protocol for exposing third-party capabilities (tools/resources) to a model
• C. A replacement for the Messages API
• D. A local-only file protocol

A hosted MCP server (e.g. Notion, Linear) typically requires which kind of credential?

• A. The service's native REST API key (e.g. a Notion `ntn_` token)
• B. An OAuth bearer token — a different auth system from the REST API
• C. Your Anthropic API key
• D. No credential is needed

📋 Scenario: Customer Support Resolution Agent

The agent frequently calls get_customer when users ask about orders. Both tools have minimal descriptions ('Retrieves customer information' / 'Retrieves order details') and accept similar identifiers. What is the most effective first step?

• A. Expand each tool's description to include input formats, example queries, edge cases, and when to use it versus the similar tool.
• B. Add 5-8 few-shot examples to the system prompt showing correct routing.
• C. Add a routing layer that parses input and pre-selects a tool from keywords.
• D. Consolidate both into a single lookup_entity tool that decides internally.

📋 Scenario: Multi-Agent Research System

You have a generic analyze_document tool being used inconsistently for very different jobs. What is the recommended redesign?

• A. Split it into purpose-specific tools with defined I/O contracts (e.g., extract_data_points, summarize_content, verify_claim_against_source).
• B. Keep one tool but add a mode string parameter with many enum values.
• C. Remove the tool and rely on the model's built-in reasoning.
• D. Duplicate the tool under three names with identical descriptions.

📋 Scenario: Customer Support Resolution Agent

An MCP tool must communicate that a refund was rejected because it violates policy (a permanent business rule). How should the tool respond so the agent behaves correctly?

• A. Return structured error metadata: errorCategory, isRetryable:false, and a customer-friendly explanation.
• B. Return a generic 'Operation failed' string.
• C. Return an empty successful result.
• D. Throw an unhandled exception to stop the loop.

📋 Scenario: Multi-Agent Research System

Which distinction is most important for an agent to make appropriate recovery decisions from tool errors?

• A. Transient/timeout errors (retryable) versus business/permission errors (non-retryable) versus valid empty results (success with no matches).
• B. Whether the error message is longer or shorter than 100 characters.
• C. Whether the tool is built-in or an MCP tool.
• D. Whether the error occurred on an even or odd iteration.

📋 Scenario: Multi-Agent Research System

A synthesis agent that should only combine findings keeps attempting web searches, producing poor results. It currently has access to 18 tools. Best fix?

• A. Restrict each subagent's tool set to only what its role needs, removing cross-specialization tools.
• B. Add more detailed instructions telling it not to search.
• C. Increase max_tokens so it has room to search and synthesize.
• D. Give every subagent all 18 tools for flexibility.

📋 Scenario: Structured Data Extraction

You want to guarantee the model calls a tool rather than replying with conversational text, but it may choose which extraction tool. Which tool_choice setting?

• A. tool_choice: 'any'
• B. tool_choice: 'auto'
• C. tool_choice: {\
• D. :\

📋 Scenario: Structured Data Extraction

You must ensure extract_metadata runs before any enrichment tool. How do you force this on the first turn?

• A. Set tool_choice to forced selection: {\
• B. :\
• C. ,\
• D. :\

📋 Scenario: Developer Productivity with Claude

Your team wants a shared MCP server (with a token) available to everyone on the project, without committing secrets. What is the correct configuration?

• A. Configure it in project-scoped .mcp.json using environment variable expansion (e.g., ${GITHUB_TOKEN}).
• B. Hard-code the token in ~/.claude.json so it stays on each machine.
• C. Put the raw token directly in .mcp.json and commit it.
• D. Add the token to the project CLAUDE.md file.

📋 Scenario: Developer Productivity with Claude

The agent keeps preferring the built-in Grep tool over a more capable custom MCP search tool. What is the most effective remedy?

• A. Enhance the MCP tool's description to clearly explain its capabilities and outputs so the model prefers it when appropriate.
• B. Delete the built-in Grep tool from the environment.
• C. Rename the MCP tool to 'grep2'.
• D. Add the instruction 'always use MCP tools' to every user message.

📋 Scenario: Developer Productivity with Claude

An agent must find all callers of a function across an unfamiliar codebase. Which built-in tool is the right first choice?

• A. Grep — to search file contents for the function name across the codebase.
• B. Glob — to match files by name pattern.
• C. Write — to create a new index file.
• D. Bash — to reformat the code first.

📋 Scenario: Scenario 1 — Customer Support Resolution Agent

Production logs show the agent frequently calls `get_customer` when users ask about orders (e.g., "check my order #12345"), instead of calling `lookup_order`. Both tools have minimal descriptions ("Retrieves customer information" / "Retrieves order details") and accept similar identifier formats. What's the most effective first step?

• A. Add few-shot examples to the system prompt demonstrating correct tool selection patterns, with 5–8 examples showing order-related queries routing to `lookup_order`.
• B. Expand each tool's description to include input formats it handles, example queries, edge cases, and boundaries explaining when to use it versus similar tools.
• C. Implement a routing layer that parses user input before each turn and pre-selects the appropriate tool based on detected keywords and identifier patterns.
• D. Consolidate both tools into a single `lookup_entity` tool that accepts any identifier and internally determines which backend to query.

📋 Scenario: Scenario 3 — Multi-Agent Research System

85% of synthesis verifications are simple fact-checks requiring 2–3 coordinator round trips and adding 40% latency. The other 15% require deep investigation. How do you reduce overhead while maintaining reliability?

• A. Give the synthesis agent a scoped `verify_fact` tool for simple lookups, while complex verifications continue delegating to the web search agent through the coordinator.
• B. Have the synthesis agent accumulate all verification needs and return them as a batch to the coordinator at the end of its pass.
• C. Give the synthesis agent access to all web search tools so it can handle any verification need directly without round-trips through the coordinator.
• D. Have the web search agent proactively cache extra context around each source during initial research, anticipating what the synthesis agent might need.

📋 Scenario: Multi-Agent Research System

You want to expose a static library of 200 curated research documents that agents can browse and retrieve by topic — without transmitting all documents in every tool call. Which MCP capability fits?

• A. MCP Resources — expose documents as a catalogued resource list that agents can page through and retrieve on demand.
• B. MCP Tools — expose a search_documents tool that embeds all 200 documents in its description.
• C. Inject all documents into the system prompt for every agent session.
• D. Create one tool per document — 200 individual MCP tools.

📋 Scenario: Developer Productivity with Claude

You need an MCP server that provides personal access tokens but only for your own developer machine — not shared with the team. Where should you configure it?

• A. In ~/.claude.json — user-scoped configuration that is never committed to version control.
• B. In the project's .mcp.json so all teammates automatically get it.
• C. In CLAUDE.md at the project root.
• D. Hard-code the token in the MCP server source code.

📋 Scenario: Customer Support Resolution Agent

A refund tool times out due to a downstream payment gateway being temporarily unavailable. How should the tool's error response be structured to support correct agent recovery?

• A. Return isError: true, errorCategory: "transient", isRetryable: true, and a description so the agent knows to retry after a delay.
• B. Return a success response with a 'processing' status so the agent doesn't retry.
• C. Throw an unhandled exception so the agentic loop halts.
• D. Return isError: true, isRetryable: false — the agent should never retry tool calls.

📋 Scenario: Structured Data Extraction

You have 25 extraction tools (parse_invoice, parse_receipt, parse_contract …). Performance metrics show tool selection accuracy declining. What is the most likely cause and remedy?

• A. Too many tools degrade selection accuracy; consolidate similar tools or use a two-stage routing approach — first classify document type, then select the matching tool.
• B. Add more detailed descriptions to each of the 25 tools to help the model differentiate them.
• C. Switch to a larger model with a bigger context window to handle 25 tools.
• D. Alphabetically sort the tools so the model encounters them in a predictable order.

📋 Scenario: Multi-Agent Research System

A coordinator calls an MCP search tool that returns zero results for a valid query. How should the tool distinguish this from an error condition?

• A. Return a successful response with an empty results array and a 'no_results_found' status — it's not an error, just a valid empty set.
• B. Return isError: true so the agent knows to retry with a different query.
• C. Throw a 404 exception since the resource was not found.
• D. Return a null response body to signal no results.

📋 Scenario: Developer Productivity with Claude

You need to force the agent to call the 'run_linter' tool at the start of every code review session, before any other tools. How do you enforce this for the first turn?

• A. Set tool_choice to {type: "tool", name: "run_linter"} on the first API call so the model must invoke that specific tool.
• B. Set tool_choice: "auto" and add 'always start with the linter' to the system prompt.
• C. List run_linter first in the tools array — order determines invocation sequence.
• D. Set tool_choice: "any" so the model is forced to call some tool.

📋 Scenario: Customer Support Resolution Agent

An MCP tool attempts to access a customer record but the agent lacks the required permission scope. How should the tool communicate this so the agent escalates correctly?

• A. Return isError: true, errorCategory: "permission_denied", isRetryable: false, and a description explaining the missing scope.
• B. Return isError: true, isRetryable: true so the agent tries again with higher privileges.
• C. Return empty data so the agent handles the absence gracefully.
• D. Return isError: true with no additional fields — the agent should infer the cause.

📋 Scenario: Structured Data Extraction

Your data extraction agent must only use the specialized extraction tools — never the general-purpose Bash or WebFetch tools available in the environment. How do you enforce this per-agent restriction?

• A. Configure allowedTools in the agent's settings to list only the extraction tools — unlisted tools are never exposed to that agent.
• B. Add a system prompt instruction: 'only use extraction tools, never Bash or WebFetch.'
• C. List Bash and WebFetch last in the tools array so they're less likely to be selected.
• D. Delete Bash and WebFetch from the global environment for all agents.

📋 Scenario: Customer Support Resolution Agent

Two tools have very similar descriptions — lookup_customer_by_email and lookup_customer_by_phone. The model almost always picks lookup_customer_by_email even when a phone number is provided. Best fix?

• A. Update each tool description to explicitly state when to use it: 'Use this tool ONLY when you have an email address. If you have a phone number, use lookup_customer_by_phone.'
• B. Rename both tools with less similar names like 'tool_a' and 'tool_b'.
• C. Merge them into a single lookup_customer tool that accepts both input types.
• D. Use tool_choice: "any" to let the model decide.

📋 Scenario: Developer Productivity with Claude

An MCP server runs in the user's home directory (~/.claude/) and provides access to the developer's personal GitHub PAT. Which security concern does this placement address?

• A. It keeps personal credentials machine-local and out of version-controlled project files, preventing accidental exposure through the repository.
• B. It makes the server faster because home directories are cached.
• C. It automatically encrypts the PAT at rest.
• D. It restricts the MCP server to read-only operations only.

📋 Scenario: Code Generation with Claude Code

You want a custom /review slash command available to every developer automatically when they clone or pull the repository. Where do you create it?

• A. In .claude/commands/ in the project repository.
• B. In ~/.claude/commands/ in each developer's home directory.
• C. In the CLAUDE.md file at the project root.
• D. In a .claude/config.json file with a commands array.

📋 Scenario: Code Generation with Claude Code

Test files are spread throughout the codebase (e.g., Button.test.tsx beside Button.tsx) and you want identical test conventions applied automatically regardless of location. Most maintainable approach?

• A. Create a file in .claude/rules/ with YAML frontmatter paths glob (e.g., paths: [\
• B. ]).
• C. Consolidate all conventions in the root CLAUDE.md under headers and rely on inference.
• D. Create skills in .claude/skills/ for each code type.

📋 Scenario: Code Generation with Claude Code

A new teammate reports that instructions you rely on aren't being applied for them. You had placed them in ~/.claude/CLAUDE.md. Why, and what's the fix?

• A. User-level config isn't shared via version control; move shared instructions to project-level (.claude/CLAUDE.md or root CLAUDE.md).
• B. Their Claude Code version is outdated; have them upgrade.
• C. CLAUDE.md must be renamed to RULES.md to be picked up.
• D. They need to run /compact before the config loads.

📋 Scenario: Code Generation with Claude Code

Your root CLAUDE.md has grown huge and unwieldy across many topics. What is a recommended way to keep it modular?

• A. Split into focused topic files in .claude/rules/ (e.g., testing.md, api-conventions.md) and/or use @import to reference external standards files.
• B. Delete most of it and rely on the model to infer conventions.
• C. Duplicate the whole file into each subdirectory.
• D. Move everything into a single slash command.

📋 Scenario: Code Generation with Claude Code

You inspect inconsistent behavior across sessions and suspect the wrong memory files are loading. Which command helps you verify what memory is active?

• A. /memory
• B. /compact
• C. /resume
• D. /rules

📋 Scenario: Developer Productivity with Claude

You have a codebase-analysis skill that produces very verbose output you don't want polluting the main conversation. Which SKILL.md frontmatter option helps?

• A. context: fork — run the skill in an isolated sub-agent context.
• B. allowed-tools — restrict which tools the skill can use.
• C. argument-hint — prompt for parameters.
• D. paths — scope the skill to certain files.

📋 Scenario: Developer Productivity with Claude

When should you prefer a Skill over putting guidance in CLAUDE.md?

• A. When the guidance is task-specific and should be invoked on demand, rather than an always-loaded universal standard.
• B. When the guidance must apply to every single prompt automatically.
• C. When you want the guidance shared with teammates but never invoked.
• D. Skills and CLAUDE.md are interchangeable in all cases.

📋 Scenario: Code Generation with Claude Code

You must restructure a monolith into microservices — dozens of files, multiple valid approaches, architectural decisions. Which mode should you use?

• A. Plan mode, to explore the codebase and design the approach before making changes.
• B. Direct execution, making changes incrementally to let boundaries emerge.
• C. Direct execution with exhaustive upfront instructions.
• D. Start in direct execution and switch to plan mode only if complexity appears.

📋 Scenario: Code Generation with Claude Code

Which task is the best fit for direct execution rather than plan mode?

• A. Adding a single date-validation conditional to one function with a clear scope.
• B. Migrating a library across 45+ files.
• C. Choosing between two integration approaches with different infrastructure needs.
• D. Restructuring service boundaries in a monolith.

📋 Scenario: Claude Code for Continuous Integration

Your CI job runs `claude \"Analyze this PR for security issues\"` but hangs waiting for interactive input. Correct fix?

• A. Add the -p (or --print) flag to run in non-interactive mode.
• B. Set CLAUDE_HEADLESS=true before running.
• C. Redirect stdin from /dev/null.
• D. Add a --batch flag.

📋 Scenario: Claude Code for Continuous Integration

You need machine-parseable findings from CI-invoked Claude Code so a script can post inline PR comments. Which flags help?

• A. --output-format json together with --json-schema to enforce structured output.
• B. --verbose to print more detail.
• C. --pretty to format the output as a table.
• D. --interactive to allow the reviewer to refine results.

📋 Scenario: Claude Code for Continuous Integration

After new commits, you re-run the automated review and it re-posts issues that were already flagged before. How do you avoid duplicate comments?

• A. Include prior review findings in context and instruct Claude to report only new or still-unaddressed issues.
• B. Disable the review on all but the first commit.
• C. Switch to a larger-context model.
• D. Run the review three times and only post issues appearing in all runs.

📋 Scenario: Scenario 2 — Code Generation with Claude Code

You want to create a custom `/review` slash command that runs your team's standard code review checklist. This command should be available to every developer when they clone or pull the repository. Where should you create this command file?

• A. In the `.claude/commands/` directory in the project repository.
• B. In `~/.claude/commands/` in each developer's home directory.
• C. In the `CLAUDE.md` file at the project root.
• D. In a `.claude/config.json` file with a `commands` array.

📋 Scenario: Scenario 2 — Code Generation with Claude Code

You've been assigned to restructure the team's monolithic application into microservices. This will involve changes across dozens of files and requires decisions about service boundaries and module dependencies. Which approach should you take?

• A. Enter plan mode to explore the codebase, understand dependencies, and design an implementation approach before making changes.
• B. Start with direct execution and make changes incrementally, letting the implementation reveal the natural service boundaries.
• C. Use direct execution with comprehensive upfront instructions detailing exactly how each service should be structured.
• D. Begin in direct execution mode and only switch to plan mode if you encounter unexpected complexity during implementation.

📋 Scenario: Scenario 2 — Code Generation with Claude Code

Test files are spread throughout the codebase alongside the code they test (e.g., `Button.test.tsx` next to `Button.tsx`). You want all tests to follow the same conventions regardless of location. What's the most maintainable way to ensure Claude automatically applies the correct conventions?

• A. Create rule files in `.claude/rules/` with YAML frontmatter specifying glob patterns to conditionally apply conventions based on file paths.
• B. Consolidate all conventions in the root `CLAUDE.md` file under headers for each area, relying on Claude to infer which section applies.
• C. Create skills in `.claude/skills/` for each code type that include the relevant conventions in their SKILL.md files.
• D. Place a separate `CLAUDE.md` file in each subdirectory containing that area's specific conventions.

📋 Scenario: Scenario 5 — Claude Code for CI/CD

Your pipeline script runs `claude "Analyze this PR for security issues"` but the job hangs indefinitely — Claude Code is waiting for interactive input. What's the correct fix?

• A. Add the `-p` flag: `claude -p "Analyze this PR for security issues"`
• B. Set the environment variable `CLAUDE_HEADLESS=true` before running the command.
• C. Redirect stdin from /dev/null: `claude "..." < /dev/null`
• D. Add the `--batch` flag: `claude --batch "..."`

📋 Scenario: Code Generation with Claude Code

You are creating a personal slash command for refactoring that should only be available on your own machine — teammates should not see or use it. Where do you create it?

• A. In ~/.claude/commands/ — personal user-level commands that are not version-controlled.
• B. In .claude/commands/ in the project repo and add it to .gitignore.
• C. In the project CLAUDE.md under a /commands section.
• D. In .claude/skills/ with context: fork to isolate it.

📋 Scenario: Claude Code for Continuous Integration

Your CI pipeline needs to run Claude Code and output structured JSON that a downstream script will parse to post inline PR comments. Which exact flags do you use?

• A. -p --output-format json --json-schema findings.schema.json
• B. --batch --json
• C. --headless --format=json
• D. -p --verbose --pretty

📋 Scenario: Developer Productivity with Claude

A skill runs database profiling and produces 3,000 lines of query statistics that would flood the main session's context window. Which SKILL.md frontmatter setting isolates this output?

• A. context: fork — runs the skill in an isolated sub-session so its verbose output never appears in the main context.
• B. allowed-tools: [] — prevents any tool use, limiting output size.
• C. argument-hint: "table name" — prompts for filtered input to reduce output.
• D. paths: ["db/**"] — limits which files the skill can read.

📋 Scenario: Code Generation with Claude Code

You want to enforce specific API naming conventions (e.g., use snake_case for all REST endpoints) only when files in src/api/ are modified, not for other files in the repo. Best mechanism?

• A. Create a rule file in .claude/rules/ with YAML frontmatter: paths: ["src/api/**"] containing the naming conventions.
• B. Add the rule to the root CLAUDE.md with an 'only for src/api/' header.
• C. Place a CLAUDE.md directly inside src/api/ with the naming rule.
• D. Create a skill the developer must invoke manually before editing API files.

📋 Scenario: Claude Code for Continuous Integration

A previous CI review session was interrupted mid-task. You want to resume from the exact point it stopped without re-running completed steps. Which flag enables this?

• A. --resume with the prior session ID to continue from the last checkpoint.
• B. --continue — restores the session from a server-side cache.
• C. --replay to regenerate the prior session's tool calls.
• D. Re-run the original command — Claude Code automatically deduplicates completed steps.

📋 Scenario: Code Generation with Claude Code

Your team has a sub-team working exclusively on the payments/ directory that wants its own specialized context loaded automatically without affecting other developers. Which mechanism achieves this?

• A. Place a CLAUDE.md directly inside payments/ — it loads automatically when any file in that directory is in scope.
• B. Add all payments context to the root CLAUDE.md with a 'Payments Team' header.
• C. Create a shared Payments slash command teammates must invoke manually.
• D. Create a .env file inside payments/ with context variables.

📋 Scenario: Code Generation with Claude Code

You are planning to migrate the team's auth library from v1 to v2, which involves choosing between two different approach patterns and modifying 30+ files. Which mode and sequence is correct?

• A. Enter plan mode first to explore the codebase, compare migration approaches, and get approval on the plan — then execute in direct mode.
• B. Execute directly and use /compact mid-task if context runs out.
• C. Run the migration in parallel using multiple direct-mode sessions.
• D. Use direct mode with comprehensive instructions — plan mode is for design, not migrations.

📋 Scenario: Claude Code for Continuous Integration

Your CI security review runs claude -p "Review PR for vulnerabilities" and produces findings, but subsequent runs on updated code re-report the same already-fixed issues. What should you include to prevent duplicate reports?

• A. Pass the previous run's findings as context and instruct Claude to report only new findings not yet addressed.
• B. Use --resume with the last session ID to continue from the previous run.
• C. Run only once per PR — disable subsequent runs after the first.
• D. Increase max_tokens so all findings fit in one pass.

📋 Scenario: Developer Productivity with Claude

You have a skill that generates API documentation. It should only be able to use the Read tool — never Write or Bash. How do you enforce this in SKILL.md?

• A. Set allowed-tools: ["Read"] in the SKILL.md frontmatter — the skill can only invoke listed tools.
• B. Add a system prompt instruction: 'Do not use Write or Bash tools in this skill.'
• C. Use context: fork — forked skills automatically have read-only access.
• D. Delete Write and Bash from the global environment before invoking the skill.

📋 Scenario: Code Generation with Claude Code

The root CLAUDE.md has grown to 4,000 words covering testing, API conventions, security standards, and deployment guidelines. Which refactoring approach is recommended?

• A. Move each topic into a focused file in .claude/rules/ (e.g., testing.md, api-conventions.md) and/or use @import in CLAUDE.md to reference them.
• B. Keep it as-is — large CLAUDE.md files perform better because context is more complete.
• C. Split it into separate CLAUDE.md files for each section and place them in the root directory with sequential naming.
• D. Summarize each section into one sentence to reduce token load.

Assistant-turn prefills (a final `assistant` message that Claude continues) now return a 400 on the 4.6/4.7/4.8 family and Fable 5. What is the recommended replacement for forcing JSON output?

• A. A `temperature: 0` setting
• B. `output_config.format` with a JSON schema (structured outputs)
• C. A stop sequence of `}`
• D. Repeating the schema three times in the user turn

On Opus 4.6+, a prompt says "CRITICAL: You MUST use this tool." The model over-triggers the tool. What is the recommended fix?

• A. Add more guardrails and stronger language
• B. Dial the language back to "Use this tool when…"
• C. Remove the tool entirely
• D. Lower `max_tokens`

Which structured-outputs constraint is _NOT_ supported by the JSON schema validator?

• A. `enum` and `const`
• B. `anyOf` / `$ref`
• C. Numeric bounds like `minimum` / `maximum`
• D. `additionalProperties: false`

Structured outputs (`output_config.format`) are incompatible with which feature?

• A. Streaming
• B. Citations (returns a 400)
• C. Extended/adaptive thinking
• D. The Batches API

To count tokens for a Claude prompt accurately, you should…

• A. Use `tiktoken`
• B. Use the `count_tokens` endpoint with the same model ID
• C. Divide character count by 4
• D. Use a fixed 0.75 words-per-token ratio

📋 Scenario: Claude Code for Continuous Integration

Your automated code review flags too many false positives on comment accuracy, eroding developer trust. Which prompt change best improves precision?

• A. Replace vague guidance with explicit criteria, e.g., 'flag comments only when the claimed behavior contradicts the actual code behavior.'
• B. Add the instruction 'be conservative and only report high-confidence findings.'
• C. Tell the model to 'double-check' each finding before reporting.
• D. Lower max_tokens so it reports fewer items.

📋 Scenario: Claude Code for Continuous Integration

One review category (style nits) has a very high false-positive rate and is undermining trust in the accurate categories. Pragmatic short-term action?

• A. Temporarily disable the high-false-positive category while you refine its prompt, preserving trust in the accurate categories.
• B. Keep it enabled but tell developers to ignore that category.
• C. Delete the entire review system and start over.
• D. Increase severity of all findings so developers pay attention.

📋 Scenario: Structured Data Extraction

Detailed prose instructions still produce inconsistently formatted extraction output. Which technique most reliably improves consistency?

• A. Provide 2-4 targeted few-shot examples demonstrating the exact desired output format and reasoning.
• B. Increase the temperature so the model is more creative.
• C. Repeat the instructions three times in the prompt.
• D. Add 'be consistent' at the end of the prompt.

📋 Scenario: Structured Data Extraction

You need guaranteed schema-compliant JSON with zero syntax errors from an extraction task. Best approach?

• A. Use tool_use with a strict JSON schema and read the structured data from the tool_use response.
• B. Ask the model to 'return valid JSON only' in plain text and parse the string.
• C. Have the model return Markdown and convert it to JSON in post-processing.
• D. Lower max_tokens to force compact JSON.

📋 Scenario: Structured Data Extraction

Even with a strict JSON schema via tool use, you still see line items that don't sum to the stated total. Why?

• A. Strict schemas guarantee syntactic validity but not semantic correctness; you need semantic validation for value errors.
• B. The schema must be malformed; regenerate it.
• C. tool_choice was set to 'auto' instead of 'any'.
• D. The model ran out of tokens mid-object.

📋 Scenario: Structured Data Extraction

Source documents sometimes omit a field entirely, and the model fabricates values to fill required fields. How should you design the schema?

• A. Make fields that may be absent optional/nullable so the model returns null instead of fabricating values.
• B. Mark every field required so the model always fills them.
• C. Add a default fake value for missing fields.
• D. Remove those fields from the schema entirely.

📋 Scenario: Structured Data Extraction

For an extensible category field where new, unforeseen categories may appear, what schema pattern is recommended?

• A. An enum with an 'other' value plus a detail string field (and values like 'unclear' for ambiguity).
• B. A free-text string with no enum at all.
• C. A fixed enum that rejects anything unlisted.
• D. A boolean per known category.

📋 Scenario: Structured Data Extraction

A schema-validation step fails on an extraction. When is a retry-with-error-feedback loop likely to succeed versus fail?

• A. It succeeds for format/structural errors (append the specific error and retry) but fails when the required information is simply absent from the source.
• B. It always succeeds because Claude can infer any missing value.
• C. It always fails because retries never help.
• D. It succeeds only if you switch to a larger model.

📋 Scenario: Structured Data Extraction

You must process 100,000 documents for a weekly audit report with no strict latency requirement, and want to cut cost. Which approach fits?

• A. Use the Message Batches API (about 50% cheaper, up to 24-hour window) since the workload is latency-tolerant.
• B. Use synchronous API calls in a tight loop to finish as fast as possible.
• C. Use the batch API for a blocking pre-merge check instead.
• D. Avoid batching because it can't correlate responses.

📋 Scenario: Claude Code for Continuous Integration

A model reviewing the very code it just generated in the same session misses subtle bugs. What most improves detection?

• A. Use a second, independent Claude instance (without the generator's reasoning context) to review the code.
• B. Add 'please review carefully' to the same session.
• C. Enable extended thinking in the same generating session.
• D. Ask the same session to rate its own confidence.

📋 Scenario: Claude Code for Continuous Integration

A 14-file PR review done in one pass gives inconsistent depth and even contradictory findings (flagging a pattern in one file, approving identical code in another). Best restructuring?

• A. Split into per-file passes for local issues, then a separate integration pass for cross-file data flow.
• B. Require developers to submit no more than 3-4 files per PR.
• C. Switch to a larger-context model to fit all files at once.
• D. Run three full-PR passes and flag only issues found in 2 of 3.

📋 Scenario: Scenario 5 — Claude Code for CI/CD

Two workflows: (1) a blocking pre-merge check that must complete before developers can merge; (2) a technical debt report generated overnight. Your manager proposes switching both to the Message Batches API for 50% cost savings. How should you evaluate this?

• A. Use batch processing for the technical debt reports only; keep real-time calls for pre-merge checks.
• B. Switch both workflows to batch processing with status polling to check for completion.
• C. Keep real-time calls for both workflows to avoid batch result ordering issues.
• D. Switch both to batch processing with a timeout fallback to real-time if batches take too long.

📋 Scenario: Scenario 5 — Claude Code for CI/CD

A PR modifies 14 files (duplicate of D4-Q11 — official exam sample). Single-pass review produces inconsistent depth, missed bugs, and contradictory feedback (flagging a pattern in one file while approving identical code elsewhere). How should you restructure the review?

• A. Split into focused passes: analyze each file individually for local issues, then run a separate integration-focused pass examining cross-file data flow.
• B. Require developers to split large PRs into smaller submissions of 3–4 files before automated review runs.
• C. Switch to a higher-tier model with a larger context window to give all 14 files adequate attention in one pass.
• D. Run three independent review passes on the full PR and only flag issues that appear in at least two of the three runs.

📋 Scenario: Structured Data Extraction

You need to extract structured data from 50,000 legal contracts for a compliance audit. The audit is non-blocking and results are needed within 24 hours. Which approach best balances cost and feasibility?

• A. Submit all 50,000 documents to the Message Batches API for ~50% cost savings within the 24-hour processing window.
• B. Use real-time API calls in a loop — batch processing can't handle 50,000 documents.
• C. Use the Message Batches API but expect multi-turn conversations for clarification per document.
• D. Submit each document as part of a multi-turn batch conversation to improve extraction quality.

📋 Scenario: Structured Data Extraction

You submitted a batch of 500 extraction requests. Now you need to match each response back to the original document it processed. Which mechanism enables this correlation?

• A. The custom_id field you set on each request — it's echoed verbatim in each response.
• B. The batch API returns responses in the same order as submitted — match by array index.
• C. The API generates a sequential integer ID per response starting from 1.
• D. Store the document content hash locally and match by content.

📋 Scenario: Structured Data Extraction

Records from before 1990 often have no 'secondary_contact_phone' field — it didn't exist. Your extraction schema has secondary_contact_phone as required: true, causing fabricated phone numbers. Fix?

• A. Make secondary_contact_phone nullable and optional (required: false) so the model returns null instead of fabricating a value.
• B. Keep it required and add a default value of '000-000-0000' for unknown numbers.
• C. Remove the field from the schema entirely — don't collect data that isn't always present.
• D. Add a note in the system prompt: 'If secondary_contact_phone is missing, leave it blank.'

📋 Scenario: Claude Code for Continuous Integration

An extraction fails schema validation — a date field has format "June 2, 2024" but the schema expects ISO-8601 "2024-06-02". Should you retry, and if so, how?

• A. Yes — retry with the validation error appended to the conversation ('date must be ISO-8601 format: YYYY-MM-DD, got "June 2, 2024"') so the model can correct the format.
• B. No — schema validation failures always indicate missing source data and retrying won't help.
• C. Retry with higher temperature so the model tries a different format.
• D. Switch to a larger model — format errors indicate insufficient capability.

📋 Scenario: Structured Data Extraction

Prose instructions for extracting contract 'party types' result in inconsistent output: sometimes 'Buyer', sometimes 'buyer', sometimes 'BUYER', sometimes 'purchasing_party'. Best fix?

• A. Add 2-4 few-shot examples showing exactly how different party types should appear in the output, with the exact casing and phrasing required.
• B. Add 'be consistent' and 'use title case' to the instructions.
• C. Post-process outputs with a string normalization function.
• D. Increase max_tokens so the model has room to be more precise.

📋 Scenario: Claude Code for Continuous Integration

Your CI review prompt says 'flag potential security issues.' It generates too many noisy false positives. Which prompt change most improves precision without missing real issues?

• A. Replace 'potential security issues' with explicit criteria: 'flag only SQL injection risks, hardcoded credentials, and unvalidated user input paths that directly affect data mutation.'
• B. Add 'only report high-confidence, actionable findings' to the prompt.
• C. Reduce temperature to zero to eliminate false positives.
• D. Use a higher-tier model — it will self-calibrate confidence.

📋 Scenario: Structured Data Extraction

A free-text extraction produces correct data 95% of the time, but 5% has syntax errors (unclosed braces, missing quotes). What is the most reliable way to eliminate the 5%?

• A. Switch to tool_use with a strict JSON schema — the schema constraint eliminates syntax errors entirely.
• B. Add 'always return valid JSON' to the system prompt.
• C. Use a JSON repair library to fix malformed output in post-processing.
• D. Add temperature: 0 to prevent stochastic JSON errors.

📋 Scenario: Structured Data Extraction

You receive valid JSON with correct syntax from tool_use, but a 'total_amount' field is $500 while the sum of line items totals $450. What type of validation is needed and what does tool_use guarantee?

• A. This is a semantic validation failure — tool_use guarantees syntactic validity only; you need application-level cross-field validation for semantic consistency.
• B. The schema is incorrect — add a constraint to enforce total_amount equals sum of line items.
• C. Use a larger model — the mismatch is a capability limitation.
• D. This indicates the source document was corrupted — no validation can catch this.

📋 Scenario: Claude Code for Continuous Integration

A code review agent flags a security vulnerability in file A but approves identical code in file B in the same pass. Root cause and remedy?

• A. Attention dilution from reviewing too many files in a single pass; split into per-file passes to ensure consistent depth.
• B. The model detected a real difference between file A and file B that makes B safe.
• C. The model ran out of max_tokens mid-review — increase the limit.
• D. The system prompt conflicted with the review instructions — check for contradictions.

📋 Scenario: Multi-Agent Research System

You need to categorize research documents into one of 12 known topic areas, but occasionally a document genuinely spans two topics and others don't fit any category. What schema design pattern handles this?

• A. An enum of 12 topics + 'multi_topic' + 'other', with a detail string for 'other' documents and a secondary_topic nullable field for multi-topic ones.
• B. A free-text category field — let the model describe each document's topic in natural language.
• C. A strict enum of exactly the 12 topics — force every document into one category.
• D. 12 boolean fields, one per category — set multiple to true for multi-topic documents.

What is the single invariant that governs all prompt caching behavior?

• A. Caching is a fuzzy semantic match
• B. Caching is a prefix match — any byte change in the prefix invalidates everything after it
• C. Only the system prompt is cached
• D. The cache is keyed by conversation ID

You repeat identical-prefix requests but `cache_read_input_tokens` is always zero. The most likely cause is…

• A. A silent invalidator (e.g. `datetime.now()` in the system prompt)
• B. Caching is disabled by default
• C. The model doesn't support caching
• D. You need a beta header

What is the maximum number of `cache_control` breakpoints per request?

• A. 1
• B. 4
• C. 10
• D. Unlimited

Which change does _NOT_ invalidate the tools+system cache tier?

• A. Adding or reordering a tool definition
• B. Switching the model
• C. Changing `tool_choice` or toggling `thinking`
• D. Editing the system prompt content

Cache _writes_ cost more than base input. What is the multiplier for the 5-minute TTL?

• A. ~0.1×
• B. ~1.25×
• C. ~2×
• D. ~5×

On Claude Opus 4.8, how do you inject an operator instruction mid-conversation _without_ invalidating the cached prefix?

• A. Edit the top-level `system` field
• B. Append a `{"role": "system", ...}` message to `messages[]`
• C. Prepend a new tool
• D. Restart the conversation

What is the key difference between compaction and context editing?

• A. They are two names for the same feature
• B. Compaction _summarizes_ earlier context; context editing _clears/prunes_ old tool results or thinking
• C. Compaction is client-side; context editing is server-side
• D. Context editing summarizes; compaction deletes

When using server-side compaction, what must you append back to `messages` on each turn?

• A. Only the extracted text string
• B. The full `response.content`, including compaction blocks
• C. Nothing — the server tracks it
• D. A summary you write yourself

Which context-editing strategy type clears old tool results?

• A. `compact_20260112`
• B. `clear_tool_uses_20250919`
• C. `summarize_tools`
• D. `clear_all`

Which mechanism is appropriate when state must persist _across sessions_, not just within one conversation?

• A. Compaction
• B. Context editing
• C. Memory (a memory directory / memory tool)
• D. A larger `max_tokens`

📋 Scenario: Customer Support Resolution Agent

In long conversations, progressive summarization is dropping specific numbers (refund amounts, dates, order IDs) into vague phrasing, causing errors. Best mitigation?

• A. Extract transactional facts into a persistent 'case facts' block included in each prompt, outside the summarized history.
• B. Summarize more aggressively so less detail is lost.
• C. Disable summarization and always resend the entire raw transcript.
• D. Ask the customer to repeat key numbers each turn.

📋 Scenario: Multi-Agent Research System

Aggregated inputs are large, and the model reliably uses the beginning and end but omits findings from the middle. What technique addresses this 'lost in the middle' effect?

• A. Place key findings summaries at the start and use explicit section headers to organize detailed results.
• B. Randomly shuffle the content so no position is favored.
• C. Compress the middle sections into a single sentence.
• D. Duplicate the entire input twice.

📋 Scenario: Customer Support Resolution Agent

Each order lookup returns 40+ fields but only about 5 are relevant to returns, and these verbose results accumulate and consume context. Best practice?

• A. Trim verbose tool outputs to only the relevant fields before they accumulate in context.
• B. Keep all fields in case they're needed later.
• C. Summarize the whole conversation after every tool call.
• D. Increase max_tokens to make room for the extra fields.

📋 Scenario: Customer Support Resolution Agent

The agent achieves only 55% first-contact resolution: it escalates straightforward cases and tries to autonomously handle ones needing policy exceptions. Most effective first fix for escalation calibration?

• A. Add explicit escalation criteria to the system prompt with few-shot examples of when to escalate versus resolve.
• B. Have the agent self-report a 1-10 confidence score and escalate below a threshold.
• C. Train a separate classifier on historical tickets to predict escalation.
• D. Use sentiment analysis to escalate on negative sentiment.

📋 Scenario: Customer Support Resolution Agent

A customer explicitly and immediately demands to speak to a human, though the issue looks resolvable. Correct behavior?

• A. Honor the explicit request for a human immediately, without first attempting investigation.
• B. Ignore the request and resolve it autonomously since it's simple.
• C. Ask three clarifying questions before deciding.
• D. Escalate only if the customer repeats the demand twice more.

📋 Scenario: Customer Support Resolution Agent

A lookup returns multiple customer matches for the provided name. What should the agent do?

• A. Ask for additional identifiers to disambiguate rather than selecting one heuristically.
• B. Pick the most recently active account.
• C. Pick the first result returned.
• D. Escalate to a human immediately.

📋 Scenario: Multi-Agent Research System

A subagent's search times out. Which error-propagation approach best enables the coordinator to recover intelligently?

• A. Return structured error context: failure type, attempted query, partial results, and possible alternatives.
• B. Retry internally with backoff, then return a generic 'search unavailable' after exhausting retries.
• C. Catch the timeout and return an empty result marked successful.
• D. Propagate the exception to a top-level handler that terminates the whole workflow.

📋 Scenario: Developer Productivity with Claude

During a long codebase exploration, the model starts giving inconsistent answers and referencing 'typical patterns' instead of the specific classes it found earlier. Best countermeasures?

• A. Maintain scratchpad files of key findings and delegate verbose sub-investigations to subagents, injecting summaries into later phases.
• B. Keep going in the same session and re-read every file each time.
• C. Raise the temperature to encourage more detailed answers.
• D. Ignore it, since context degradation cannot be mitigated.

📋 Scenario: Structured Data Extraction

Your extraction pipeline reports 97% aggregate accuracy, and you're tempted to reduce human review. What is the key risk and mitigation?

• A. Aggregate accuracy can mask poor performance on specific document types or fields; segment accuracy by type/field and use stratified sampling before automating.
• B. 97% is high enough to fully automate with no further checks.
• C. Only overall accuracy matters, so no segmentation is needed.
• D. Route every extraction to human review regardless of confidence.

📋 Scenario: Multi-Agent Research System

Two credible sources report different statistics for the same metric. How should the synthesis output handle this?

• A. Annotate the conflict with source attribution and (where relevant) publication dates, rather than arbitrarily picking one value.
• B. Silently choose the higher number.
• C. Average the two values without noting the conflict.
• D. Drop both values to avoid confusion.

📋 Scenario: Scenario 1 — Customer Support Resolution Agent

Your agent achieves 55% first-contact resolution, well below the 80% target. Logs show it escalates straightforward cases (standard damage replacements with photo evidence) while attempting to autonomously handle complex situations requiring policy exceptions. What's the most effective way to improve escalation calibration?

• A. Add explicit escalation criteria to your system prompt with few-shot examples demonstrating when to escalate versus resolve autonomously.
• B. Have the agent self-report a confidence score (1–10) before each response and automatically route requests to humans when confidence falls below a threshold.
• C. Deploy a separate classifier model trained on historical tickets to predict which requests need escalation before the main agent begins processing.
• D. Implement sentiment analysis to detect customer frustration levels and automatically escalate when negative sentiment exceeds a threshold.

📋 Scenario: Scenario 3 — Multi-Agent Research System

The web search subagent times out. You need to design how this failure information flows back to the coordinator. Which error propagation approach best enables intelligent recovery?

• A. Return structured error context to the coordinator including the failure type, the attempted query, any partial results, and potential alternative approaches.
• B. Implement automatic retry logic with exponential backoff within the subagent, returning a generic "search unavailable" status only after all retries are exhausted.
• C. Catch the timeout within the subagent and return an empty result set marked as successful.
• D. Propagate the timeout exception directly to a top-level handler that terminates the entire research workflow.

📋 Scenario: Multi-Agent Research System

A 15-source research synthesis at position 15–35 in a 50-source aggregate is being ignored in the final output. What is the cause and the recommended mitigation?

• A. Lost-in-the-middle effect — the model under-weights content far from the start and end of a large context. Mitigate by placing key summaries at the start and using explicit section headers throughout.
• B. The sources are duplicates — deduplicate before synthesis.
• C. The sources at positions 15–35 contain lower-quality information — the model correctly de-prioritizes them.
• D. The model's context window was exceeded at source 14 — the rest was truncated.

📋 Scenario: Developer Productivity with Claude

A long codebase exploration session crashes mid-task. On restart, the agent has no memory of which files were already analyzed. What architectural feature prevents this data loss?

• A. State persistence to a scratchpad or checkpoint file after each analysis step, so recovery can resume from the last saved checkpoint.
• B. Increase max_tokens — larger outputs are less likely to be lost.
• C. The model will remember previously analyzed files because conversation history is server-stored.
• D. Re-run from the beginning — reanalysis is fast because Claude Code caches file reads.

📋 Scenario: Customer Support Resolution Agent

An agent processes support tickets from three different product lines. Tickets from Product C are consistently handled incorrectly, but the other two lines are fine. You have 97% overall accuracy. What does this imply about evaluation?

• A. Overall accuracy masks segment-specific failures — always evaluate accuracy per product/category/type, not just in aggregate.
• B. 97% overall accuracy is sufficient — Product C errors are within acceptable bounds.
• C. The agent should be replaced — 97% is too low for production use.
• D. The Product C tickets must be lower quality — fix the data, not the agent.

📋 Scenario: Multi-Agent Research System

After 200,000 tokens of research, the model begins citing 'common knowledge' for specific statistics it should be deriving from the collected sources. What context management technique should the coordinator apply?

• A. Run /compact to summarize the conversation history, then continue with the summary plus key claims in a fresh context window.
• B. Increase max_tokens to 500,000 to fit all research in context.
• C. Switch to a model with a 1M token context window and continue without intervention.
• D. Delete all tool results from the history to free context space.

📋 Scenario: Customer Support Resolution Agent

An order lookup tool returns full order objects with 60+ fields. Only 4 fields (order_id, status, amount, created_at) are ever used by the support agent. The agent's context fills up after 20 minutes due to accumulated tool results. Best fix?

• A. Project only the 4 needed fields from tool results before injecting them into the agent's context.
• B. Switch to a 1M token context model so the full objects fit.
• C. Run /compact after every tool call to keep context small.
• D. Modify the order API to return fewer fields for all callers.

📋 Scenario: Multi-Agent Research System

A research subagent encounters a claim from a source but cannot verify it (the source URL is inaccessible). What is the most accurate way to represent this in the synthesized output?

• A. Include the claim with an explicit annotation: 'unverified — source inaccessible at time of research' with the original source citation.
• B. Omit the claim entirely — unverified claims should never appear in synthesis.
• C. Present it as a confirmed fact — the user can verify later.
• D. Ask the user to provide the missing source URL before proceeding.

📋 Scenario: Customer Support Resolution Agent

The agent successfully identified the customer's issue and found a resolution tool, but the resolution tool requires a supervisor token the agent does not have. What is the correct behavior?

• A. Escalate to a human supervisor with full structured context: issue summary, proposed resolution, and the reason escalation is required (missing permission).
• B. Attempt the tool call anyway — the system will reject it and the agent can inform the customer.
• C. Tell the customer 'an error occurred' without further context.
• D. Abandon the ticket — the agent cannot resolve it.

📋 Scenario: Multi-Agent Research System

At what point should the research coordinator trigger /compact to avoid context degradation rather than simply running out of tokens?

• A. Proactively before token limits are reached — when output quality shows signs of degradation (vague answers, referencing general knowledge instead of collected sources).
• B. Only when the API returns a context-length exceeded error.
• C. After every third tool call to maintain a consistently small context.
• D. Never — /compact risks losing critical findings and should be avoided in research tasks.

📋 Scenario: Structured Data Extraction

You add a prompt caching breakpoint at the end of your 10,000-token system prompt that includes a step_id that changes each run. Subsequent requests always show zero cache_read_input_tokens. Why?

• A. The step_id changes the cached prefix bytes on every request, invalidating the cache. Move volatile fields (IDs, timestamps) after the last cache breakpoint.
• B. Prompt caching requires a beta header that is not being sent.
• C. The system prompt is below the 4,096-token minimum for caching.
• D. Caching only works for user-turn messages, not system prompts.

📋 Scenario: Customer Support Resolution Agent

A customer provides an order ID that looks valid but the lookup tool returns nothing. What should the agent do next?

• A. Ask the customer to verify the order ID, and offer alternative lookup options (e.g., email, phone) before escalating.
• B. Assume the order doesn't exist and tell the customer there's no record.
• C. Escalate to a human immediately — tool failures require human handling.
• D. Retry the lookup 5 times with the same ID.

Which model string should you use by default when the caller does not name a specific model?

• A. `claude-3-opus-20240229`
• B. `claude-opus-4-8`
• C. `claude-sonnet-5`
• D. `claude-opus-latest`

Which is Anthropic's most capable widely released model, intended for the most demanding reasoning and long-horizon agentic work?

• A. Claude Opus 4.8
• B. Claude Sonnet 5
• C. Claude Fable 5 (`claude-fable-5`)
• D. Claude Haiku 4.5

What is the context window of Claude Haiku 4.5, and how does it differ from the current Opus/Sonnet/Fable models?

• A. 1M tokens — identical to the others
• B. 200K tokens — the others offer 1M
• C. 128K tokens — the others offer 200K
• D. 64K tokens — the others offer 1M

A user wants to look up whether a specific model supports vision or a given effort level _at runtime_. What is the recommended approach?

• A. Hard-code a capability table in your app
• B. Query the Models API (`client.models.retrieve(id)` / `.list()`)
• C. Send a test message and inspect the error
• D. Parse the model ID string for capability hints

A request specifies `claude-3-5-sonnet-20241022` and returns a 404. What happened?

• A. The API key lacks permission
• B. The model is retired; migrate to `claude-sonnet-5`
• C. The date suffix is malformed
• D. The region does not host that model

Which statement about the Messages API conversation state is correct?

• A. The API stores conversation state; send only the newest turn
• B. The API is stateless; you resend the full conversation each request
• C. State persists for 24 hours keyed by conversation ID
• D. State persists only when caching is enabled

Which message arrangement is _invalid_ and returns a 400?

• A. First message has role `assistant`
• B. The messages array is empty
• C. `max_tokens` is missing
• D. All of the above

What is the recommended default `max_tokens` for a _streaming_ request, and why?

• A. ~256, to keep responses short
• B. ~16000, to avoid SDK HTTP timeouts
• C. ~64000, since timeouts aren't a concern when streaming
• D. Always the model maximum

A response returns `stop_reason: "pause_turn"` during server-side tool use. How do you continue?

• A. Append a user message saying "Continue."
• B. Re-send the user message plus the assistant response; the server resumes automatically
• C. Start a fresh conversation
• D. Increase `max_tokens` and retry from scratch

`response.stop_reason` is `"model_context_window_exceeded"`. What does it mean, distinct from `max_tokens`?

• A. The requested output cap was hit; raise `max_tokens`
• B. The context window limit was hit; compact or split the conversation
• C. The model refused the request
• D. A stop sequence was matched

Which SDK helper returns the fully-assembled message when you stream but don't need individual events?

• A. `.get_final_message()` / `.finalMessage()`
• B. `.collect()`
• C. Wrapping `.on()` events in a new Promise
• D. `.await_all()`

On Opus 4.8, what happens if you send `thinking: {type: "enabled", budget_tokens: 8000}`?

• A. It works as on older models
• B. It returns a 400 — `budget_tokens` is removed
• C. It silently falls back to adaptive thinking
• D. It disables thinking

On Opus 4.8/4.7, what happens if you omit the `thinking` field entirely?

• A. Adaptive thinking runs automatically
• B. The request runs _without_ thinking; set `{type: "adaptive"}` to enable
• C. The request returns a 400
• D. Thinking runs at maximum budget

Where does the `effort` parameter live, and what are its levels on Opus 4.8?

• A. Top-level; `low`/`high`
• B. Inside `output_config`; `low`/`medium`/`high`/`xhigh`/`max`
• C. Inside `thinking`; `1`–`10`
• D. A beta header

On Opus 4.8/4.7 and Fable 5, what is the default value of `thinking.display`, and what does it mean?

• A. `"summarized"` — a readable summary is returned
• B. `"omitted"` — thinking blocks stream with empty text
• C. `"full"` — the raw chain of thought is returned
• D. `"hidden"` — no thinking blocks appear at all

A "task budget" (beta) differs from `max_tokens` in that…

• A. It is an enforced per-response cap the model is unaware of
• B. It is a token ceiling for the whole agentic loop that the model sees and paces itself against
• C. It only applies to thinking tokens
• D. It replaces `effort`

On Fable 5, a safety classifier declines a request. How is this surfaced, and what should your code check first?

• A. An HTTP 403; check the status code
• B. An HTTP 200 with `stop_reason: "refusal"`; branch on `stop_reason` before reading `content`
• C. An empty 200 with no signal
• D. A 429 rate-limit error

Fable 5 code should ship a refusal fallback by default. On the first-party API, what is the preferred mechanism?

• A. Manually retry on a different model in a catch block
• B. The server-side `fallbacks` parameter (beta `server-side-fallback-2026-06-01`)
• C. Lower the effort and retry
• D. Disable safety classifiers

Which is a hard requirement when using Fable 5?

• A. Assistant prefill must be enabled
• B. The organization must meet 30-day data retention (it is not available under zero data retention)
• C. `temperature` must be set to 0
• D. A dedicated region must be selected

The Message Batches API offers what cost reduction, and how do results arrive?

• A. 50% cheaper; results keyed by `custom_id` and may arrive in any order
• B. 90% cheaper; results are strictly ordered
• C. No discount; real-time streaming
• D. 25% cheaper; results by position index

Which HTTP errors do the Anthropic SDKs automatically retry with exponential backoff?

• A. 400 and 401
• B. 404 only
• C. 408, 409, 429, and 5xx, plus connection errors
• D. None — you must retry manually

Best practice for catching API errors in the SDK is to…

• A. String-match on the error message
• B. Catch a single broad base class
• C. Catch a most-specific-first chain of typed exceptions (e.g. `NotFoundError` → `RateLimitError` → `APIStatusError`)
• D. Ignore errors and rely on retries

Which is the most effective lever to reduce cost for a large, repeated, stable context prefix?

• A. Lowering `max_tokens`
• B. Prompt caching (cache reads cost ~0.1× base input)
• C. Switching to a larger model
• D. Disabling streaming