CCAR-F Sample Questions Answers

Each requirement belongs in the mechanism matching its enforcement semantics. The migration restriction is a hard safety boundary, so it should be implemented through permissions.deny , not merely expressed as contextual guidance. Anthropic explicitly states that CLAUDE.md content is treated as context rather than enforced configuration. Permission rules use the Tool(specifier) form, evaluate deny rules before ask or allow rules, and support path-based Edit(...) restrictions. ( https://code.claude.com/docs/en/memory )

The custom logging convention is a persistent project preference, making CLAUDE.md the appropriate location. It should guide Claude’s code-generation decisions but does not require deterministic interception. Prettier formatting, by contrast, is deterministic automation. Anthropic documents the exact pattern of using a PostToolUse hook with an Edit|Write matcher to run Prettier automatically after file modifications. ( https://code.claude.com/docs/en/hooks-guide )

Option A incorrectly treats path-scoped rules as a security control; rules remain instructions. Option B overuses hooks for a semantic coding preference that belongs in CLAUDE.md. Option C relies entirely on stronger prompting, which cannot guarantee that protected files remain untouched. Option D correctly separates prohibition, preference, and automatic enforcement.

Official references/topics: Permission rules, CLAUDE.md semantics, PostToolUse formatting hooks.

Option D separates durable case history from volatile operational data. The new session receives a compact, structured summary describing the billing dispute, the customer’s objective, actions previously taken, and the unresolved status. It does not inherit outdated backend observations as though they were still authoritative. Fresh tool calls then retrieve the current refund or order state before the agent responds.

Agent SDK sessions preserve conversation history, including earlier tool calls and tool results. Resuming the complete transcript therefore reintroduces stale system data into the active context, even though the external backend may have changed substantially during the four-hour gap. Conversation persistence must not be confused with persistence of external-system truth.

Option A performs unnecessary calls to every previously used tool, including tools unrelated to the returning customer’s current question. Option B relies on prompt compliance while retaining contradictory historical evidence in context. Option C manually removes tool results from an existing transcript and may damage the logical relationship between prior tool_use and tool_result blocks while still retaining a long, unstructured conversation.

A structured summary should preserve stable identifiers, previous actions, customer commitments, and unresolved issues. Time-sensitive fields such as refund status, delivery state, account balance, or expected resolution should always be refreshed through authoritative tools.

Official references/topics: Session persistence, stale tool-result management, context compaction, fresh-data retrieval.

The problem is an undefined relevance threshold. Claude is finding technically valid observations, but the prompt does not clearly distinguish actionable defects from acceptable conventions and low-value style preferences. Option A establishes explicit positive and negative reporting criteria, allowing the model to apply the team’s actual definition of a useful finding during generation.

Anthropic’s prompt-engineering guidance emphasizes clear, specific instructions and well-defined success criteria. The managed Code Review documentation similarly recommends defining skipped categories, generated paths, severity rules, and evidence requirements. Reporting “bugs affecting correctness or security” while excluding “formatting handled by CI and documented local conventions” is substantially more precise than asking the model to be generally conservative.

Option B adds cost, latency, another probabilistic decision, and a new evaluation surface before improving the original prompt. Option C confuses confidence with importance: Claude may be highly confident about a trivial style observation. Option D is dangerously broad because it can suppress legitimate but uncertain bugs, reducing recall. Explicit relevance criteria address the demonstrated failure directly while preserving the model’s ability to investigate and report genuine correctness or security problems.

================

Option A establishes a clear destination without forcing the subagent to follow a brittle route. The prompt should define the research question, boundaries, expected deliverable, acceptable source types, recency requirements, coverage expectations, and verification criteria. The subagent can then broaden, narrow, reformulate, or follow emerging leads according to observed search results.

Anthropic’s research-agent guidance emphasizes giving each subagent an objective, output format, source guidance, and clear task boundaries. It also describes research as dynamic and path-dependent, requiring agents to adapt their strategy as new information emerges.

Option B removes too much structure and may cause duplicated work, incomplete coverage, or inconsistent output. Option C handles only one known failure condition and still restricts the agent to a predetermined procedure. Option D adds classification complexity and creates an artificial boundary between topic types that may change during investigation. Objective-based delegation retains accountability because results can be evaluated against explicit quality criteria, while preserving the agent’s ability to discover alternative terminology, unexpected sources, and useful adjacent evidence. This is controlled autonomy rather than either procedural micromanagement or unrestricted exploration.

================

Retry-with-error-feedback is effective when the required information is available and the defect concerns representation. Options A, C, and D are correctable formatting failures: the model can flatten an object into an array, remove thousands separators and emit an integer, or convert a datetime into the required date-only format. The validation message supplies enough information to revise the output.

Option B is fundamentally different. The complete co-author list is absent from the model’s input and exists only in an external document. No number of retries can recover evidence that was never supplied. Repeated attempts may instead increase the probability of fabrication. Anthropic’s hallucination guidance recommends restricting responses to available documents, allowing the model to acknowledge missing information, and withholding or retracting claims that cannot be grounded in the source. ( https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/reduce-hallucinations )

The correct response is therefore to return an explicit missing-data state, retrieve the external document through a tool, or route the record for enrichment. Retrying without changing the information boundary cannot solve the problem.

Current Anthropic Structured Outputs can eliminate many shape-related failures by guaranteeing JSON Schema conformance, but they still cannot create unavailable source facts. ( https://platform.claude.com/docs/en/build-with-claude/structured-outputs ) This distinction—format failure versus evidence failure—is central to reliable extraction architecture.

Official references/topics: Retry Boundaries; Missing Context; Grounded Extraction; Structured Outputs; External Data Retrieval.

Option C preserves the semantic strengths of each information type instead of forcing heterogeneous evidence into one presentation structure. Financial values share comparable fields and therefore belong in a table. News developments require connected prose to preserve chronology and causality. Patent technology areas are naturally represented as grouped or prioritized lists.

Anthropic’s prompting best practices recommend giving explicit output-format instructions and matching the requested format to the intended communication goal. The synthesis prompt should therefore include rendering rules for each recognized content type while maintaining common provenance fields behind the presentation.

Option A damages numerical comparability and makes trends harder to scan. Option B can be useful as an internal exchange schema, but presenting the entire briefing as uniform JSON does not produce an effective executive document. Option D normalizes transport but does not correct the synthesis agent’s bullet-only rendering policy; a common representation can still be displayed badly. The correct design separates structured internal interchange from audience-facing presentation. The synthesis agent should preserve citations and metadata while selecting the most legible form for each class of evidence.

================

A schema-defined tool provides a structured interface between Claude and the application. The tool’s input_schema can declare required properties, nested work-experience and education objects, arrays of skills, and exact data types. Claude then supplies the extracted resume information as tool-call arguments, which the application can read directly from the tool_use response.

Anthropic’s tool documentation specifies that a custom tool definition includes a JSON Schema object describing its expected parameters. Current strict tool use can additionally enforce that generated tool arguments match the declared schema exactly. This removes the need to locate JSON inside free-form text or depend on post-generation repair. ( https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use )

Option A is fragile because regular expressions do not provide a robust parser for arbitrary nested JSON and cannot correct missing properties or incorrect types. Option B improves formatting behavior but remains probabilistic. Option C doubles latency and creates two opportunities for information loss: first during extraction and again during reformatting.

In a production design, fields that may genuinely be absent from a resume should be optional or nullable rather than forcing invented values. The tool schema should also use strict: true where supported. Among the available choices, D provides the strongest structural guarantee and the cleanest downstream integration.

Official references/topics: Tool Use Responses, Input Schemas, Strict Tool Use, Nested Structured Extraction.

Resuming preserves the prior architectural analysis, dependency mapping, and conversation history, avoiding the cost of repeating an hour of valid work. Anthropic states that resuming by session ID restores the agent’s full prior context, including files read, analysis performed, and decisions made. ( https://code.claude.com/docs/en/agent-sdk/sessions )

However, the session represents historical knowledge rather than a repository snapshot. Because three files changed externally, the agent must be told which files are affected and directed to re-read them before relying on earlier conclusions. Anthropic clarifies that sessions persist the conversation, not the filesystem. ( https://code.claude.com/docs/en/agent-sdk/sessions ) Targeted re-analysis updates the stale portion of the agent’s model while retaining the nine unchanged files’ established context.

Option A discards valuable work even though most of the analyzed code remains unchanged. Option C is accurate but inefficient because it reprocesses all twelve files regardless of whether they changed. Option D is unsafe: the agent may continue reasoning from obsolete function signatures, dependencies, or control flows.

The continuation prompt should identify the changed files, summarize the merge’s purpose where known, and request a focused comparison against the earlier understanding. Any architectural conclusions affected by those changes should then be revised explicitly.

Official references/topics: Session Resume; Filesystem Versus Conversation State; Targeted Re-Analysis; Repository Change Awareness.

Option D addresses the observed inconsistency at the model-behavior level. A schema can require that materials be a string, but it cannot teach Claude which lexical form the application considers canonical or demonstrate when a source phrase should populate the field. Anthropic identifies examples as one of the most reliable ways to steer output format, structure, and consistency, recommending several relevant and diverse examples that mirror the real task in its prompting best practices . Complete input-output pairs show both recognition and normalization: for example, a description containing “60% cotton, 40% polyester” can consistently map to the chosen “cotton/polyester blend” representation. They can also include difficult cases where material information is embedded indirectly in prose. Temperature zero reduces sampling variability but does not repair an underspecified transformation rule. A more capable model likewise lacks the missing formatting convention. Making the field required is dangerous because documents may legitimately omit materials; it can force unsupported values and increase hallucinations. Few-shot examples therefore supply the missing decision boundary while preserving truthful absence handling. The examples should be evaluated on held-out descriptions and supplemented by deterministic post-processing if downstream systems require an exact controlled vocabulary.

================

Option D fixes the actual failure while avoiding needless reprocessing. Anthropic’s Message Batches API treats every request independently, records the result against its unique custom_id, and explicitly states that one failed request does not affect the others. The 9,700 successful documents therefore require no retry. The failed requests exceeded the available context; increasing max_tokens changes the permitted output budget, not the size of the input context, so option C does not correct the cause. Resubmitting all 10,000 requests would repeat paid work, and prompt caching would only reduce some repeated-input cost without repairing oversized requests. Chunking each failed document reduces the input presented to Claude so every replacement request fits within the model’s context window . The application can then merge the extracted partial structures deterministically, retaining the original document identifier and chunk ordering. Anthropic recommends retry logic for failed batch requests and using custom_id to match results because batch results can arrive out of order. Consequently, selective retry plus chunking is both the technically correct recovery path and the lowest-cost option.

================

Option B demonstrates the decision boundary Claude must learn. Carefully selected examples can show structurally similar code producing different outcomes based on project context—for example, an approved authentication wrapper versus an unsafe direct call, or a deliberate performance trade-off versus an accidental quadratic operation. These contrasts help Claude apply the underlying judgment to new code rather than merely memorizing prohibited phrases.

Anthropic identifies relevant, diverse, and clearly structured examples as one of the most reliable methods for improving output accuracy and consistency. It recommends several examples that mirror the real use case and cover important edge conditions. Option A risks creating an oversized negative catalogue that consumes context, becomes difficult to maintain, and cannot anticipate every future variation. Option C filters text after generation and may suppress genuine findings that happen to use the selected keywords. Option D is dangerously vague: telling a reviewer to be conservative can suppress real but uncertain defects and reduce recall. The prompt should provide paired acceptable/problematic examples, explain why each classification differs, and require concrete code evidence for every reported finding. Anthropic prompting best practices

================

Project skills are stored at .claude/skills/ < skill-name > /SKILL.md . The directory name becomes the invocable command name, so .claude/skills/migrate-component/SKILL.md creates /migrate-component . Anthropic distinguishes project skills from personal skills: project skills apply only to the repository, while skills under ~/.claude/skills/ apply to one user across all projects. ( https://code.claude.com/docs/en/skills )

Committing the project skill to version control ensures that every developer receives the same workflow and that changes are reviewed, versioned, and synchronized with the codebase. Anthropic’s .claude directory guidance states that project configuration should be committed when it is intended to be shared with the team, whereas files under ~/.claude are personal. ( https://code.claude.com/docs/en/claude-directory )

Option A requires manual duplication across developer machines and allows versions to diverge. Option B loads the migration procedure into every conversation even when no migration is occurring; Anthropic recommends skills for reusable checklists and multi-step procedures because their bodies load only when used. Option C describes no valid mechanism for defining a skill’s content in settings.json .

Option D provides the correct scope, command name, on-demand loading behavior, and team distribution model.

Official references/topics: Project skills, SKILL.md structure, command invocation, version-controlled team configuration.

Option C matches the distinction between reasoning about delegation and executing it. Defining subagents makes their descriptions available for selection, but the coordinator must still invoke the SDK’s subagent-spawning tool. Current Claude Agent SDK documentation calls this the Agent tool; Task was its earlier name and remains relevant to older SDK configurations. Anthropic’s Subagents in the SDK documentation instructs developers to include Agent in allowedTools so subagent invocations are approved automatically. Without that permission, an invocation can fall through to a permission callback or be denied under a non-interactive permission mode. Option A is unlikely because the configured subagent descriptions already tell Claude when each agent should be selected, although explicit prompting can improve invocation reliability. Option B misstates context isolation: context must be included in the spawning prompt, but that issue occurs after an invocation is attempted and does not explain the absence of all subagent executions. Option D would normally produce truncation evidence or incomplete output rather than consistent verbal promises with no tool call. The configuration should therefore permit Agent, explicitly request delegation where necessary, and log subagent invocation events.

================

Option C respects the customer’s explicit request for human assistance. The agent should not attempt to retain the interaction, gather additional account information, or require the customer to repeat the request. Because the escalation decision has already been made by the customer, further autonomous investigation would create unnecessary delay and disregard clear human direction.

Anthropic’s trustworthy-agent framework emphasizes maintaining meaningful human control over agent autonomy. Anthropic’s customer-support implementation guidance also recommends defining interaction branches and measuring escalation efficiency as part of the system’s success criteria.

Option A deliberately delays escalation despite an unambiguous request. Option B performs unnecessary tool calls and may expose or retrieve account information that is not required before transferring the conversation. Option D similarly introduces another conversational barrier. Since the current exchange is short and contains no tool-generated evidence, passing the available conversation history gives the human agent the immediate context—the customer’s frustration, repeated unsuccessful attempts, and explicit transfer request—without pretending that account investigation has occurred.

================

Option D directly addresses cache entries expiring before later batch requests are processed. Anthropic’s batch-processing documentation specifically notes that Message Batches can take longer than five minutes and recommends the one-hour prompt-cache duration for batches containing shared context. The prompt-caching documentation confirms that the default TTL is five minutes and that " ttl " : " 1h " creates an extended entry.

Option A may improve cache locality, but it introduces the sequential-processing latency explicitly prohibited by the requirement. Option B seeds the cache initially, but the prewarmed entry still expires after five minutes unless the TTL is extended; it therefore does not solve misses among requests scheduled later. Option C places the breakpoint on request-specific content, defeating reuse of the stable 8,000-token prefix and attempting to cache scripts that are not byte-for-byte identical.

The system should retain the breakpoint at the end of the shared system content and apply the one-hour TTL there. Cache-usage fields should then be monitored to confirm that cache_read_input_tokens rises and later batch requests reuse the intended prefix.

================

Option B targets the remaining failure mode: semantic recognition across heterogeneous document structures. Strict schemas eliminate malformed JSON and can guarantee that tool inputs conform to declared types, but they cannot force Claude to locate evidence that appears under unfamiliar headings or in atypical sections. Anthropic’s prompting guidance says that a few relevant, diverse, structured examples are among the most reliable ways to improve accuracy and consistency. Examples should therefore show inline citations, reference lists, numbered bibliographies, methodology sections, and methods embedded in introductions, each paired with the correct extracted structure. This teaches the intended evidence-location and granularity rules rather than merely repeating the same request. Option A retries an unchanged prompt and can reproduce the same omission. Option C introduces brittle regex rules that may miss nonstandard citations and mistake keyword mentions for methodology content. Option D suppresses validation failures by weakening the contract, but it does not improve extraction and would convert recoverable omissions into incomplete records. The examples should be drawn from real failure cases, evaluated on a held-out set, and expanded when monitoring reveals new layouts. Schema constraints and few-shot coverage solve different layers of reliability and should be used together.

================

Option A reduces the maximum output required from any single response while preserving the structured schema and complete severity range. The pipeline can partition files into coherent groups, execute bounded reviews, validate each returned array, and merge and deduplicate findings using stable fields such as file path, line number, category, and description.

Anthropic’s stop-reason documentation confirms that max_tokens means generation reached the configured output limit and the response must be treated as incomplete. Structured output constraints can guarantee schema-valid generation when completion succeeds, but they cannot create unlimited output capacity. A large findings array can still exceed the available token budget.

Option B may postpone the failure but provides no durable guarantee for still-larger pull requests, and aggressively shortening descriptions may eliminate necessary evidence. Option C abandons machine-validated structure without reducing the amount of generated content. Option D deliberately suppresses medium- or low-severity findings and repeats an oversized request rather than addressing its scope. Partitioning establishes predictable output bounds, supports targeted retries, retains every required finding category, and prevents a single truncated response from invalidating the complete review.

================

The pipeline must preserve source evidence while making inconsistencies explicit. Option D records the amount stated on the invoice separately from the total derived from extracted line items. A mismatch then becomes a machine-detectable validation condition rather than an invisible extraction defect.

This approach is superior because it does not silently overwrite source data or ask another model to guess which value is correct. Anthropic’s evaluation guidance recommends automated, code-based grading whenever the criterion can be expressed deterministically. Arithmetic reconciliation is precisely such a criterion. ( https://docs.anthropic.com/en/docs/build-with-claude/develop-tests ) In production, the summation should preferably be calculated by application code using normalized decimal values, even though the option describes the model populating calculated_total . The essential design principle remains the same: preserve stated_total , compute an independent total, compare them, and route discrepancies for adjudication.

Option A might improve behavior but cannot resolve genuine OCR corruption and could encourage the model to modify extracted values merely to create mathematical consistency. Option B introduces a second probabilistic judgment without new evidence. Option C is unacceptable for accounting data because it fabricates adjusted amounts and destroys fidelity to the invoice.

The schema should therefore expose both values and attach a validation status or review reason when they differ.

Official references/topics: Deterministic Validation; Human-in-the-Loop Review; Structured Output Design; Source-Fidelity Controls.

The venue server must be available to every project contributor, so it belongs at project scope. Claude Code stores project-scoped MCP configurations in the repository-root .mcp.json file, which can be committed to version control and shared with the team.

The experimental playlist server should remain private. Local-scoped MCP servers are stored under the current project’s entry in ~/.claude.json , while user-scoped servers are also stored in ~/.claude.json but load across all projects. Because this server is described as a personal experiment, either private scope is conceptually appropriate; among the listed choices, option B correctly separates shared project configuration from private personal configuration. ( https://code.claude.com/docs/en/mcp )

Option A prevents the team from receiving the venue configuration. Option C reverses the intended visibility. Option D exposes the experimental server configuration to other contributors and may commit machine-specific commands or credentials.

The preferred commands would specify --scope project for the shared venue server and --scope local for an experiment limited to the current repository. Project-scoped servers also require user approval before Claude Code activates configurations received through .mcp.json .

Official references/topics: MCP Installation Scopes; Project Scope; Local Scope; .mcp.json ; ~/.claude.json .

Option B creates a targeted correction loop using information the first extraction did not have: the validator’s precise failure report. Anthropic’s prompting guidance describes prompt chaining as appropriate when an application must inspect intermediate output or enforce a specific pipeline, with self-correction following the pattern generate, review against criteria, and refine. Here, deterministic validators identify arithmetic mismatches and invalid vendor-ID formats. Returning the source document, original extraction, and explicit errors lets Claude revise only the defective fields while preserving valid data. The corrected record must then be validated again before acceptance, with a bounded retry count and human-review fallback. Option A is unsafe because automatically recalculating a total may overwrite the amount actually printed on the invoice; a mismatch can originate in an OCR or line-item extraction error. Option C repeats the same extraction without explaining what failed, wasting calls and relying on chance. Option D may prevent some format violations, but JSON Schema cannot express every cross-field arithmetic relationship or external vendor-registry rule. A validator-guided second pass therefore reduces manual review without silently changing source facts, while keeping deterministic code—not the model—as the final acceptance authority.

================

Option B identifies the missing executable capability. Defining specialized agents makes their configurations available, but the coordinator must still be permitted to call the tool that invokes them. Without that tool, Claude can describe an intended delegation in ordinary text but cannot create a subagent execution.

The current Claude Agent SDK documentation requires " Agent " in allowedTools to auto-approve subagent invocations. The tool was renamed from " Task " to " Agent " in Claude Code 2.1.63, so the terminology in the original candidate question required correction. Older integrations may still expose " Task " in initialization or permission records.

Option A is unlikely because properly written AgentDefinition.description values already tell Claude when each agent should be used. Option C misinterprets context isolation: the parent supplies the subagent’s assignment through the Agent tool’s prompt, and no additional automatic forwarding setting is required. Option D would normally produce truncation evidence or a max_tokens stop reason rather than silent absence of every invocation. The coordinator needs both agent definitions and permission to use the invocation tool.

================

Option B follows the Claude Agent SDK’s default context-isolation model. A newly spawned subagent receives a fresh context window and does not automatically inherit the parent’s conversation history or previous tool results. The coordinator must therefore include the information required for synthesis directly in the spawning prompt, preferably using clearly separated structured sections for web findings, document findings, source metadata, conflicts, and unresolved questions.

Anthropic’s official SDK subagent documentation states that the Agent tool’s prompt string is the content passed from the parent to the new subagent. It specifically advises including required file paths, errors, and decisions in that prompt because parent context is not inherited.

Option A could work only if the application had deliberately implemented and authorized such a shared-memory architecture. The question establishes no such mechanism, and reference identifiers alone provide no evidence to the subagent. Option C introduces a callback protocol that is unnecessary for a normal handoff. Option D is incorrect because subagent isolation expressly prevents automatic inheritance. “Complete findings” means the complete evidence needed for synthesis, not every intermediate search trace or irrelevant tool result.

================

Option B introduces an evaluator-and-refinement loop at the correct orchestration layer. The coordinator already owns the research plan and delegation decisions, so it should inspect the synthesis result against the required questions, identify coverage gaps, and issue focused follow-up assignments. Anthropic’s description of its multi-agent research system follows this pattern: the lead agent synthesizes returned findings, determines whether additional research is required, and creates new subagents or refines its strategy before producing the final result. Increasing the initial query breadth, option A, may generate additional irrelevant material and cannot guarantee that unforeseen gaps will be covered. Option C merely documents the incompleteness instead of correcting it. Option D weakens role separation by giving the synthesis agent search capabilities, increasing tool complexity and bypassing the coordinator’s centralized tracking. Targeted re-delegation preserves specialized responsibilities and creates an observable sequence of research, evaluation, refinement, and resynthesis. The coordinator should also maintain explicit coverage criteria and limit the number of refinement rounds so the system improves completeness without entering an uncontrolled research loop.

================

The failure is caused by an underspecified extraction policy rather than an inadequate JSON structure. “Extract all skills mentioned” does not define whether coordinated phrases should be split, whether inferred capabilities qualify, or what level of specificity constitutes one skill. Few-shot examples can demonstrate all three decisions using concrete inputs and expected outputs.

Anthropic identifies examples as one of the most effective ways to improve output accuracy and consistency because they communicate behavior more precisely than abstract instructions alone. Representative examples can show that “Python and SQL” becomes two entries, that an unstated skill must not be inferred from a job title, and that broad descriptions should not be decomposed into dozens of speculative micro-skills. ( https://docs.anthropic.com/en/docs/about-claude/use-case-guides/ticket-routing )

Option A adds provenance and confidence metadata but does not define the correct extraction granularity. Option C addresses explicitness and splitting, but the arbitrary 10–20 limit can truncate documents containing more than 20 legitimate skills or force padding when fewer than 10 appear. Option D is useful for canonicalization and deduplication, but post-processing cannot reliably remove plausible implied skills or determine how the original phrase should have been interpreted.

The strongest prompt should combine explicit rules with diverse few-shot examples covering normal cases, compound phrases, implied information, duplicates, and unusually long or short skill lists.

Official references/topics: Few-Shot Prompting, Output Consistency, Explicit Extraction Criteria, Representative Examples.

The document contains multiple factually valid values whose applicability depends on chronology and legal context. Collapsing those values into a single scalar field discards essential provenance. Option B corrects the data model by representing each term as a structured record containing the extracted value, source location, document or amendment identifier, and effective date.

Anthropic’s Structured Outputs feature is designed for data-extraction use cases in which nested objects and arrays must conform to a defined JSON Schema. ( https://platform.claude.com/docs/en/build-with-claude/structured-outputs ) Anthropic also recommends grounding factual outputs in direct source material and making claims auditable through supporting evidence. ( https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/reduce-hallucinations ) A provenance-aware schema applies both principles: it retains the original clause and the amendment instead of forcing Claude to resolve a potentially complex legal precedence question during extraction.

Option A is destructive because removing superseded text prevents auditing and may eliminate terms still relevant to earlier periods. Option C oversimplifies amendment logic; the newest document is not automatically controlling for every date, jurisdiction, or clause. Option D identifies risk but does not improve the extracted representation and unnecessarily sends all amendment cases to manual review.

After extraction, deterministic business logic can select the value effective on a requested date while retaining the complete contractual history.

Official references/topics: Structured Outputs; Nested Schema Design; Provenance and Source Grounding; Temporal Data Modeling.

An unchanged retry repeats the same task specification and therefore commonly reproduces the same invalid interpretation. The validator has generated precise corrective information— quantity requires a float, but the model returned the range string 2 to 3 . Supplying that error in a follow-up turn converts a generic retry into an iterative repair operation.

Anthropic identifies iterative refinement as a method for detecting and correcting inconsistencies by feeding an earlier output back into a subsequent request with targeted instructions. ( https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/reduce-hallucinations ) Option A applies that pattern directly. Claude receives the invalid output, the exact Pydantic error, and an instruction to return a schema-compliant correction. The application should cap retries, retain the original source, and escalate cases that cannot be represented without information loss.

Option B does not guarantee correct formatting; lower temperature may make the same wrong output more repeatable. Option C can be valuable for systematic OCR or source-format problems, but it is unnecessarily broad when the immediate failure is already described by the validator. Option D increases cost and complexity without first using the actionable feedback available from the existing validation layer.

For supported models, native Structured Outputs should also be considered because they guarantee schema-conformant JSON and can prevent many Pydantic shape failures before they occur. ( https://platform.claude.com/docs/en/build-with-claude/structured-outputs )

Official references/topics: Iterative Refinement; Validation-Error Feedback; Bounded Retry Loops; Structured Outputs.

Option A is the only configuration that establishes both required limits inside Claude Code. The official CLI reference defines --max-turns as the maximum number of agentic turns permitted in print mode; Claude Code exits with an error when that limit is reached. It defines --max-budget-usd as the maximum dollar expenditure on API calls before execution stops, including applicable subagent expenditure.

These controls address different failure dimensions. The turn limit prevents an investigation from continuing through excessive read-search-analyze cycles, while the budget limit stops an invocation whose expensive turns consume the monetary allowance before reaching the turn ceiling. Supplying both therefore creates an effective per-run boundary.

Option B controls how permission requests are handled; it does not limit the number of already permitted tool calls or API expenditure. Option C applies an external wall-clock timeout and merely observes cost, violating the requirement that Claude Code itself enforce both limits. Option D lowers expected cost per turn but creates no hard ceiling: the agent can still perform many iterations and exceed the intended budget. A cheaper model also does not guarantee that the review will terminate within a predictable number of turns.

================

Option C converts the linear pipeline into a controlled iterative research loop. The document-analysis agent is best positioned to identify precisely what the retrieved evidence fails to answer. It should return structured gaps containing the missing question, evidence already examined, preferred source characteristics, and the coverage criterion that remains unsatisfied. The coordinator can then issue focused searches and resubmit the new material for analysis.

Anthropic’s multi-agent research architecture uses a lead agent to decompose work, coordinate research agents, assess returned information, and continue investigation when further evidence is required. The guidance also stresses clear objectives, output formats, source requirements, and task boundaries to prevent gaps and duplicated work.

Option A may improve initial coverage but cannot anticipate every deficiency revealed only after sources are examined. Option B documents incompleteness rather than correcting it. Option D retrieves more information but does not ensure that the new evidence is analyzed and tested against the original gap. The loop in Option C establishes an explicit completion condition and preserves specialization: analysis identifies the gap, the coordinator orchestrates, search agents retrieve evidence, and analysis verifies whether the gap has actually been closed.

================

Option A follows the MCP error contract. An error originating during execution of a valid tool call—such as an API failure, input-validation problem, or business-logic failure—should be returned inside the tool result with isError: true. The content should explain what happened and, where possible, provide actionable recovery guidance.

The official MCP tools specification distinguishes tool-execution errors from protocol-level errors and specifies that execution failures are reported through tool results using isError: true. Anthropic’s tool-using agent tutorial provides the equivalent Claude API pattern using is_error: true, allowing Claude to retry with corrected input, request clarification, or explain the limitation.

Option B falsely represents a failed operation as successful, weakening reliable failure detection. Option C deprives the agent of the information required to determine an appropriate recovery action. Option D may be converted into a tool error by some SDK runners, but uncaught exceptions are not the MCP-level response contract. The strongest implementation returns a concise, sanitized, actionable error result and separately records detailed diagnostics in server logs.

Option A uses the dedicated control surface for managed Claude Code Review. Anthropic’s Code Review documentation states that a root-level REVIEW.md is injected into every review agent as the highest-priority instruction block. It can define skip paths, suppress categories already enforced by CI, recalibrate severity, cap nit volume, and require source evidence before reporting particular findings. The documentation explicitly identifies generated code, linting, and verification requirements as appropriate uses.

Option B configures a self-hosted GitHub Actions workflow, but the scenario concerns the separate managed Code Review service running on Anthropic’s infrastructure. Instructions in that workflow do not control the managed reviewer. Option C provides useful general project context, but CLAUDE.md has lower review-specific authority: managed Code Review treats violations of it primarily as nit-level findings. REVIEW.md is the stronger and more precise mechanism for changing what the managed service reports. The file should skip src/gen/**, suppress style issues already enforced by CI, and require concrete behavioral evidence for rendering-helper warnings while continuing to report verified correctness and security defects.

================

Option A parallelizes independent precedent analysis while preserving centralized control. The coordinator can partition the 12 precedents into balanced groups, provide each worker with identical extraction and citation requirements, monitor completion or failure, and aggregate the structured results before invoking synthesis.

Anthropic’s multi-agent research architecture uses an orchestrator-worker pattern in which a lead agent coordinates specialized subagents operating in parallel. Parallel execution is valuable when tasks are substantially independent, as each precedent can be analyzed without waiting for the preceding case. Maintaining the fan-out at the coordinator also produces a clear execution trace showing each assignment, status, and returned result.

Option B introduces nested delegation and makes tool usage, permissions, failures, and costs harder for the coordinator to observe. Option C compounds those problems through recursive spawning and risks excessive agent and token consumption. Option D may be appropriate for a large distributed processing platform, but it adds infrastructure without inherently improving the coordinator’s reasoning-level observability or defining how results are associated with the case. Coordinator-managed parallel workers provide the required latency reduction with the simplest debuggable architecture.

================

The search must first establish the function’s complete naming surface. Reading the core definition and every wrapper or re-export reveals aliases such as computeOrderTax , names introduced through intermediate modules, and potentially different import paths. Once those names are known, the agent can search the entire codebase for each exposed identifier and inspect the resulting call sites.

Claude Code’s Grep tool searches patterns inside file contents, whereas Read provides the surrounding implementation needed to determine whether a wrapper delegates to, renames, or conditionally invokes the original function. These tools are complementary: Read establishes semantic identity; Grep provides broad reference discovery. ( https://code.claude.com/docs/en/tools-reference?utm_source=chatgpt.com )

Option B misses every caller using a wrapper alias. Option A may find importing files, but import-level discovery is indirect and can miss re-exports, namespace imports, dependency injection, or calls made through a locally renamed symbol. It also requires unnecessary manual inspection of every consumer of the module. Option D relies on documentation, which may be incomplete or stale and cannot prove that all executable references have been found.

Before removal, the agent should also inspect tests, dynamic registrations, configuration-driven references, and generated code where relevant. The defining requirement is to map the alias chain first and then search all discovered public names.

Official references/topics: Read and Grep Tool Behavior; Symbol and Alias Discovery; Codebase Reference Tracing.

The two statistics cannot be compared correctly without temporal metadata. Option A preserves when each value was measured, not merely when its document was retrieved. The structured record should ideally distinguish publication date, observation period, geographic scope, population, methodology, unit, and metric definition. The synthesis agent can then determine whether the figures represent a trend, conflicting measurements of the same period, or incomparable populations.

Anthropic’s multi-agent research guidance emphasizes specifying output formats and source requirements so downstream agents receive the context required for accurate synthesis. Its structured-output capability enables these provenance fields to be required and schema validated.

Option B removes valuable historical evidence and still does not guarantee that returned sources describe the same measurement period. Option C assumes newer automatically means more reliable and could discard an authoritative historical baseline. Option D preserves older material but imposes an interpretation without examining whether methodology, geography, or definitions changed. Explicit temporal and methodological metadata allows the synthesis agent to state a defensible conclusion such as apparent growth from 18% in 2021 to 35% in 2024 while preserving any comparability caveats.

================

Option C identifies the architectural contradiction. A specialized subagent’s role prompt says what work it should perform, but granting it every tool simultaneously signals that unrelated actions are available and potentially legitimate. The synthesis agent can therefore interpret web search as a permissible way to fill gaps, while the report generator may invoke document-analysis tools even though those responsibilities belong elsewhere. Anthropic’s Agent SDK documentation describes subagents as focused workers with tailored instructions and explicitly supports restricting each subagent to specific tools; it notes that tool restrictions reduce unintended actions. There is no documented universal threshold at which choosing among 18 tools becomes unreliable, so option B invents a “four or five tools” limit. Context consumption in option A may affect efficiency, but it does not directly explain the role-specific cross-calling pattern. Option D is also incorrect because the observed behavior occurs after delegation, inside agents that already possess the tools. The remedy is least-capability configuration: give the web agent search tools, the document agent document tools, the synthesis agent only the inputs and utilities required to combine findings, and the report agent formatting or file-output tools. Aligning role, description, and tool allowlist removes the conflicting affordances.

================

Option D supplies the missing repository-specific knowledge before Claude evaluates the code. The project’s CLAUDE.md should state that force-unwrapping is permitted within test paths, explain the coordinator-class architecture, and identify the internally maintained deprecated module as an approved dependency. These instructions should be concise and scoped carefully so exceptions do not become global permissions.

Anthropic’s CLAUDE.md documentation defines project CLAUDE.md files as persistent context for coding standards, architecture, workflows, and team conventions. They are loaded at the beginning of applicable sessions, preventing the organization from repeatedly supplying the same corrections. Anthropic also recommends recording information that Claude should know whenever it works in the repository.

Option A filters generated findings after tokens have already been consumed and can hide genuine issues containing similar terminology. Option B removes valuable surrounding context and would likely increase false positives and missed cross-file defects. Option C distributes project knowledge across individual source lines, creates maintenance overhead, and requires custom preprocessing. Centralized, narrowly scoped CLAUDE.md instructions address the root cause and improve the initial review judgment instead of repairing its output afterward.

================

Option A preserves disagreement as meaningful evidence. The report should identify the two estimates separately, explain that they arise from different methodologies and source types, retain the peer-reviewed study’s stated confidence interval, and classify the market size as contested rather than manufacturing false agreement. It may then explain what additional evidence would resolve the discrepancy.

Anthropic’s research prompting guidance recommends developing competing hypotheses, tracking confidence, verifying across sources, and retaining structured research notes. This supports calibrated synthesis rather than arbitrary selection or vague hedging.

Option B discards potentially important minority evidence and incorrectly treats corroboration count as equivalent to reliability. Option C creates numerical precision unsupported by the original sources; confidence scores from different agents are not automatically comparable, and averaging incompatible estimates can be meaningless. Option D introduces survivorship bias by suppressing uncertainty before synthesis. A systematic reporting structure distinguishes consensus, disagreement, evidence quality, methodological limitations, and unresolved questions. That produces an actionable briefing without overstating certainty or weakening every conclusion with generic qualifications.

================

The failure is caused by missing evidence, not insufficient reasoning over the supplied evidence. A static prompt containing only changed files cannot reliably identify callers, configuration dependencies, generated interfaces, or indirect relationships located elsewhere in the repository. Asking Claude to reason more deeply cannot recover code that it was never given.

Option A converts the review into a bounded agentic loop. Claude can search for symbol references, read relevant callers, inspect type definitions, and follow newly discovered dependencies before validating a potential defect. Anthropic describes the Claude Code agentic loop as gathering context, taking action, verifying results, and repeating based on tool feedback. A turn limit preserves predictable cost and execution time.

Option C improves coverage but imposes an arbitrary two-hop boundary and depends on the accuracy of a precomputed graph, which may omit dynamic imports, reflection, generated code, configuration references, or language-specific call relationships. Option D creates duplicated context and aggregation complexity while still limiting each reviewer to predetermined dependents. Option B changes the reasoning instructions but supplies no mechanism for checking unchanged files. Tool-enabled, just-in-time retrieval is therefore the most adaptable and reliable architecture for cross-file review.

================

Option A uses the limited review capacity as a risk-ranking mechanism rather than spending it uniformly. JSON Schema validation can prove that an output has the expected types and structure, but it cannot detect a semantically misplaced value such as a duration stored as an ingredient quantity. Field-level confidence can identify the exact parts of a record that warrant inspection, provided those scores are calibrated against labeled examples rather than trusted at face value. The labeled validation set must mirror the production distribution and include edge cases; Anthropic’s evaluation guidance explicitly recommends task-specific evaluations, representative distributions, measurable criteria, and automated grading where possible. Calibration then converts raw confidence into an empirically tested estimate of error risk, allowing reviewers to inspect the lowest-confidence records or fields first. Option C, random sampling, is useful for unbiased quality measurement and discovering new failure modes, but it does not maximize error detection within a fixed 20 percent review budget. Options B and D target narrow proxies—layout anomalies and missing required values—while the observed errors pass structural validation and may occur in ordinary-looking documents. The operational design should combine calibrated risk-based review with a smaller random audit sample to detect drift and overconfidence.

================

The agent is behaving inconsistently because every failure is represented identically. “Operation failed” contains no information about permanence, user correctability, authorization, or whether another attempt is likely to succeed. Adding structured fields converts the error into an actionable interface contract.

Anthropic instructs tool implementations to mark failures using an error flag and return information Claude can use to retry with corrected input, ask for clarification, or explain a limitation. Tool design should expose sufficient detail for the model to choose the correct next action rather than forcing it to infer the cause from a generic message. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent?utm_source=chatgpt.com )

With error_category , isRetryable , and a causal description, the agent can retry transient network failures, request corrected identifiers for validation errors, and escalate or report permission failures without pointless repetitions. Option B retries permanent validation and permission failures unnecessarily. Option C adds another tool call and failure point merely to classify information the original tool already possesses. Option D relies on parsing variable text and examples rather than providing explicit machine-readable semantics.

The tool should preserve isError: true , return a stable structured error object, include a safe customer-facing message where appropriate, and avoid exposing internal secrets or stack traces.

Official references/topics: MCP error contracts, actionable tool results, retryability metadata, agent-computer interface design.

The defects are coupled, so changing all three simultaneously would make it difficult to determine which modification caused an improvement or regression. Option C establishes a controlled sequence: correct the foundational column geometry, verify the resulting layout, format dates within the stabilized columns, and finally tune page breaks using the resulting content heights.

Anthropic recommends tight feedback loops and early course correction. It also advises supplying Claude with an executable or observable verification mechanism, such as a test, build result, generated fixture, or screenshot comparison. Claude can then make a focused change, inspect the output, and iterate until that specific condition is satisfied. ( https://code.claude.com/docs/en/best-practices )

Option A discards useful context from the functioning database implementation. Option B changes multiple interacting variables in one pass, making failures harder to isolate. Option D provides a useful visual target but does not replace precise technical constraints or incremental verification.

Each stage should have explicit acceptance criteria—for example, minimum column widths, expected date strings, and page-break fixtures using short and long content. Once a stage passes, its test becomes a regression guard for subsequent changes.

Official references/topics: Incremental Refinement; Tight Feedback Loops; Observable Verification; Regression Control.

Option A preserves provenance as first-class data throughout the pipeline. Each finding should contain the summarized claim, supporting excerpt, source identifier, URL or document title, and location information such as a page or content-block index. The synthesis agent can combine findings without severing the association between evidence and source, while the report generator can render citations directly from the structured records. Anthropic’s Citations documentation explains that reliable citations identify the supporting passage and its precise source location, including PDF page ranges or content-block indices. Passing all raw output, option B, preserves evidence but introduces excessive context and makes source selection harder. Inline references in prose, option C, are vulnerable to being altered, omitted, or detached from claims during subsequent summarization. Option D repeats research after report generation and may locate a different source rather than the evidence originally used. A structured provenance contract should therefore be required in every subagent’s output and validated at each handoff. The report generator should reject or flag factual claims that lack an associated evidence record instead of inventing or retrospectively reconstructing citations.

================

Stratified random sampling provides both an ongoing quality-control mechanism and an unbiased measurement framework. By reviewing a fixed proportion of high-confidence outputs across meaningful strata—such as document type, field, source format, and business risk—the organization can estimate the residual error rate, compare performance across releases, and discover failure patterns that were not anticipated when existing rules were designed.

Anthropic recommends measurable success criteria and evaluations that mirror the real-world task distribution, including edge cases. Evaluation volume and repeatability are important because improvements must be demonstrated empirically rather than inferred from isolated examples. ( https://docs.anthropic.com/en/docs/build-with-claude/develop-tests ) A weekly sampling program creates a stable benchmark and allows confidence intervals, trend analysis, regression detection, and error-taxonomy updates.

Option A detects only disagreements between stochastic extractions. Two attempts may produce the same plausible but incorrect answer, so agreement is not equivalent to factual correctness. Option B addresses known patterns but will miss new failure modes and may generate excessive false positives. Option C actually lowers the review threshold in the wrong direction: documents between 70% and 85% would be treated as automated rather than reviewed if the routing rule remains “below threshold,” and changing thresholds alone does not measure high-confidence error prevalence.

Official references/topics: Evaluation Design; Representative Test Distributions; Continuous Reliability Measurement; Human-in-the-Loop Sampling.