CCAR-F practice questions

Question 1.1Domain 1: Agentic architecture and orchestrationSelect one

You are implementing the agent's core loop. Which control flow correctly determines when to keep executing tools and when to present the final response?

• AContinue looping until the assistant's text contains a phrase like “I have resolved the issue”, then stop
• BInspect stop_reason on each response: while it is “tool_use”, execute the requested tools and return results for the next iteration; when it is “end_turn”, present the final response
• CRun exactly five iterations, since support cases rarely need more tool calls than that
• DStop as soon as any response contains text content, since text indicates completion

Question 1.2Domain 1: Agentic architecture and orchestrationSelect one

The agent calls lookup_order and your code executes it successfully. How does the model actually receive the order data so it can reason about the next action?

• AThe MCP server pushes the result directly into the model's memory
• BThe model re-reads the tool's description, which now includes the result
• CNothing is required — the API executes tools and incorporates results automatically
• DYour code appends a tool result block (referencing the tool call's ID) to the conversation history and sends the updated messages back to Claude in the next request

Question 1.3Domain 1: Agentic architecture and orchestrationSelect one

Company policy caps autonomous refunds at $500; larger refunds must go to a human. In testing, prompt instructions alone still let an occasional $650 refund through. What is the correct enforcement design?

• AImplement a hook that intercepts outgoing process_refund calls, blocks any amount above $500, and redirects the agent to the escalate_to_human workflow
• BMove the $500 limit to the top of the system prompt and repeat it in every user turn
• CLower the model temperature so it follows the policy more consistently
• DAdd the limit to the process_refund tool description so the model reads it during selection

Question 1.4Domain 1: Agentic architecture and orchestrationSelect one

A customer writes one message containing three concerns: a refund for a damaged item, a shipping address change, and a missing loyalty credit. How should the agent handle this?

• AResolve only the refund, since it was mentioned first, and wait for the customer to raise the others again
• BEscalate immediately — multi-issue messages always exceed agent capability
• CDecompose the message into three distinct items, investigate each (in parallel where possible) using the shared customer context, then synthesize one unified resolution covering all three
• DAsk the customer to resend each issue as a separate message

Question 1.5Domain 1: Agentic architecture and orchestrationSelect one

The agent must escalate a complex billing dispute mid-process. The human agents receiving escalations do not have access to the conversation transcript. What should the escalation include?

• AOnly the customer's name, so the human can start fresh without bias
• BA structured handoff summary: customer ID, the root cause analysis so far, relevant amounts and order numbers, and the agent's recommended action
• CA sentiment score describing how upset the customer is
• DThe raw JSON of every tool result gathered during the session

Question 1.6Domain 2: Tool design and MCP integrationSelect one

When process_refund fails for any reason, it currently returns the string “Operation failed.” The agent responds by retrying policy-blocked refunds and giving up on temporary outages — the opposite of correct. What is the fix?

• AInstruct the agent in the system prompt to always retry exactly twice
• BRemove failure responses entirely so the agent never sees errors
• CHave the agent apologize to the customer whenever any error occurs
• DReturn structured error metadata: an errorCategory (transient / validation / business / permission), an isRetryable boolean, and a human-readable description the agent can act on

Question 1.7Domain 2: Tool design and MCP integrationSelect one

A refund request violates the returns window policy. The tool rejects it. Which error response enables the agent to handle this correctly with the customer?

• AerrorCategory: “business”, retriable: false, plus a customer-friendly explanation of the policy — so the agent explains the refusal rather than retrying it
• BerrorCategory: “transient” so the agent retries later, when the policy might differ
• CAn empty result marked as success, to keep the conversation positive
• DA stack trace, so the agent has maximum detail

Question 1.8Domain 2: Tool design and MCP integrationSelect two

The agent frequently confuses get_customer and lookup_order; both currently carry one-line descriptions. Which TWO description changes most directly fix the misrouting? (Select TWO.)

• AMake both descriptions shorter so there is less to confuse
• BDocument each tool's expected input formats and add example queries it should handle
• CPrefix both descriptions with “IMPORTANT:” for emphasis
• DAdd boundary language differentiating the two — e.g., “use lookup_order when an order number is present; use get_customer to verify identity before account operations”
• ERely on the tool names alone, since names are what models read

Question 1.9Domain 5: Context management and reliabilitySelect one

A customer's first message is: “I want to speak to a human. Do not try to fix this yourself.” The issue looks like a routine replacement the agent could resolve. What should the agent do?

• AAttempt resolution first, escalating only if the attempt fails
• BRun sentiment analysis and escalate only if frustration exceeds a threshold
• CEscalate immediately — an explicit customer request for a human is honored without first attempting investigation
• DAsk the customer three clarifying questions before deciding

Question 1.10Domain 5: Context management and reliabilitySelect two

In long multi-issue sessions, the agent's later responses misquote refund amounts and order numbers because earlier details were condensed into vague summaries, while each lookup_order result dumps 40+ fields into context. Which TWO changes address this? (Select TWO.)

• AExtract transactional facts — amounts, dates, order numbers, statuses — into a persistent case-facts block included in each prompt, outside the summarized history
• BIncrease max_tokens so responses can be longer
• CSummarize even more aggressively to save space
• DTrim each tool result to only the fields relevant to the current issue before it enters context
• EAsk the customer to repeat key numbers periodically

Question 2.1Domain 3: Claude Code configuration and workflowsSelect one

You have a personal /scratch-notes slash command you use constantly, but it reflects your own workflow and should not appear for teammates when they pull the repository. Where does the command file belong?

• AIn .claude/commands/ in the repository, like all slash commands
• BIn the root CLAUDE.md under a # Commands heading
• CIn ~/.claude/commands/ in your home directory, where user-scoped commands live outside version control
• DIn .claude/rules/ with a paths glob matching your username

Question 2.2Domain 3: Claude Code configuration and workflowsSelect one

Your /analyze-architecture skill produces thousands of lines of exploration output that pollute the main conversation, crowding out the task you actually wanted help with. Which SKILL.md frontmatter option fixes this?

• Aargument-hint, so the skill asks what to analyze
• Bcontext: fork, which runs the skill in an isolated sub-agent context and returns results without flooding the main conversation
• Callowed-tools, restricting the skill to read-only operations
• Dpaths, restricting the skill to architecture files

Question 2.3Domain 3: Claude Code configuration and workflowsSelect one

You are writing a /scaffold-component skill that generates boilerplate files. You want a guarantee it can create files but can never run shell commands, no matter what its instructions are asked to do. How do you enforce this?

• AState “never run Bash” prominently in the SKILL.md instructions
• BTrust the skill's narrow purpose to keep it away from Bash
• CRun the skill only in plan mode
• DSet allowed-tools in the SKILL.md frontmatter to permit only the file-write operations the skill needs, excluding Bash

Question 2.4Domain 3: Claude Code configuration and workflowsSelect one

A new teammate's Claude Code sessions ignore the team's coding standards. You discover the standards live in your own ~/.claude/CLAUDE.md. What is the correct fix, and how do you verify it?

• AMove the standards into the project-level CLAUDE.md (checked into the repository) so every clone receives them, and use the /memory command to verify which memory files a session has loaded
• BEmail the teammate your ~/.claude/CLAUDE.md to copy into their home directory
• CHave the teammate re-install Claude Code to refresh configuration
• DPaste the standards at the start of each session until they stick

Question 2.5Domain 3: Claude Code configuration and workflowsSelect one

The project's CLAUDE.md has grown to 2,000 lines covering testing, API conventions, deployment, and styling; sessions load it all regardless of task. What is the recommended reorganization?

• ADelete the file and rely on the model's general knowledge of good practice
• BMove everything to each developer's user-level CLAUDE.md
• CSplit it into focused, topic-specific files in .claude/rules/ (e.g., testing.md, api-conventions.md, deployment.md), adding path-scoped frontmatter where conventions apply only to matching files
• DConvert the entire file into a single slash command developers run manually

Question 2.6Domain 1: Agentic architecture and orchestrationSelect one

Yesterday you ran a long investigation into a memory leak in a session you named leak-hunt. Today you want to continue exactly where that investigation left off. What do you run?

• Aclaude --continue-all, which reopens every recent session
• Bclaude --resume leak-hunt, resuming the named session with its context
• Cclaude -p “continue the leak investigation”
• DA new session, pasting yesterday's terminal scrollback as the first message

Question 2.7Domain 1: Agentic architecture and orchestrationSelect one

You have completed a thorough analysis of a module and now want to compare two competing refactoring strategies — developing each independently from that same analysis baseline without the explorations contaminating each other. Which capability fits?

• ARun both strategies sequentially in the same session, asking Claude to forget the first before starting the second
• BOpen two brand-new sessions and redo the module analysis in each
• CUse /compact between the two strategies
• DUse fork_session to create independent branches from the shared analysis baseline, exploring one strategy per branch

Question 2.8Domain 1: Agentic architecture and orchestrationSelect one

You want to resume last week's refactoring session, but since then the team has merged substantial changes across the files it analyzed, so most of its tool results now describe code that no longer exists. What is the reliable approach?

• AStart a new session seeded with a structured summary of the prior conclusions — stale tool results make resumption unreliable, since the model will reason from outdated file contents
• BResume the session as-is; Claude automatically detects file changes
• CResume the session and increase max_tokens to accommodate the confusion
• DNever resume any session; always start from zero exploration

Question 2.9Domain 5: Context management and reliabilitySelect one

Mid-way through an extended exploration session, context is filling with verbose discovery output and responses are noticeably degrading, but you are not ready to end the session. Which built-in command helps immediately?

• A/memory, which clears the conversation
• B/fork, which splits the session in half
• C/compact, which reduces context usage by compacting the conversation so the session can continue productively
• D/rules, which reloads the rule files

Question 2.10Domain 5: Context management and reliabilitySelect two

During multi-hour codebase exploration sessions, the agent starts answering from “typical patterns” instead of the specific classes it discovered earlier. Which TWO practices counteract this context degradation? (Select TWO.)

• ASwitch to a model with a larger context window and continue accumulating
• BMaintain a scratchpad file recording key findings as they are discovered, and have the agent reference it for subsequent questions
• CRepeat important questions twice in the same message
• DAsk the agent to be more specific
• EDelegate verbose investigation (e.g., “find all test files”, “trace the refund flow”) to subagents that return summaries, keeping the main session's context for high-level coordination

Question 3.1Domain 1: Agentic architecture and orchestrationSelect one

Your coordinator's system prompt tells it to delegate research to subagents, but at runtime it never spawns any — it attempts all the research itself. Its configuration restricts it to research-planning tools. What is the most likely cause?

• AThe coordinator model tier is too small to understand delegation
• BSubagents must be started manually before the coordinator runs
• CThe system prompt needs the word “delegate” in capital letters
• DThe coordinator's allowedTools does not include “Task” — the Task tool is the mechanism for spawning subagents, so without it no delegation can occur

Question 3.2Domain 1: Agentic architecture and orchestrationSelect one

The web search subagent gathers excellent findings, but the synthesis subagent's reports are generic and reference none of them. The coordinator invokes synthesis with the prompt “Synthesize the research findings.” What is wrong?

• AThe synthesis agent's model needs extended thinking enabled
• BSubagents do not inherit the coordinator's conversation history — the coordinator must include the actual findings (search results, analysis outputs) directly in the synthesis subagent's prompt
• CThe synthesis agent needs web search tools to gather its own findings
• DThe prompt needs the word “please”

Question 3.3Domain 1: Agentic architecture and orchestrationSelect one

The coordinator currently invokes the web search subagent, waits for completion, then invokes the document analysis subagent — doubling research latency even though the two tasks are independent. How do you run them in parallel?

• AHave the coordinator emit both Task tool calls in a single response, which spawns the subagents in parallel
• BAsk each subagent to work faster in its system prompt
• CRun two copies of the entire system and merge the databases
• DParallelism is impossible — subagents must always run sequentially

Question 3.4Domain 1: Agentic architecture and orchestrationSelect one

Your coordinator gives subagents rigid step-by-step procedures (“run these exact five queries in this order”). Subagents fail whenever a topic doesn't fit the script. How should coordinator prompts be designed instead?

• AMake the procedures longer, covering more contingencies explicitly
• BRemove all instructions and let subagents infer their tasks
• CSpecify research goals and quality criteria — what a complete answer looks like — and let the subagent adapt its approach to what it discovers
• DHave subagents ask the human operator whenever the script fails

Question 3.5Domain 1: Agentic architecture and orchestrationSelect one

Completed reports are coherent but shallow on some subtopics. You want the system to notice and repair its own coverage gaps before finalizing. Which orchestration pattern achieves this?

• ALower the bar: accept the first synthesis as final to control costs
• BAn iterative refinement loop: the coordinator evaluates synthesis output for gaps, re-delegates to search and analysis subagents with targeted queries, and re-invokes synthesis until coverage is sufficient
• CAsk the report generation agent to pad thin sections with general knowledge
• DAlways run every subagent exactly twice regardless of output quality

Question 3.6Domain 2: Tool design and MCP integrationSelect one

Every subagent currently receives the full 18-tool catalog. Logs show the synthesis agent attempting web searches and the search agent trying document parsing — with frequent wrong-tool selections everywhere. What is the correct redesign?

• AAdd a nineteenth tool that tells the agents which tool to use
• BAlphabetize the tool list so selection is easier
• CWrite longer system prompts warning each agent about the tools it should ignore
• DScope each subagent's tool set to its role — a handful of relevant tools each — since large tool inventories degrade selection reliability and out-of-role tools invite misuse

Question 3.7Domain 2: Tool design and MCP integrationSelect one

Subagents burn many tool calls just discovering what data exists — listing available document collections, probing for issue summaries, checking what schemas are present — before real work begins. Which MCP capability reduces this?

• AExpose content catalogs (document hierarchies, issue summaries, schema listings) as MCP resources, giving agents visibility into available data without exploratory tool calls
• BIncrease the tool-call budget so exploration is affordable
• CHard-code the current data inventory into every system prompt
• DRemove discovery capability so agents work blind

Question 3.8Domain 5: Context management and reliabilitySelect one

Final reports state findings but cite nothing. Investigation shows each summarization step compresses source attribution away, so by synthesis time nobody knows which claim came from where. What is the structural fix?

• AHave the report generator add plausible citations at the end
• BInstruct the synthesis agent to write “sources available on request”
• CRequire subagents to output structured claim-source mappings (claim, evidence excerpt, source URL or document name) that every downstream agent preserves and merges through synthesis
• DReduce the number of summarization steps to one

Question 3.9Domain 5: Context management and reliabilitySelect two

Two credible sources report different figures for the same market's size, and one subagent's summary simply picked the larger number. Which TWO practices produce correct handling of conflicting source data? (Select TWO.)

• AAnnotate the conflict explicitly — both values, each with source attribution — and let the coordinator decide how to reconcile before synthesis, rather than silently selecting one
• BAverage the two figures into a single compromise value
• CAlways adopt the more recent source and discard the other
• DRequire publication or data-collection dates in subagents' structured outputs, so temporal differences are not misread as contradictions
• EExclude both sources to avoid taking sides

Question 3.10Domain 5: Context management and reliabilitySelect two

You are designing how the web search subagent behaves when its searches fail or return nothing. Which TWO behaviors are correct? (Select TWO.)

• AOn any failure, immediately terminate the entire research workflow
• BAttempt local recovery for transient failures (e.g., retrying a timeout), and propagate to the coordinator only errors it cannot resolve — including what was attempted and any partial results
• CReturn empty results marked as success whenever a search fails, keeping the pipeline moving
• DReport every problem as a generic “search unavailable” status
• EDistinguish access failures (timeouts, service errors) from valid empty results (successful queries with no matches), since the two require different coordinator decisions

Question 4.1Domain 2: Tool design and MCP integrationSelect two

The agent must (a) locate every file matching the test naming convention anywhere in the repo, and (b) find every place the string “PaymentDeclinedError” appears in code. Which TWO tool selections are correct? (Select TWO.)

• AGlob with a pattern like **/*.test.tsx for the test files — file-path pattern matching is Glob's job
• BGrep with a filename pattern to find the test files
• CGrep for “PaymentDeclinedError” — searching file contents for a string is Grep's job
• DGlob for “PaymentDeclinedError” across file contents
• EBash running cat on every file, piping through manual inspection

Question 4.2Domain 2: Tool design and MCP integrationSelect one

The agent attempts an Edit on a legacy file and fails: the anchor text it targeted appears in six places, so the unique-match requirement cannot be satisfied. What is the standard fallback?

• ADelete five of the six occurrences so the match becomes unique
• BRetry the same Edit repeatedly until it succeeds
• CSwitch to Bash and modify the file with sed
• DUse Read to load the full file, then Write the complete modified content — the reliable path when Edit cannot find unique anchor text

Question 4.3Domain 2: Tool design and MCP integrationSelect one

Asked how the billing module works, the agent Reads dozens of files upfront and exhausts its context before answering. What is the correct exploration strategy for building codebase understanding?

• ARead files in alphabetical order and stop at the context limit
• BWork incrementally: Grep to find entry points (key functions, imports, error strings), then Read selectively to follow imports and trace flows from those anchors
• CAsk the developer to explain the module instead
• DRead only the README and reason from documentation

Question 4.4Domain 2: Tool design and MCP integrationSelect one

The team shares a GitHub MCP server that needs an auth token, and you also run a personal, experimental MCP server you don't want to impose on anyone. How should these be configured?

• AThe shared server in project-scoped .mcp.json using environment variable expansion (e.g., ${GITHUB_TOKEN}) so no secret is committed; the personal server in user-scoped ~/.claude.json
• BBoth servers in .mcp.json, with the token pasted in so teammates don't have to set variables
• CBoth servers in ~/.claude.json, with setup instructions in the wiki
• DThe shared server in CLAUDE.md and the personal one in .claude/commands/

Question 4.5Domain 3: Claude Code configuration and workflowsSelect one

Two tasks arrive: fixing an off-by-one bug in one function with a clear stack trace, and migrating the codebase's HTTP library — touching 45+ files with several viable approaches. How should plan mode and direct execution be assigned?

• APlan mode for both — planning never hurts
• BDirect execution for both — plan mode is only for greenfield projects
• CDirect execution for the well-scoped single-file bug fix; plan mode for the migration, whose scale and multiple valid approaches demand exploration and design before changes are committed
• DPlan mode for the bug fix and direct execution for the migration

Question 4.6Domain 3: Claude Code configuration and workflowsSelect one

Developers keep invoking your /generate-fixture skill bare, without the entity type and record count it needs, then get confused by the results. Which frontmatter option addresses this?

• Acontext: fork, isolating the confusion in a subagent
• Ballowed-tools, restricting what the skill can touch
• CA longer skill description explaining the parameters
• Dargument-hint, which prompts developers for the required parameters when the skill is invoked without arguments

Question 4.7Domain 3: Claude Code configuration and workflowsSelect one

You must decide where two things live: (1) the team's universal coding standards that should shape every session, and (2) a multi-step release-notes workflow used a few times per month. What is the correct placement?

• ABoth as skills, invoked when developers remember
• BStandards in CLAUDE.md, which is always loaded; the occasional release-notes workflow as a skill in .claude/skills/, invoked on demand
• CBoth in CLAUDE.md so nothing is ever missed
• DStandards as a skill; the release workflow in CLAUDE.md

Question 4.8Domain 1: Agentic architecture and orchestrationSelect one

The task is open-ended: “add comprehensive tests to this legacy codebase.” Nobody knows yet where the risk concentrates or what depends on what. Which decomposition approach fits?

• AFirst map the codebase structure, identify high-impact areas, then create a prioritized plan that adapts as dependencies and surprises are discovered
• BWrite tests file-by-file in directory order until done
• CGenerate all tests in a single maximal request
• DTest only the code modified in the last month

Question 4.9Domain 1: Agentic architecture and orchestrationSelect one

You are choosing decomposition strategies for two workflows: a code review that always checks the same five aspects, and a production-incident investigation whose next step depends on what each finding reveals. Which pairing is right?

• ADynamic decomposition for both, since flexibility is always better
• BPrompt chaining for both, since fixed steps are easier to test
• CPrompt chaining (a fixed sequence of focused passes) for the predictable five-aspect review; dynamic adaptive decomposition for the investigation, where intermediate findings determine the next subtask
• DDynamic decomposition for the review; prompt chaining for the investigation

Question 4.10Domain 1: Agentic architecture and orchestrationSelect two

You are writing AgentDefinition configurations for the productivity system's subagents. Which TWO statements about subagents are accurate? (Select TWO.)

• ASubagents automatically inherit the parent agent's full conversation history
• BEach subagent's AgentDefinition carries its own description, system prompt, and tool restrictions for its role
• CSubagents can be spawned without the Task tool if the prompt describes them clearly
• DSubagents do not share memory between invocations — whatever context a subagent needs must be provided explicitly in its prompt
• ESubagent tool restrictions are advisory and not enforced at runtime

Question 5.1Domain 3: Claude Code configuration and workflowsSelect one

Your CI job must run Claude Code non-interactively and produce review findings your pipeline can parse and post as inline PR comments. Which invocation is correct?

• Aclaude “review this PR” piped through grep to extract findings from prose
• Bclaude -p “review this PR” with --output-format json and --json-schema, producing machine-parseable structured findings without waiting for interactive input
• Cclaude --batch “review this PR” --format=structured
• Dclaude -p “review this PR” alone, then regex-parsing the prose output

Question 5.2Domain 3: Claude Code configuration and workflowsSelect one

CI-generated tests ignore your team's fixture library, duplicate helper setup, and test trivialities. Developers reject most of them. What is the configuration-level fix?

• AGenerate three times as many tests so some survive review
• BHave developers rewrite the generated tests as a standing chore
• CLower the temperature of the generation call
• DDocument testing standards, what makes a test valuable, and the available fixtures in CLAUDE.md — the mechanism that supplies project context to CI-invoked Claude Code

Question 5.3Domain 3: Claude Code configuration and workflowsSelect one

Reviews re-run after each new commit to a PR, and the bot re-posts the same findings every time — developers now mute it. How should re-reviews be designed?

• AInclude the prior review's findings in context and instruct Claude to report only new issues or previously reported ones that remain unaddressed
• BReview only the newest commit's diff in isolation
• CLimit reviews to one per PR regardless of subsequent commits
• DPost all findings again but formatted differently to seem new

Question 5.4Domain 3: Claude Code configuration and workflowsSelect one

You notice that when the same Claude Code session that generated a change also reviews it, the review is conspicuously gentle — missing issues an independent reviewer catches. Why, and what is the design implication?

• AThe model is being polite; instruct it to be harsher
• BReviews should always be performed by a larger model tier
• CA session retains the reasoning context from generation, making it less likely to question its own decisions — so CI reviews should run in an independent instance without the generator's context
• DGeneration and review must run on different days to avoid contamination

Question 5.5Domain 4: Prompt engineering and structured outputSelect one

Your review prompt says “be conservative and only report high-confidence findings,” yet false positives remain high. What does effective precision engineering look like instead?

• AAdd “be very, very conservative” for stronger emphasis
• BReport all findings but sort them by the model's stated confidence
• CReduce the number of files reviewed per run
• DReplace confidence language with explicit categorical criteria: define which issue types to report (bugs, security) and which to skip (minor style, local patterns), with concrete boundaries

Question 5.6Domain 4: Prompt engineering and structured outputSelect one

Findings in the “code style” category are 70% false positives, and developers have begun dismissing security findings too — trust in the whole reviewer is collapsing. What is the right operational move?

• AShip more style findings to demonstrate the category's importance
• BTemporarily disable the style category to restore trust in the accurate categories, while improving the style prompts before re-enabling it
• CRename “code style” to “code quality”
• DAsk developers to be more tolerant of noise during the tuning period

Question 5.7Domain 4: Prompt engineering and structured outputSelect one

The reviewer labels near-identical issues “critical” one day and “minor” the next. Severity-based merge gates are therefore unreliable. How do you get consistent severity classification?

• ADefine explicit severity criteria with concrete code examples for each level, so every severity has an operational definition the model can match against
• BRemove severity levels and treat all findings equally
• CLet the model choose severity freely but average it over five runs
• DMap severity to line count of the affected code

Question 5.8Domain 4: Prompt engineering and structured outputSelect one

The reviewer keeps flagging your codebase's accepted idiomatic patterns (e.g., intentional fall-throughs with comments) as bugs, while your detailed prose instructions haven't fixed it. What is the most effective addition?

• AA rule that anything containing a comment is acceptable
• BAn instruction to “use good judgment about idioms”
• CFew-shot examples distinguishing the accepted patterns from genuine issues — showing the reasoning why each is or isn't reportable — so the model generalizes the judgment to novel cases
• DA ban on reviewing files containing any idiomatic pattern

Question 5.9Domain 4: Prompt engineering and structured outputSelect two

Your team is deciding which CI workloads to move to the Message Batches API for its 50% cost savings. Which TWO statements are accurate? (Select TWO.)

• ABatch processing suits latency-tolerant, non-blocking workloads like nightly test generation and weekly audit reports
• BBatches are guaranteed to complete within one hour
• CThe batch API supports multi-turn tool calling within a single request
• DBlocking workflows such as pre-merge checks should stay on the synchronous API, since batches can take up to 24 hours with no latency SLA
• EBatch responses cannot be matched back to their requests

Question 5.10Domain 4: Prompt engineering and structured outputSelect two

You are adding few-shot examples to the review prompt. Which TWO practices reflect how few-shot prompting works best? (Select TWO.)

• AInclude as many examples as possible — twenty or more — to cover every case
• BUse 2–4 targeted examples aimed at the ambiguous scenarios, showing the reasoning for why one action was chosen over plausible alternatives
• COnce examples are added, explicit criteria become unnecessary
• DRely on examples only for prose tasks; they don't work for code
• EInclude examples demonstrating the exact desired output format — location, issue, severity, suggested fix — to achieve consistent, actionable findings

Question 6.1Domain 4: Prompt engineering and structured outputSelect one

Your current pipeline asks Claude to “respond with JSON” in plain text; downstream parsing breaks on markdown fences, trailing commentary, and occasional malformed syntax. What is the most reliable structural fix?

• AStrengthen the prompt: “respond ONLY with valid JSON, no exceptions”
• BPost-process the text with regexes that strip fences and repair syntax
• CDefine the extraction as a tool whose input schema is your JSON schema, and read the structured data from the tool_use block — guaranteeing schema-compliant output and eliminating JSON syntax errors
• DSwitch to XML output, which models format more carefully

Question 6.2Domain 4: Prompt engineering and structured outputSelect one

You have several extraction tools — one per document type — and incoming documents of unknown type. The model must always produce a structured extraction, choosing the appropriate schema itself, and never reply with conversational text. Which tool_choice setting is correct?

• Atool_choice: “any” — the model must call a tool but may choose which, guaranteeing structured output while leaving schema selection to the model
• Btool_choice: “auto” — the model decides whether to call a tool at all
• Ctool_choice forced to one named tool, applied to every document
• DOmit tool_choice, since defaults handle this

Question 6.3Domain 4: Prompt engineering and structured outputSelect one

Your invoice schema marks vendor_tax_id as required. On invoices that genuinely lack a tax ID, the model fabricates plausible-looking values to satisfy the schema. What is the schema-level fix?

• AAdd a prompt instruction: “never fabricate tax IDs”
• BPost-validate tax IDs against a checksum and discard failures
• CLower the temperature to make fabrication less creative
• DMake the field optional/nullable so the model can legitimately return null when the information is absent from the source document

Question 6.4Domain 4: Prompt engineering and structured outputSelect one

Since adopting tool use, extractions are always syntactically valid — yet invoices arrive where line items don't sum to the stated total, and values occasionally land in the wrong fields. What should you understand and do?

• ASchema compliance was falsely advertised; file a bug
• BStrict schemas eliminate syntax errors but not semantic ones — add semantic validation, e.g., extracting calculated_total alongside stated_total and flagging discrepancies with a conflict_detected boolean
• CMake every field an unconstrained string so nothing can be wrong
• DRe-run each extraction until the numbers happen to sum

Question 6.5Domain 4: Prompt engineering and structured outputSelect one

An extraction fails Pydantic validation with two specific field errors. You will retry. What should the retry request contain — and when would you skip retrying altogether?

• AJust the instruction “try again more carefully”; skip retries on Mondays
• BOnly the validation errors, to keep the retry cheap; always retry at least five times
• CThe original document, the failed extraction, and the specific validation errors — enabling targeted self-correction; skip retrying when the required information is simply absent from the source, since no retry can produce it
• DA different document, to give the model a fresh start

Question 6.6Domain 4: Prompt engineering and structured outputSelect one

An overnight batch of 10,000 documents completes with 200 failures: most are oversized documents that blew past context limits, plus some transient errors. What is the correct failure-handling workflow?

• AIdentify the failed requests by custom_id and resubmit only those, with modifications where needed — e.g., chunking the oversized documents before resubmission
• BResubmit the entire 10,000-document batch and keep whichever results arrive first
• CDiscard the 200 failures as an acceptable loss rate
• DSwitch the 200 failures to the synchronous API unchanged, where context limits don't apply

Question 6.7Domain 2: Tool design and MCP integrationSelect one

A single analyze_document tool handles extraction, summarization, and claim verification, chosen by a mode parameter. The agent regularly picks the wrong mode and results are inconsistent. What is the recommended redesign?

• AAdd a fourth mode that automatically detects the right mode
• BDocument the modes more thoroughly inside the one description
• CReduce to two modes by merging extraction into summarization
• DSplit the generic tool into purpose-specific tools — extract_data_points, summarize_content, verify_claim_against_source — each with a defined input/output contract

Question 6.8Domain 2: Tool design and MCP integrationSelect one

When your MCP extraction tool hits a parsing failure, it returns the message “Error: could not parse document” as an ordinary successful text result. The agent then treats that sentence as document content. What is the correct MCP pattern?

• APrefix error text with “SYSTEM ERROR:” so the agent notices
• BReturn the failure with the MCP isError flag set, so the agent programmatically recognizes a tool failure instead of interpreting error prose as data
• CReturn an empty string on failure
• DThrow an unhandled exception and let the connection drop

Question 6.9Domain 5: Context management and reliabilitySelect two

Your extraction system reports 97% aggregate accuracy, and leadership wants to cut human review of high-confidence extractions. Which TWO practices must precede that decision? (Select TWO.)

• ASegment accuracy by document type and field — verifying consistent performance across all segments, since aggregate metrics can mask systematic failures on specific types
• BAccept the 97% aggregate as sufficient evidence on its own
• CImplement stratified random sampling of high-confidence extractions for ongoing error-rate measurement and detection of novel error patterns
• DStop measuring once review is reduced, to save cost
• EReview only extractions the model itself flags as uncertain

Question 6.10Domain 5: Context management and reliabilitySelect two

Reviewer capacity covers only a fraction of extractions, so review attention must be routed where errors are likeliest. Which TWO practices form a sound routing design? (Select TWO.)

• ATrust the model's raw self-reported confidence scores without validation
• BHave the model output field-level confidence scores, then calibrate review thresholds against a labeled validation set
• CReview a fixed 1% of extractions chosen by submission order
• DRoute to human review the extractions with low calibrated confidence or ambiguous/contradictory source documents, prioritizing limited reviewer capacity where errors concentrate
• EReview only documents longer than ten pages