Anthropic CCAR-F Dumps

The Claude Messages API is stateless. Each API request must include the conversation history that Claude requires for the current response. If the application sends only the customer’s third verification answer, Claude does not automatically retrieve the earlier turns containing the customer’s name and previous answers. From the model’s perspective, that information is absent.

Anthropic’s Messages API documentation states that applications must send the full conversational history to build a multi-turn interaction. The correct implementation appends each user message and assistant response to the messages array and resends the accumulated sequence on every subsequent request. ( )

Option A cannot restore information that was omitted from the request. Instructions to “remember” do not create server-side conversational state. Option C describes application-specific behavior for which the scenario provides no evidence. Option D is factually incorrect: Claude does not have a default two-turn retention limit. Its effective conversational awareness depends on the messages provided and the model’s context window.

For a verification workflow, the application should also persist structured verification state separately from prose history. That state may include completed checks, pending checks, attempt counts, and a verified customer identifier. This improves reliability while the conversational transcript preserves the natural interaction.

Official references/topics: Stateless Messages API, multi-turn history construction, structured workflow state, conversational continuity.

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. ( )

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. ( ) 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.

Resuming the existing subagent preserves the expensive investigative context: files already inspected, data-flow relationships, hypotheses, and intermediate conclusions. Anthropic documents that session history contains prompts, tool calls, tool results, and responses, allowing an interrupted investigation to continue with its prior analysis intact. ( ) Subagent transcripts also persist within their parent session and can be resumed after an interruption or restart. ( )

The engineer must nevertheless disclose the renamed utility functions. Anthropic explicitly distinguishes conversation persistence from filesystem persistence: resuming restores what the agent previously knew, but it does not freeze or snapshot the repository. ( ) Without the update, the subagent may search for obsolete symbols, misinterpret broken references, or rely on stale file paths.

Option A loses the detailed transcript and replaces it with a necessarily compressed summary. Option B preserves context but conceals a material repository change. Option D duplicates a large transcript inside a new context, increasing token consumption without providing any advantage over native resume functionality.

The resumed prompt should name the renamed functions, identify the merge or affected files, and instruct the subagent to re-read only the changed areas before continuing its broader exploration.

Official references/topics: Session Resume; Persistent Subagent Transcripts; Repository Drift; Targeted Context Refresh.

The primary risk is not implementation difficulty but incomplete requirements. Production caching introduces decisions involving invalidation, stale-data tolerance, cache keys, tenant boundaries, serialization, stampede prevention, failure behavior, observability, deployment topology, and consistency expectations. Implementing Redis with a five-minute TTL before resolving these questions can produce a technically functional but operationally unsafe design.

Anthropic recommends having Claude interview the user before beginning a larger feature when important requirements remain uncertain. The AskUserQuestion workflow is intended to surface technical implementation concerns, edge cases, trade-offs, and assumptions the user may not have considered. Anthropic further recommends converting the resulting answers into a self-contained specification with explicit scope and an end-to-end verification step. ( )

Option B provides useful codebase context but postpones requirement discovery. Option C creates avoidable rework by allowing architecture to emerge from production failures. Option D documents uncertainty but delegates unresolved design choices during implementation, when they may already constrain the code.

After the interview produces a caching specification, Claude can enter plan mode to inspect the endpoint and map those requirements onto the existing architecture before implementation.

Official references/topics: Requirements Interviewing; AskUserQuestion; Specification Development; Edge-Case and Trade-Off Discovery.

Option B teaches Claude the actual decision boundaries behind the team’s judgments. Contrasting examples can demonstrate why one apparent security pattern is acceptable within the organization’s deployment controls while a superficially similar implementation is genuinely unsafe. The same technique can distinguish established style conventions from deviations and intentional performance trade-offs from accidental inefficiencies.

Anthropic identifies relevant, diverse, and clearly structured examples as one of the most reliable ways to improve Claude’s accuracy and consistency. Its official prompting guidance recommends examples that closely mirror the production task while covering important variations and edge cases. This encourages generalization based on demonstrated criteria instead of memorization of prohibited wording.

Option A can suppress legitimate findings merely because they contain a selected keyword. Option C will become lengthy, difficult to maintain, and incapable of enumerating every future code variation. Option D is too vague and may reduce recall by discouraging Claude from reporting uncertain but genuine defects. Few-shot contrasts provide precise, maintainable behavioral guidance without imposing a blanket suppression policy.

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

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. ( )

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 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 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.

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

