CCAR-F Claude Certified Architect – Foundations Questions and Answers

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

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

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.

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

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.

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

First-contact resolution does not require pretending that every backend operation succeeded. The agent can still resolve the informational portion of the interaction by explaining the charge and confirming eligibility using the successfully retrieved customer and order data. It must then distinguish that verified conclusion from the uncompleted refund transaction.

Anthropic’s tool-error guidance states that Claude should receive the failure information so it can retry, request clarification, or explain the limitation. A tool timeout must therefore be surfaced honestly rather than converted into an unsupported success claim. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent?utm_source=chatgpt.com ) Anthropic also emphasizes transparent, simple agent designs and carefully constructed tool interfaces, which support explicit disclosure of tool failure and controlled escalation. ( https://www.anthropic.com/engineering/building-effective-agents )

Option A can create an unbounded or excessively long interaction; retries should be limited and conditioned on retryability. Option B falsely represents an incomplete financial operation as completed. Option D discards the useful work already performed and escalates before providing the customer with the available explanation.

Option C preserves trust, delivers the information already established, clearly states what remains incomplete, and gives the customer a practical next step through bounded retry or human escalation.

Official references/topics: Graceful tool failure, transparent customer communication, bounded retry, human escalation.

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.

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

A tool definition converts the desired extraction structure into an explicit machine-readable contract. Claude returns the event information inside a tool_use block, with the tool arguments corresponding to the properties defined by the tool’s input_schema . Anthropic specifies that custom tool parameters are described using JSON Schema, allowing the application to extract the structured arguments directly rather than attempting to recover JSON from ordinary prose. For current implementations, adding strict: true to the tool definition provides guaranteed conformance of tool-call inputs to the declared schema. ( https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use )

Options A, B, and D remain prompt-based formatting techniques. They may improve the probability of valid JSON, but none creates the same schema-enforced interface. Prefilling an opening brace constrains the beginning of the response without guaranteeing valid field names, required properties, or data types. Retry logic detects failures only after generation and adds latency. Detailed formatting instructions can still produce malformed or structurally incorrect output.

Anthropic now also provides Structured Outputs for direct, schema-validated JSON responses. Within the options presented, however, a schema-defined tool is the only approach that establishes an explicit structured-output boundary rather than relying primarily on text-generation compliance. ( https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/increase-consistency )

Official references/topics: Tool Definitions, JSON Schema Input Contracts, Strict Tool Use, Structured Outputs.

Option B creates the granular error taxonomy needed to understand recurring false-positive patterns. The existing issue_category field is too broad: a high dismissal rate for style does not reveal whether developers object to single-letter variables, line-length warnings, naming conventions, or something else. Recording the detected construct allows dismissal rates to be grouped by trigger and connected to targeted prompt revisions or project-specific examples.

Anthropic’s evaluation guidance recommends measurable, task-specific criteria and evaluation cases that reflect real production behavior and edge cases. Its structured-output documentation supports schema-constrained, parseable records suitable for this type of downstream analysis.

Option A can help rank findings, but a confidence score does not explain why developers reject them and may be poorly calibrated across issue types. Option C produces more text without adding a stable dimension for aggregation. Option D removes useful category information and makes systematic analysis harder. A normalized detected_pattern field enables dashboards, pattern-level dismissal metrics, representative-example sampling, and controlled evaluations of prompt changes while retaining the broader category for higher-level reporting.

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

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.

The failures reflect missing project-specific knowledge: Claude does not know which fixtures are preferred, what the existing suite already covers, or what the team considers meaningful behaviour. Option C provides this information as persistent project context before test generation begins. This changes generation quality at the source instead of filtering weak tests after spending tokens to produce them.

Anthropic’s CLAUDE.md documentation recommends storing shared build and test commands, coding standards, architectural decisions, conventions, and common workflows in a project CLAUDE.md. Testing guidance can define required behavioural assertions, fixture selection rules, duplication checks, naming conventions, and representative examples of acceptable and unacceptable tests.

Option A avoids difficult directories rather than improving the model’s understanding and sacrifices potentially useful automation. Option B may remove some weak tests, but it doubles model work and asks another probabilistic call to infer quality criteria that should have been stated explicitly. Option D treats line coverage as a quality metric even though a trivial test can increase coverage without validating meaningful behaviour, while a valuable regression test may cover already executed lines with better assertions. Persistent, concrete testing standards therefore offer the most direct and scalable improvement.

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

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. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools )

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. ( https://www.anthropic.com/research/trustworthy-agents )

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

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

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

Claude Code supports resuming a specific saved session by either its identifier or its assigned name. Because the engineer knows the target session is named auth-deep-dive , the appropriate command is:

claude --resume auth-deep-dive

Anthropic’s CLI reference explicitly states that --resume can resume a session by ID or name and gives named-session usage in the same form. Resuming restores the relevant conversation history and accumulated context, including the prior analysis and files discussed during the investigation. ( https://docs.anthropic.com/en/docs/claude-code/cli-reference )

Option B is incorrect because --continue resumes the most recent session in the current directory. The engineer has conducted three subsequent sessions, so it may open an unrelated investigation. Option A uses a flag that is not the documented Claude Code mechanism for selecting a prior session; --resume itself accepts the session identifier when an ID is used. Option C discards two hours of established context and unnecessarily repeats codebase exploration.

Named sessions are particularly useful when engineers alternate among multiple projects or parallel investigations. Assigning descriptive names allows the correct thread to be retrieved deterministically rather than depending on chronological recency.

Official references/topics: Claude Code Session Persistence, Named Sessions, --resume , --continue .

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 . ( https://code.claude.com/docs/en/mcp )

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 A removes the semantic ambiguity created by one generic tool performing three substantially different operations. Each replacement tool can have a distinct name, focused description, appropriate required parameters, and an output schema designed for its task. For example, extract_data_points can return typed records, while verify_claim_against_source can return a verdict, supporting excerpt, and source location.

Anthropic’s tool-design guidance recommends thoughtful tools with clear, distinct purposes and natural task boundaries. Ambiguous or overlapping capabilities make it harder for agents to select the correct operation and interpret its results consistently.

Option B improves the existing interface, but the implementation and result contract remain overloaded, increasing the possibility that the model or tool will mix behavior across modes. Option C adds another probabilistic classification stage without repairing the underlying interface. Option D may reduce some errors, but free-text interpretation remains the principal control mechanism. Purpose-specific tools encode the intended operation directly into the callable interface, permit strict schemas tailored to each result type, and make evaluation failures easier to diagnose. This produces a stronger contract between the agent and deterministic document-processing system.

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

Option B removes the ambiguity from the tool interface itself. The agent no longer needs to choose between separate functions that represent closely related business operations. Instead, a single compensation tool exposes an explicit action parameter, while the existing order lookup tool can optionally return delivery-tracking information through a clearly defined flag.

Anthropic’s tool-design guidance recommends consolidating related operations into fewer, more capable tools when separate functions create unnecessary semantic overlap. Claude selects tools primarily from their names, descriptions, schemas, and the current task. When multiple tools appear capable of satisfying the same request, selection accuracy declines because the agent must infer distinctions that should have been made explicit in the interface design.

Option A adds routing complexity but leaves overlapping financial operations available within the same sub-agent. Option C reduces the number of tools loaded initially, but it does not eliminate the semantic duplication between compensation operations or overlapping lookup functions. Option D may improve behavior through examples, but it compensates for a poorly designed tool surface rather than correcting the root cause.

The consolidated schemas should use enums for supported actions, clearly define when each action applies, and document the returned fields. This creates a smaller and more deterministic agent-computer interface.

Official references/topics: Tool consolidation, semantic tool boundaries, action parameters, MCP tool-selection accuracy.

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. ( https://code.claude.com/docs/en/best-practices )

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. ( https://www.anthropic.com/research/building-effective-agents )

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

Option B uses the tool designed to search file contents. Anthropic’s Claude Code tools reference distinguishes Grep from Glob: Grep searches lines inside files, whereas Glob matches filenames and paths. Grep is built on ripgrep and accepts regular-expression patterns, so the opening parenthesis should be escaped as eval\( when the intention is to match the literal function call. The search can return matching files, line numbers, and surrounding context without loading every file into the model’s context window. Option A searches filenames resembling eval , not source files whose contents invoke the function. Option C follows only code reachable from a selected entry point and can miss test utilities, dynamically loaded modules, scripts, and dormant vulnerable code. Option D combines a recursive filename listing with text filtering; it still searches names rather than file contents. After Grep identifies matches, the agent should use Read on the relevant ranges to distinguish actual executable calls from comments, strings, or safe wrappers. Grep therefore provides the most complete and context-efficient initial security scan.

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

Option C directly searches source-file contents for imports of @company/auth . Anthropic’s Claude Code tools reference states that Grep locates patterns within files, while Glob matches filenames and paths. The search can account for the repository’s supported module syntaxes, including static imports, require() calls, dynamic imports, and re-exports. It can also restrict results by file type or directory when appropriate. Option A identifies packages that declare the dependency but does not prove which source files import or invoke it; workspace-level dependency declarations may cover many packages. Option B finds authentication-related filenames, which are unrelated to whether a file imports the package. Option D searches directory names and therefore has the same limitation. After Grep returns the matching files and line numbers, the agent can read the surrounding code to determine whether each import supports middleware registration, token verification, authorization checks, or re-exporting. This produces an accurate usage inventory while minimizing context consumption and unnecessary file reads.

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

Option A exposes both independent invocations in the same assistant turn, allowing the Agent SDK or application tool runner to execute them concurrently. The coordinator can then receive both results together and continue with synthesis only after the independent research branches have completed.

Anthropic’s parallel tool-use documentation explains that a response may contain multiple tool-use blocks. Independent, read-only operations can be executed concurrently to reduce latency, after which all corresponding tool results should be returned together. The term “Agent” is used here because current Claude Agent SDK releases renamed the earlier “Task” tool.

Option B may shorten individual execution but does not eliminate the sequential waiting pattern and could reduce research quality. Option C expresses the desired behavior but does not correct an orchestration implementation that processes only one tool call per turn. Option D introduces unnecessary coordinators, duplicated context, and substantially more complex state management. A single coordinator issuing both independent Agent calls preserves centralized monitoring and result association while removing the avoidable serial dependency. The runtime must process every returned tool call concurrently rather than stopping after the first one.

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

The root cause is an incomplete tool contract. Claude sees that process_refund requires an order_id , but the tool description does not explain the parameter’s trusted source or the prerequisite lookup sequence. Option A makes the dependency explicit and prohibits fabricated values.

Anthropic states that tool descriptions should explain what a tool does, when it should be used, how it behaves, and any important limitations. Its prompting guidance also states that dependent tool calls must be executed sequentially and that Claude must never use placeholders or guess missing tool parameters. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools )

Option B merely forces some tool use; it does not force the correct tool or prevent a fabricated identifier. Option C is an essential defense-in-depth control, but it detects the invalid ID after the model has already made the faulty call. It does not correct the selection logic that caused the fabrication. Option D works only when the customer actually provides an identifier and introduces an unnecessary preprocessing dependency.

The process_refund schema should describe order_id as a verified identifier returned by lookup_order , and the tool description should state that the tool is unavailable until the corresponding order has been retrieved and eligibility established.

Official references/topics: Tool descriptions, prerequisite tool calls, parameter provenance, sequential tool orchestration.

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 .

This change is narrow, localized, and already defined: add one conditional validation check to an existing function in a single file. A separate planning phase would introduce process overhead without resolving meaningful architectural uncertainty. Direct execution allows Claude to read the function, implement the condition, and run the relevant focused tests.

Anthropic explicitly states that plan mode adds overhead and should generally be skipped when the scope is clear and the fix is small. Planning is most valuable when the approach is uncertain, multiple files are affected, or the code is unfamiliar. Anthropic’s practical rule is that when the required diff can be described in one sentence, direct implementation is appropriate. ( https://code.claude.com/docs/en/best-practices )

Option B allocates unnecessary reasoning effort to straightforward validation logic. Options C and D exaggerate the complexity of a single-function change. Broader impact analysis would be justified only if the requirement altered reservation semantics, time-zone rules, persistence behavior, or public interfaces—none of which is stated.

The implementation should still include verification. Claude should add or update tests for a future date, the current date, and a past date, then run the narrowest relevant test command. Direct execution does not mean unverified execution.

Official references/topics: Direct Execution; Plan-Mode Selection; Small Scoped Changes; Focused Verification.

Option B eliminates an unnecessary agent boundary. The coordinator already possesses the accumulated findings and can answer a straightforward follow-up without serializing more than 80,000 tokens into a fresh subagent context, waiting for another model execution, and receiving the result back. Anthropic’s multi-agent research engineering guidance emphasizes scaling effort to task complexity: simple fact-finding or lightweight processing should use substantially fewer agents and tool calls than complex research. It also reports that multi-agent systems consume far more tokens than ordinary interactions, making avoidable delegation expensive and slow. Option A adds an interactive retrieval protocol between agents and additional round trips. Option C spends compute proactively on summaries that users may never request and creates cache-invalidation problems whenever findings change. Option D could reduce repeated input cost where caching is applicable, but the subagent still receives and processes an unnecessarily large context and still incurs spawning latency. Delegation is valuable when an isolated context or specialized capability materially improves the result. For a direct summary already supported by the coordinator’s active context, local handling is the faster and simpler architecture.

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

Option A identifies the direct configuration contradiction. Each system prompt defines a specialized responsibility, but the corresponding tool allowlist presents unrelated actions as available capabilities. The synthesis agent may therefore interpret web searching as an acceptable way to fill evidence gaps, while the report generator may perform document analysis instead of limiting itself to report production.

Anthropic’s subagent documentation defines subagents as focused workers with their own prompts and specific tool access. Its tool-definition guidance also recommends reducing selection ambiguity by presenting clear, relevant tools. The appropriate correction is least-capability configuration: expose search tools to the search agent, document tools to the analyzer, synthesis utilities to the synthesizer, and formatting or output tools to the report generator.

Option B may affect token efficiency but does not explain the role-specific misuse pattern. Option C concerns delegation, whereas the improper calls occur after successful delegation. Option D is tempting, but Anthropic does not define four or five tools as a universal reliability threshold; 18 tools alone does not prove threshold failure. The decisive defect is misalignment between declared roles and permitted capabilities.

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

Prompt chaining is appropriate because the workflow consists of predictable, fixed subtasks that apply to every pull request. The system can run a focused style-compliance analysis, then a security analysis, then a documentation review, and finally synthesize the three results into a consistent report.

Anthropic defines prompt chaining as decomposing a task into a sequence of steps in which each call handles a smaller component. It is recommended when a task can be cleanly divided into fixed subtasks, trading additional latency for better focus and accuracy. Intermediate checks can also be inserted between stages to confirm that each report section meets its requirements. ( https://www.anthropic.com/engineering/building-effective-agents )

Option A concentrates all considerations into one call, making it easier for one aspect to receive inadequate attention. Option B is unnecessary because orchestrator-workers is intended for complex work where the required subtasks cannot be predicted in advance. Here, the three review dimensions are already known and remain constant. Option D solves a different problem: routing is appropriate when inputs belong to distinct categories that require different downstream processes.

Although the three analyses could potentially be parallelized for lower latency, the option that accurately represents the stated repeatable decomposition is prompt chaining with final synthesis.

Official references/topics: Prompt Chaining, Fixed Subtasks, Intermediate Validation, Workflow Selection.

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.

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

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 current prompt asks for testing analysis at too high a level. Claude recognizes the obvious absence of an entire test but has not been instructed to construct a path-level inventory. Option B turns the desired behavior into an explicit verification procedure: enumerate each condition, alternative branch, early return, exception handler, and failure path, then locate a test assertion that exercises its behavior.

Anthropic’s prompting best practices emphasize clear, specific instructions and explicit sequential steps when a task requires a defined analysis process. This change keeps the existing single review call while making the missing evaluation criterion unambiguous.

Option A improves proximity between implementation and tests but does not tell Claude what coverage relationship to inspect. Option C could work, but it adds orchestration, latency, cost, and another handoff before testing whether a direct instruction solves the observed failure. Option D may improve recognition of examples resembling the demonstration, but a few cases cannot enumerate every branch structure. Explicit path enumeration generalizes across unfamiliar code and creates auditable output: each reported gap can name the uncovered condition, expected behavior, and missing assertion.

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

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 checklist is a reusable, task-specific procedure that should load only when a pull-request review is being performed. A /review command provides an explicit invocation mechanism, prevents repeated copy-and-paste, and keeps the checklist out of unrelated coding, debugging, and documentation sessions.

In current Claude Code terminology, custom commands have been consolidated into skills. A .claude/skills/review/SKILL.md file creates a /review command, while the legacy .claude/commands/review.md format remains supported. Anthropic recommends skills when users repeatedly supply the same checklist or multi-step procedure; unlike CLAUDE.md content, the skill body is loaded only when invoked or determined relevant. ( https://code.claude.com/docs/en/skills )

Option B introduces an isolated agent context when the requirement is primarily to inject a repeatable review procedure. A subagent could be useful for independent verification, but it is not necessary merely to avoid repasting the checklist. Option C bloats every session with instructions that apply only to code review. Option D controls editing permissions and planning behavior; it does not encode review criteria.

The review skill can also pre-authorize read-only tools and accept a pull-request identifier or branch as an argument.

Official references/topics: Claude Code Skills; Custom Slash Commands; On-Demand Instructions; Reusable Review Workflows.

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. ( https://docs.anthropic.com/en/docs/claude-code/sdk?utm_source=chatgpt.com )

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

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

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.

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

In the standard Claude tool-use loop, the application executes lookup_order and sends its output back as a tool_result . That result becomes part of the conversation state available to Claude. Claude then evaluates the purchase date, refund policy, customer request, authorization constraints, and available tools before selecting the next action.

Anthropic describes client-tool orchestration as a repeated loop: Claude emits a tool_use request, the application executes it, returns a tool_result , and Claude continues reasoning from the updated conversation. Claude, rather than the tool implementation, selects when and how to invoke the next available tool unless the application has explicitly implemented a fixed workflow. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/how-tool-use-works )

Options B and C describe possible custom orchestration architectures, but neither is stated in the scenario. Option D is inconsistent with adaptive agent behavior because later actions depend on information that did not exist before lookup_order completed. A rigid sequence would not respond appropriately to different purchase dates, eligibility states, or order conditions.

The tool result should return high-signal fields such as purchase date, return-window status, refund eligibility, existing refund status, and stable order identifiers so Claude can make the subsequent decision accurately.

Official references/topics: Tool-result continuation, adaptive agent loops, model-directed tool selection, sequential dependency handling.

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.

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

Option C preserves provenance as part of the data contract instead of attempting to reconstruct it after synthesis. Each finding should carry a stable claim identifier and one or more source records containing the URL or document identifier, relevant location, supporting excerpt, retrieval date, and applicable qualification. The synthesis agent can combine or rewrite claims while retaining their source relationships.

Anthropic’s structured-output documentation supports schema-constrained, parseable results for downstream workflows. Its citation documentation explains that reliable citations depend on valid pointers to provided source material. Anthropic’s skill guidance similarly recommends cross-referencing each major claim and verifying its citation before completion.

Option A reconstructs attribution probabilistically and may associate a claim with a similar but incorrect passage. Option B encodes metadata inside prose, making transformations and parsing fragile. Option D retains excessive context and adds another model stage to recover information that should never have been discarded. Structured claim-source mappings permit deterministic merging, citation validation, deduplication, and audit trails. The report generator can therefore cite the exact evidence supporting each conclusion without replaying complete research transcripts.

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

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.

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

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.

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. ( https://docs.anthropic.com/en/docs/claude-code/hooks-guide )

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.

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 .