The prompt’s conservative reporting policy is directly causing the low recall. Claude may discover a legitimate race condition during analysis but suppress it because it cannot satisfy the instruction to report only issues about which it is certain. Option C separates two objectives that should not be conflated: broad defect discovery and strict acceptance filtering.

Anthropic’s current code-review prompting guidance explicitly recommends reporting every issue, including uncertain or lower-severity findings, assigning confidence and severity metadata, and allowing a separate verification stage to filter them. This maximizes recall while retaining control over developer-facing noise.

Option A leaves the suppression policy intact, so additional examples cannot guarantee that discovered problems will be reported. Option B improves recall but relies on historical category-level suppression, which can discard genuine findings that happen to belong to noisy categories. Option D can improve analysis quality but does not remove the instruction responsible for withholding findings. A dedicated finding stage followed by an independently configurable verification or thresholding stage produces measurable recall and precision controls without forcing one model call to optimize competing objectives.

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

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.

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

MCP prompts are exposed as user-invoked commands rather than autonomous tools or permanently loaded system instructions. Claude Code dynamically discovers prompts from connected MCP servers and displays them in the command list using the naming convention /mcp__servername__promptname .

Arguments are supplied as space-separated values after the command. When executed, the MCP server resolves the prompt and its returned content is injected into the active conversation. Anthropic’s official documentation provides examples such as /mcp__github__list_prs and /mcp__jira__create_issue " Bug in login flow " high . ( )

Option A would consume context continuously and incorrectly treat optional workflow templates as mandatory system instructions. Option B confuses MCP prompts with MCP tools: tools are model-callable operations, while prompts are reusable prompt templates invoked as commands. Option C describes MCP resources, which can be referenced and attached but are a distinct MCP capability.

For the stated server, the team could invoke commands such as /mcp__devops__deploy_checklist or /mcp__devops__incident_response service-name . The exact server segment is derived from the configured server name, with normalization applied where necessary.

Official references/topics: MCP Prompts; Dynamic Prompt Discovery; MCP Slash-Command Naming; Prompt Arguments.

Option C is the only approach that guarantees the required terminal condition independently of the model’s behavior. When the agent loop stops, the orchestration layer evaluates the recorded outcome. If neither a successful resolution nor a confirmed human escalation occurred, deterministic application code invokes escalate_to_human using the information accumulated before termination.

The max_turns limit is a host-controlled safety boundary. Once that boundary is reached, the model may no longer have an opportunity to follow a prompt instruction or make another tool call. Therefore, the required fallback cannot depend entirely on Claude deciding to escalate before its remaining turns are exhausted.

Option A escalates based on an arbitrary 80% threshold and may prematurely terminate cases that could have been resolved successfully within the remaining budget. Option B provides additional turn capacity but does not guarantee that the second agent will complete its work or escalate before its own limit is reached. Option D remains probabilistic and cannot operate after an unexpected termination has already occurred.

The orchestration fallback should be idempotent, ensuring that repeated completion checks cannot create duplicate escalation records. It should also include verified customer information, relevant order data, completed actions, failure reasons, and the unresolved request in the handoff payload.

Official references/topics: Agent-loop termination, deterministic fallback orchestration, terminal-state validation, human handoff guarantees.

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.

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

The --system-prompt flag replaces Claude Code’s complete default system prompt. Although this does not technically remove the available tools, it discards the default coding-agent guidance that tells Claude how to gather repository context, navigate code, use tools, and verify findings. The replacement prompt says only to analyze the supplied diff, so the observed diff-only behaviour is consistent with the configured instructions.

Option B preserves the standard Claude Code identity and tool guidance while adding the custom review criteria. The Claude Code CLI reference states that --append-system-prompt appends instructions to the default prompt, whereas --system-prompt replaces it. Anthropic specifically recommends appending when Claude should remain a coding assistant that follows additional per-invocation rules.

Option A is incorrect because print mode does not inherently disable Read, Glob, or Grep; --allowedTools restricts or pre-authorizes tools but does not restore overwritten behavioural guidance. Option C is incorrect because replacement system prompts remain compatible with tools, although the replacement must supply suitable tool instructions. Option D changes where the diff appears but does not restore Claude Code’s default code-navigation behaviour. Appending the review instructions directly addresses the configuration error.

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

Forking is specifically designed for exploring alternative directions from a shared body of prior analysis. Each fork starts with a copy of yesterday’s conversation history, including the files read, architectural observations, dependency findings, and decisions already recorded. The microservice approach and the in-place refactoring approach can then develop independently under separate session IDs.

Anthropic’s Agent SDK documentation states that a fork creates a new session from a copy of the original history while leaving the original session unchanged. Each resulting session can subsequently be resumed independently. The documented implementation combines resume with fork_session=True in Python or forkSession: true in TypeScript. ( )

Option B allows conclusions, assumptions, and proposed edits from the first approach to contaminate the evaluation of the second. Option C preserves context for only one branch and forces the engineer to reconstruct context manually for the other. Option D discards the detailed analysis already captured in the session and depends on potentially incomplete summaries.

Two forks provide equivalent starting conditions, preserve the parent investigation, and support a fair comparison of scope, migration risk, operational complexity, and required code changes. Filesystem edits should still be isolated through worktrees or checkpointing because session forking branches conversation history, not the working directory.

Official references/topics: Agent SDK Sessions; Session Forking; Alternative-Approach Exploration; Context Preservation.

Forking the existing analysis session creates independent continuations that inherit the accumulated conversation context. Each branch begins with the same understanding of the service module, request flow, source files, and error-handling patterns, but subsequent work on one testing strategy does not alter the other branch or the original session.

Anthropic’s Agent SDK documentation states that sessions can be resumed with their full context and forked to explore different approaches. In the SDK, enabling fork_session while resuming causes the continuation to receive a new session identifier rather than modifying the original session. ( )

Option B wastes time, tokens, and tool calls by requiring both new sessions to rebuild the same 23-file analysis. Option C mixes two experimental implementations into one conversation, increasing the risk that assumptions, edits, or conclusions from the first strategy influence the second. Option D preserves only a manually selected summary, which may omit details contained in the full session history.

The appropriate design is to create one fork for the end-to-end strategy and another fork for the snapshot strategy. The original analysis remains a stable parent, while each child session develops and evaluates its approach independently.

Official references/topics: Agent SDK Sessions, Session Forking, Context Preservation, Alternative-Approach Evaluation.

Option B correctly separates asynchronous bulk work from latency-sensitive operational work. Anthropic describes the Message Batches API as a cost-effective asynchronous service for high-volume requests that do not require immediate responses. Batch requests are processed independently, normally finish within an hour, may remain pending for up to 24 hours, and are billed at 50 percent of standard API prices. Those characteristics fit standard monthly reports because they are archived after processing and have no immediate business deadline. Urgent exception reports, however, must trigger an alert within 30 minutes. The batch service cannot guarantee that deadline, even if many batches finish quickly; a workload should not use typical completion time as a service-level guarantee. Routing exceptions through the synchronous Messages API provides the real-time response path needed for alerting, while the shared JSON schema keeps downstream records consistent across both routes. Option A knowingly permits delayed alerts. Option C introduces an hourly submission delay before processing even begins. Option D meets latency requirements but wastes the batch discount on non-urgent reports. A routing layer based on document priority therefore satisfies both the cost objective and the business deadline without changing the extraction contract.

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

Option C identifies the fundamental trade-off introduced by batch processing: lower cost in exchange for asynchronous completion and potentially substantial latency. Anthropic states that most Message Batches complete within one hour, but results may become available only when all requests finish or after 24 hours, whichever occurs first. Therefore, the workflow must remain useful even if security findings arrive considerably later than they would through synchronous requests.

The reviews are explicitly non-blocking, so batch processing can be suitable if developers can still act on delayed findings through follow-up commits. Option B describes an implementation requirement because batch results may be returned out of submission order, but Anthropic provides a deterministic solution through each request’s unique custom_id. Option A incorrectly focuses on near-instant feedback, which batch processing does not provide. Option D is not decisive because batches support independent Messages API requests containing system prompts, tool use, and multi-turn conversation content. The primary decision is therefore whether the maximum practical feedback delay is acceptable to the development workflow. Anthropic Message Batches documentation

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

The investigation contains several bounded research questions that can be delegated independently: locating the complete test suite, tracing payment and refund flows, identifying conditional branches, and mapping external dependencies. Each subagent can read the relevant files in its own context and return a focused summary to the coordinating agent.

Anthropic recommends subagents for codebase exploration because extensive file reading rapidly consumes the main context window. Subagents isolate that volume and return only their conclusions, preserving the main conversation for synthesis and implementation. ( ) Anthropic also describes parallel research as appropriate when separate investigation paths can proceed independently and the main agent can synthesize the results afterward. ( )

Option B sacrifices the current conversational state and requires reconstruction after /clear . Option C may reduce token usage, but isolated text matches cannot reliably reveal full execution paths, indirect calls, or test coverage relationships. Option D converts the current analysis into a single lossy summary and risks omitting details needed later.

Option A directly addresses the demonstrated context degradation while retaining a high-level coordinating thread. The subagent prompts should be narrowly scoped and require concrete outputs such as file paths, uncovered branches, call-chain evidence, and existing tests associated with each flow.

Official references/topics: Subagent Context Isolation; Parallel Research; Context Preservation; Coordinated Codebase Analysis.

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.

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

Option C applies the two native stopping controls required by the question. Anthropic’s Claude Code CLI reference defines --max-turns as the maximum number of agentic turns permitted in print mode and --max-budget-usd as the maximum API expenditure for that invocation. When the turn limit is reached, the run exits with an error. Spending by subagents counts toward the budget cap, and current Claude Code versions stop remaining background subagents when the limit is reached. These flags therefore control the complete invocation rather than merely one model request.

Option A lowers expected cost per iteration but establishes no hard ceiling on either iterations or total expenditure. Option B limits wall-clock execution at the CI-runner level and only observes spending retrospectively; it does not enforce a Claude Code budget. Option D controls permission behavior, not iteration count, execution time, or token spending. The pipeline should use both flags, capture the resulting nonzero exit or structured error status, and report whether a review ended normally or was terminated by a configured operational limit.

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

Option A is correct because the failure results from excessive output volume, not from JSON or tool use. Anthropic documents that max_tokens is a hard output ceiling and that a response stopped at this limit reports stop_reason: " max_tokens " . Its tool-streaming guidance also warns that generation can stop midway through a tool parameter, leaving partial JSON that must not be treated as complete. Splitting the pull request into bounded file groups limits the number of findings produced by each call, preserves the report_findings schema, and allows the pipeline to validate every response independently before merging and deduplicating the arrays. Shared dependency context can still be included when cross-file analysis is required.

Option B only postpones the failure because the model’s output maximum remains finite. Option C abandons the structured contract and makes deterministic parsing less reliable. Option D changes the review requirements by suppressing potentially valuable lower-severity findings, while the retried request could still reach the same limit. Controlled partitioning followed by deterministic aggregation is therefore the most reliable and scalable design. Anthropic stop-reason guidance and tool-streaming guidance .

The implementation approach is unresolved and carries architectural consequences. WebSockets, Server-Sent Events, and polling differ in connection lifecycle, bidirectional communication, proxy compatibility, scaling requirements, deployment topology, reconnection behavior, and operational complexity. Claude should therefore inspect the existing application and infrastructure before modifying code.

Anthropic recommends separating exploration and planning from implementation when the approach is uncertain, the work affects multiple files, or the developer is unfamiliar with the relevant architecture. In plan mode, Claude can read files and analyze the system without making changes, produce a detailed proposal, and allow the developer or team to review the plan before execution. ( )

Option A commits to polling before determining whether its latency and load characteristics meet the requirement. Option B delegates a consequential architectural decision and immediate implementation to a single execution step without a review checkpoint. Option D prematurely selects the most infrastructure-sensitive option and assumes later refactoring will be inexpensive.

Option C creates the correct sequence: examine the frontend and backend architecture, document requirements, compare alternatives, identify infrastructure constraints, obtain approval, and only then implement the selected design with appropriate tests and observability.

Official references/topics: Plan mode, explore–plan–implement workflow, architectural trade-off analysis, review checkpoints.

A mandatory compliance threshold must be enforced outside probabilistic model reasoning. A PreToolUse hook can inspect every attempted process_refund call before execution, compare its amount with the $500 threshold, and deny the call when the limit is exceeded. The host application can then create the human-escalation case using the validated customer and order context.

Anthropic describes hooks as deterministic controls that ensure required actions occur instead of relying on the model to choose them. Agent SDK documentation confirms that a single denying PreToolUse hook blocks the tool call, including MCP tools matched through their qualified tool names. ( )

Options A and B improve expected behavior but cannot guarantee compliance. The stated production failure rate demonstrates that prompting alone is insufficient. Option C prevents the refund from completing, but the subsequent escalation still depends on Claude correctly interpreting the returned error and invoking the human tool. It therefore enforces the financial block but not the complete escalation requirement.

Option D enforces both sides of the policy at the orchestration boundary: deny the unauthorized action and route the case to an approved human process. The escalation action should be idempotent and auditable.

Official references/topics: PreToolUse hooks, deterministic policy enforcement, MCP tool interception, human-approval controls.

Option D preserves Claude Code’s standard coding-agent instructions while adding the specialized review criteria. Anthropic documents that --system-prompt replaces the entire default system prompt, including its tool guidance, safety instructions, and coding conventions. It does not technically disable tools, but removing that guidance can make the invocation behave like a narrowly scoped text processor. --append-system-prompt retains the default behavior and layers the review instructions on top.

The prompt should explicitly direct Claude to use Read, Glob, and Grep to inspect definitions, callers, tests, and related modules whenever the diff alone is insufficient. Option A is incorrect because --system-prompt is not incompatible with tools. Option B is also inaccurate: --allowedTools pre-approves tool execution; it does not make tools available when -p would otherwise disable them. In this command, --dangerously-skip-permissions already bypasses permission prompts. Option C is false because Claude Code officially supports piped standard input in non-interactive mode. The repaired invocation should therefore use --append-system-prompt and include an explicit repository-exploration requirement. Claude Code programmatic usage , CLI system-prompt reference

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

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.

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

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. ( ) 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.

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 identifies escalation through direct operational criteria rather than indirect proxies. A customer’s explicit request for a person is unambiguous. A required policy exception defines an authorization boundary. An inability to make meaningful progress identifies a case where continued autonomous execution is no longer productive.

Anthropic describes agents as systems that act, observe results, adjust, and continue until the task is completed or human input is required. Its trustworthy-agent guidance also emphasizes that agents must recognize when to pause rather than pushing through uncertainty or decisions that only a human can settle. ( )

Option A is too rigid for high-ambiguity support cases. Maintaining exhaustive mappings for every issue, product, and customer segment recreates the brittleness that agentic reasoning is intended to avoid. Option C treats repeated tool use as a substitute for semantic progress; one definitive authorization failure may require immediate escalation, while several legitimate diagnostic calls may not. Option D confuses emotional tone with operational necessity. A calm customer may require a policy exception, while a frustrated customer may still have a straightforward automated resolution.

The escalation criteria should be encoded in the system instructions and supported by evaluations covering explicit requests, authorization limits, unresolved ambiguity, repeated non-progress, and successful self-service cases.

Official references/topics: Human-control checkpoints, escalation criteria, authorization boundaries, progress-aware agents.

Option C uses MCP resources for their intended purpose: exposing contextual data that applications and agents can discover and read without treating every lookup as an action-oriented tool invocation. Anthropic’s Claude Code MCP documentation states that Claude Code automatically provides mechanisms to list and read resources exposed by connected MCP servers. Resources may contain text, JSON, structured data, or other server-provided content. The official MCP server concepts likewise explain that resources expose information from files, APIs, and databases through identifiable, discoverable URIs. Publishing issue summaries, the wiki hierarchy, and database schemas gives the agent an initial map of available evidence. It can identify relevant systems and retrieve only the necessary records before making targeted tool calls. Option A creates another opaque, high-level tool whose output quality depends on each server interpreting the investigation correctly. Option B produces tight coupling and increases operational complexity. Option D prevents the cross-system investigation required by the question. Resource catalogs improve discoverability, reduce blind exploration, and preserve tools for searches, queries, and mutations that genuinely require execution.

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

Option B removes ambiguity at the tool-interface level. Extraction, summarization, and claim verification are different operations with different success criteria and output structures. Separate tools allow each operation to have a precise name, purpose, parameter schema, response contract, and error behavior. Anthropic’s guidance on writing effective tools for agents recommends a small set of thoughtful tools targeted at specific, high-impact workflows rather than generic wrappers that force the model to infer operational meaning from loosely structured instructions. Tool descriptions and examples, option A, could improve behavior but leave the overloaded free-text contract intact. An analysis_type enum, option C, identifies the requested mode but still requires one tool to return substantially different result structures, increasing validation and downstream branching. Coordinator pre-classification, option D, adds another probabilistic decision without correcting the interface used by the analysis agent. Purpose-specific tools let the synthesis layer know exactly what output it will receive. Their schemas should require relevant fields—for example, data-point names and source locations for extraction, or claim, verdict, and evidence for verification—and should be tested against the observed failure cases.

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

Request B benefits substantially more from an explicit multi-phase workflow because it is broad, judgment-intensive, and likely to affect multiple execution paths. Improving error handling requires the agent to identify current failure modes, determine which exceptions should be caught, preserve useful diagnostic information, prevent partial state corruption, and verify that the resulting behavior remains consistent across the module. An analyze → propose → implement → review sequence separates those concerns and creates checkpoints before consequential edits are made.

Request A is comparatively deterministic. The function and target name are already defined, and the task primarily requires locating references, applying the rename, and running tests or static analysis. Anthropic’s Claude Code guidance states that planning is most useful when the approach is uncertain, the work spans multiple files, or the developer is unfamiliar with the affected code. For a small change that can be described as a straightforward diff, direct implementation is usually preferable. ( )

Anthropic also characterizes prompt chaining as appropriate when a task can be divided into fixed stages and additional latency is justified by increased accuracy. Request B fits that pattern because analysis and review materially reduce the risk of introducing swallowed exceptions or inconsistent recovery behavior. ( )

Official references/topics: Prompt Chaining; Plan Before Editing; Multi-Phase Coding Workflows; Verification and Review.

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 D uses the established integration mechanism without creating unnecessary infrastructure. Anthropic’s Claude Code MCP documentation specifically recommends connecting an MCP server when users repeatedly copy information from an external system, such as an issue tracker, into conversations. Once connected, the server exposes Jira operations through named, schema-defined tools that Claude can discover and invoke directly. This allows the agent to retrieve ticket descriptions, acceptance criteria, comments, and metadata while preserving the server’s authentication and access controls.

Option A exposes authentication details to shell commands and requires the agent to construct requests and parse responses repeatedly. Option B is justified only when no existing server provides the required capabilities or the workflow requires highly specialized operations. The question requires standard Jira information, so building and maintaining another server is unnecessary. Option C creates stale, manually synchronized copies that lose permissions, current comments, and authoritative ticket state. The team should therefore select a trusted Jira MCP implementation, configure appropriate read-only scopes where possible, and verify its tool descriptions and data-access boundaries before enabling it.

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

Option A corrects the missing tool contract that permits Claude to guess a required parameter. The process_refund description should state its prerequisite explicitly: invoke lookup_order, use only the exact order_id returned by that successful call, and ask for additional identifying information when lookup cannot resolve an order. An input example can demonstrate the correct two-tool sequence.

Anthropic’s tool-definition guidance identifies detailed descriptions as the most important factor in tool performance. Descriptions should explain when a tool should and should not be used, what every parameter means, and all important limitations. The tool-use overview confirms that Claude selects and populates tools based on the request and their descriptions.

Option B forces some tool call but does not tell Claude which tool must run first or where the identifier originates. Option C is an essential defence-in-depth control, but it detects the fabricated value after Claude has already made the incorrect decision. Option D works only when the customer supplies an identifier and does not cover “recent purchase.” Explicit prerequisite and provenance instructions directly prevent the model from inventing the required argument.

Option C preserves the information structure that makes each source useful. Financial metrics share comparable fields and therefore benefit from rows, columns, aligned units, and reporting periods. News findings require connected prose to preserve chronology and causal relationships, while patent technology areas are naturally represented as categorized lists. Anthropic’s output-consistency guidance recommends specifying the exact output format needed for the task rather than relying on an unspecified default. Anthropic’s discussion of its multi-agent research system also recognizes specialized output stages for reports, structured data, and visualizations because specialist prompts can produce better results than generic coordinator processing. Option A destroys the comparative structure of numerical data. Option D can provide a useful provenance contract internally but does not determine how the executive briefing should present heterogeneous content. Option B risks creating a lowest-common-denominator representation that discards source-specific advantages. The synthesis contract should preserve normalized facts and provenance internally while directing the report generator to select presentation forms according to the content’s semantic structure and the executive reader’s needs.

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

Option B follows the Claude Agent SDK’s subagent context model. A normal subagent begins with a fresh context window and does not inherit the parent agent’s conversation history or prior tool results. Anthropic’s Subagents in the SDK documentation states that the information passed from parent to subagent is the spawning tool’s prompt string; required file paths, decisions, errors, or findings must therefore be included in that prompt. In this scenario, the coordinator should supply both agents’ relevant findings, source metadata, and explicit synthesis instructions. “Complete findings” means the full required result artifacts, not every intermediate search trace. Option C incorrectly assumes automatic context inheritance. Option A introduces callbacks that are neither necessary nor the standard handoff mechanism. Option D can be a valid custom architecture when a shared store has deliberately been implemented, but the question does not establish such infrastructure, and identifiers alone do not give the subagent information. The prompt should use clear sections or structured objects to distinguish web findings, document findings, sources, unresolved conflicts, and expected output. This preserves context isolation while providing everything the synthesis task actually requires.

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

Option C avoids an unnecessary agent boundary. The coordinator already possesses the accumulated findings and can perform a straightforward summary without serializing, transferring, and reprocessing more than 80,000 tokens in another context window. Subagents should be reserved for work that requires isolated context, specialized instructions, separate tools, or an independent analytical process.

Anthropic’s current prompting guidance advises using subagents for independent workstreams and parallel or context-isolated tasks, while handling simpler tasks directly. Anthropic also notes that excessive subagent use creates unnecessary cost and latency.

Option A generates multiple summaries speculatively, consuming resources even if they are never requested and creating cache-invalidation complexity whenever findings change. Option B may reduce repeated input-token cost, but it does not eliminate subagent startup, message processing, or the unnecessary orchestration round trip. Option D introduces an iterative request protocol that will likely increase latency further. Direct coordinator summarization uses information already available in active context and therefore provides the smallest architectural change, lowest token-transfer overhead, and fastest response while preserving subagent synthesis for genuinely complex comparative or cross-source analysis.

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

This migration is a high-impact, cross-module change with several independent breaking changes. Before editing, Claude must determine how the callback-based API is currently used, where the restructured User fields propagate, whether deprecated methods are wrapped or re-exported, and which downstream modules depend on the affected behavior. Plan mode is therefore the correct starting point because it allows Claude to inspect the repository, identify affected code paths, and produce an implementation strategy without modifying source files.

Anthropic recommends separating exploration and planning from implementation when the approach is uncertain, the change affects multiple files, or the developer is unfamiliar with the impacted code. Direct execution is better reserved for small, clearly scoped changes that can be described as a simple diff. ( )

Option A applies transformations before establishing whether every usage follows the same pattern. Option B turns the test suite into a reactive discovery mechanism and may miss untested behavior. Option D provides useful migration documentation but assumes all 45 files can be changed uniformly. The reliable sequence is exploration, impact mapping, migration planning, implementation, and verification against tests and type checks.

Official references/topics: Plan Mode; Explore–Plan–Implement Workflow; Multi-File Migration Planning; Verification.

A mid-process escalation should transfer the decision-ready state accumulated by the agent. The human reviewer needs the verified customer identity, relevant order information, the promotional-pricing discrepancy, the reason approval is required, and any actions already attempted. Option B preserves this information in a concise, structured handoff while avoiding unnecessary repetition of the complete raw transcript.

Anthropic’s tool-design guidance recommends returning high-signal information and stable identifiers containing only what Claude or the next workflow participant needs to determine the next action. Anthropic’s context-engineering guidance similarly advocates structured notes that preserve critical state and dependencies without retaining every redundant tool result. A structured escalation payload applies both principles and reduces handling time for the manager. ( )

Option A discards the investigation already completed. Option C violates the agent’s authorization boundary and risks an impermissible financial action. Option D provides auditability, but a reference ID alone forces the human to reconstruct the case from an excessively broad transcript. Human control must remain meaningful when an agent encounters a decision outside its authority; the agent should pause and hand the decision back with sufficient supporting context. ( )

Official references/topics: Structured agent handoffs, high-signal tool results, human-control boundaries, persistent structured state.

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 A begins with the strongest available discriminator: the exact production error text. Anthropic’s tools reference specifies that Grep searches file contents and returns matching lines, enabling the agent to locate a literal error constant or message without loading the full repository. Searching both the stable code SYNC_CONFLICT and the distinctive phrase protects against cases where the identifier and displayed message are defined separately. The agent can then read only the matching files and follow the surrounding call path, error construction, and service ownership. Option B assumes that errors are stored in conventionally named directories, which may not hold in a twelve-service repository. Option C consumes substantial context before using the most direct evidence. Option D narrows the search to consumers of a known shared error module, but the message may be locally defined, generated from configuration, or wrapped by another component. Grep followed by targeted Read operations follows Anthropic’s broader context-engineering principle of retrieving relevant source material just in time instead of placing an entire codebase into the active context.

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

Option C gives the human agent the operational state required to continue without replaying a long conversation. The handoff should include verified identifiers, the duplicate transaction evidence, the diagnosed timeout-and-retry mechanism, the $847 refund requirement, the agent’s $500 authorization constraint, completed verification steps, prior actions, and the recommended resolution. Any unresolved uncertainty should be labeled explicitly.

Anthropic’s effective context-engineering guidance recommends preserving high-value state in structured notes while removing redundant conversational and tool-call history. Its long-running-agent guidance likewise describes structured handoffs as the mechanism for maintaining continuity across context resets or agent boundaries.

Option A maximizes raw information but forces the human to locate the relevant facts among more than 25 turns, increasing delay and error risk. Option B preserves evidence but omits the authorization constraint, completed verification, and explicit recommended action. Option D is too sparse to support validation or execution. A structured handoff balances fidelity and efficiency: it contains everything needed for the next actor to make the refund decision while excluding greetings, repeated explanations, and irrelevant intermediate tool output.

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

Limited review capacity should be concentrated on records with the highest probability of semantic error. Schema validation confirms that the response has the correct structure and data types; it does not establish that the extracted values are accurate. Ambiguous wording, contradictory passages, missing evidence, and model-reported uncertainty are direct indicators that an extraction requires human judgment.

Anthropic’s reliability guidance recommends permitting Claude to express uncertainty, grounding factual outputs in source material, and validating critical information because hallucination-reduction methods do not eliminate errors completely. These principles support routing uncertain or evidentially conflicted records to reviewers rather than treating syntactically valid output as automatically trustworthy. ( )

Option B may waste reviewer capacity on clear, well-supported values while overlooking ambiguous errors in other fields. Option C is reactive: downstream acceptance does not guarantee semantic correctness, and silent errors may never produce processing failures. Option D provides an unbiased estimate of overall quality and should be retained as a secondary audit mechanism, but random selection is not the most efficient way to intercept risky records when only 5% can be reviewed.

In production, model confidence should not be treated as a calibrated probability by itself. It should be combined with objective signals such as contradictory source spans, missing citations, OCR quality, validation warnings, document type, and business impact.

Official references/topics: Human-in-the-Loop Review, Uncertainty Handling, Source Grounding, Risk-Based Escalation.

The key difference is reviewer independence. In the original session, Claude retains the reasoning, assumptions, implementation decisions, and intermediate conclusions that led to the refactor. That context can anchor the subsequent review toward defending or confirming the chosen approach instead of evaluating the resulting code independently. The separate CI review begins with fresh context and can assess the implementation solely against the code and review criteria.

Anthropic’s Claude Code best-practices documentation explicitly states that fresh context improves code review because Claude is not biased toward code it has just written. It recommends a writer/reviewer pattern using separate sessions or a review subagent with an isolated context.

Option B is possible in an uncontrolled comparison, but the scenario’s defining distinction is that one review occurs in the implementation session and the other is independent. Option C is false because local Claude Code can read and search the repository when permissions and tools permit it; it is not inherently restricted to the current file. Option D would require evidence of context saturation, such as degraded instruction following or an almost-full context window. No such evidence is supplied. Prior-reasoning bias most directly explains the observed discrepancy.

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