CCAR-F Claude Certified Architect – Foundations Questions and Answers

Option C converts an empirically validated source hierarchy into an explicit extraction rule. The downstream contract requires one battery_capacity value, and historical analysis establishes that the detailed specifications table is substantially more reliable than the summary section. Claude should therefore be instructed to inspect all occurrences, detect conflicts, and select the detailed-table value when the two locations disagree.

Anthropic’s prompting guidance emphasizes clear, direct instructions, relevant context, and explicit decision rules when order or completeness matters. Providing the reason for the precedence rule also helps the model generalize it to comparable specification conflicts. Option A preserves every value but transfers a known and repeatable decision into downstream systems, unnecessarily changing the schema. Option B rejects approximately 15% of otherwise processable documents even though a reliable precedence policy is available. Option D creates a costly manual-review queue for conflicts that can usually be resolved deterministically. The extraction system should still retain source quotations or locations in internal provenance metadata when auditability matters, but the output field should follow the established detailed-table precedence. Anthropic prompting best practices

Option A supplies the missing project context before Claude evaluates the code. Anthropic’s CLAUDE.md documentation defines project-level files as persistent, version-controlled instructions for coding standards, architecture, workflows, and conventions. The described exceptions are stable repository facts: force-unwrapping is permitted in tests, coordinator classes follow an intentional pattern, and an internally maintained dependency remains approved despite its public deprecation status. Recording these facts concisely allows every review session to interpret the patterns correctly.

Option B removes surrounding evidence and would make architectural and cross-file judgments less reliable. Option C hides findings after generation and can suppress genuine bugs containing the same keywords. Option D adds noise to source files and distributes policy across individual call sites instead of documenting it centrally. The CLAUDE.md entries should be specific and scoped—for example, limiting the force-unwrapping exception to test paths rather than approving it globally. Anthropic notes that shorter, precise instructions are followed more consistently, so the file should state the accepted convention, its scope, and any conditions that would still make the pattern reportable.

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

Option C defines the reviewer’s actual objective instead of relying on an undefined notion of confidence. The prompt should identify reportable categories such as correctness defects, security vulnerabilities, data-loss risks, broken requirements, and meaningful performance regressions. It should also specify that cosmetic preferences, lint-enforced formatting, speculative refactoring, and intentional repository conventions must not be reported unless they cause concrete incorrect behavior.

Anthropic’s Claude Code best-practices guidance recommends telling a reviewer to report gaps affecting correctness or stated requirements and to treat other observations as optional. Without such criteria, a reviewer asked to “find issues” will predictably return technically defensible but operationally low-value observations. Option A adds cost and another probabilistic decision layer before correcting the primary prompt. Option B relies on self-reported confidence, which does not necessarily align with developer value or severity. Option D can suppress genuine defects that require inference or cross-file verification because “highly confident” is undefined. Explicit scope, evidence requirements, and examples of both reportable and excluded findings directly calibrate the review toward what developers will act upon. Claude Code best practices

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

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. ( https://docs.anthropic.com/en/docs/claude-code/common-workflows ) Anthropic also describes parallel research as appropriate when separate investigation paths can proceed independently and the main agent can synthesize the results afterward. ( https://docs.anthropic.com/en/docs/claude-code/sub-agents )

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 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 A moves durable, high-value discoveries outside the transient conversation history. The scratchpad should record module responsibilities, important symbols, architectural relationships, file paths, unresolved questions, and decisions supported by the code. The agent can reread this compact file after context compaction or before answering a later architectural question. Anthropic’s large-codebase guidance recommends saving plans and important state to files because those artifacts survive when long conversations are compacted. Its context-management guidance also warns that accumulated file contents and command output can reduce performance during extended sessions.

Option B clears valuable information on a fixed schedule regardless of whether the current task is complete. Option C delays the problem but does not prevent irrelevant history from crowding out important details. Option D performs expensive summarization before the agent knows which files are relevant and may remove implementation details needed later. A focused scratchpad supports just-in-time restoration: the agent keeps the active context lean while retaining an auditable architectural map that can be updated as exploration progresses.

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

Option B gives the report generator the two forms of information it actually needs: a compact narrative containing the synthesized conclusions and precise evidence records supporting those conclusions. The source index should map claim identifiers to URLs, document locations, excerpts, and other provenance fields so citations can be generated and verified without reloading 120,000 tokens of raw material.

Anthropic’s context-engineering guidance recommends distilling extensive subagent activity into high-signal summaries while preserving critical context and dependencies. Its research architecture similarly treats subagents as intelligent filters that compress large evidence collections before returning relevant findings to the coordinator.

Option A lacks sufficient location-level evidence for reliable citation verification. Option C postpones attribution until after drafting, when claim wording may no longer map cleanly to the original evidence. Option D maximizes theoretical completeness but introduces extensive irrelevant material, higher token costs, slower processing, and greater context pollution. The synthesis draft plus a structured claim-to-source index maintains evidentiary completeness where it matters while eliminating intermediate searches, duplicate passages, and other low-value context.

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

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

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

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

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

The Messages API exposes stop_reason specifically so the application can determine why Claude stopped generating and what action is required next. A value of tool_use means Claude is requesting one or more tools and expects the application to execute them and return corresponding tool_result blocks. A value of end_turn means Claude has naturally completed the response. ( https://platform.claude.com/docs/en/build-with-claude/handling-stop-reasons )

Anthropic’s agent-loop tutorial implements this as a loop that continues executing tools and returning results while stop_reason remains tool_use . Once the value changes, the response is treated according to the new terminal or continuation condition. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent )

Option A is unreliable because an assistant response can contain both text and tool-use blocks. Text alone does not prove that the workflow is complete. Option B requires the application to predict that no further tool call is needed, defeating Claude’s ability to adapt from tool results. Option D is an important safety limit but is not the primary completion signal; an arbitrary maximum may terminate a valid workflow prematurely.

The harness should check stop_reason , process every requested tool call, append results to the conversation, and maintain a separate maximum-turn safeguard against runaway loops.

Official references/topics: Messages API stop reasons, tool-use loops, tool-result continuation, bounded orchestration.

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.

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

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.

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

An aggregate accuracy value can conceal severe performance disparities. A system may achieve 97% overall accuracy while performing poorly on a low-volume document type, a critical financial field, or a specific edge case. Automating outputs solely from the aggregate figure could therefore expose downstream systems to concentrated, high-impact errors.

Anthropic’s evaluation guidance states that evaluations should be task-specific, reflect the real-world task distribution, and explicitly include edge cases. It also emphasizes multidimensional success criteria rather than reliance on a single global metric. ( https://docs.anthropic.com/en/docs/build-with-claude/develop-tests ) Option A applies those principles by stratifying performance according to document type and field. This reveals whether confidence is calibrated consistently and whether the proposed automation threshold remains safe for every operationally significant segment.

Option B is useful only after segment-level performance has been understood. Selecting a global threshold cannot correct a subgroup where confidence is systematically overstated. Option C is necessary governance work, but it treats the overall 97% result as though errors were uniformly distributed. Option D places unvalidated outputs into downstream systems and depends on passive error reporting, which may fail to detect silent corruption.

The correct deployment gate is therefore segmented validation, followed by threshold selection, downstream acceptance criteria, and a controlled pilot.

Official references/topics: Define Success Criteria; Task-Specific Evaluations; Edge-Case Coverage; Reliability Segmentation.

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

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

Option D identifies the dominant capacity problem. Anthropic states that everything sent in a request counts toward the context window : the system prompt, messages, documents, tool results, tool definitions, and the output Claude generates. A 175,000–190,000-token document is therefore not the complete input. Adding a 2,500-token tool schema, system instructions, wrappers, and the reserved output budget can push a nominally sub-200,000-token document close to or beyond the effective limit. Anthropic also warns that more context is not automatically better and that accuracy and recall can degrade as token count grows, a behavior described as context rot. That combination explains why short documents remain accurate while long documents lose information. Option A predicts a problem independent of document length, contradicting the measurements. Option B is an unsupported generalization and does not account for tool-definition overhead. Option C recognizes long-context degradation but ignores the concrete evidence that hidden prompt components consume the same window. The correct response is to count tokens for the complete request before submission, reserve output capacity, and chunk or retrieve relevant sections when the total approaches the model’s supported window.

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

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

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

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

Direct @ references provide Claude with the exact implementations it must imitate. Anthropic documents that referencing a file with @ includes the full file content in the conversation, and multiple files can be referenced in one message. This gives Claude immediate access to the real transaction boundaries, exception structures, audit fields, naming conventions, and helper APIs used by the project. ( https://code.claude.com/docs/en/common-workflows )

Option B is inappropriate because the task is explicitly one-off and the conventions are already documented elsewhere. CLAUDE.md is loaded into every session and should contain concise information that broadly applies to the project. Adding detailed implementation material for a single integration would consume context unnecessarily. Anthropic recommends moving occasional procedures to skills and keeping CLAUDE.md limited to persistent, widely applicable guidance. ( https://code.claude.com/docs/en/memory )

Option C loses precision because a natural-language summary may omit subtle but important code behavior. Option D asks Claude to rediscover files that have already been identified, increasing exploration time and context usage.

The most effective prompt should reference all three modules, identify which pattern each demonstrates, specify the new module’s required behavior, and request focused tests proving that the established conventions were followed.

Official references/topics: @ file references, rich prompt context, CLAUDE.md scope, pattern-based implementation.

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

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. ( https://platform.claude.com/docs/en/build-with-claude/working-with-messages )

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.

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

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

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

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

Option D improves the generation conditions instead of filtering defective output afterward. Anthropic recommends using CLAUDE.md for repository-wide standards and information that Claude should apply in every session. The file can define what constitutes a useful test, require assertions on observable behavior, identify approved fixture factories, prohibit duplication of existing scenarios, and provide contrasting examples of strong and trivial tests. These instructions are available before Claude decides what tests to create.

Option A may remove some weak tests, but it doubles model work and still permits the first stage to generate low-quality material. Option B treats line coverage as a quality measure even though a trivial assertion can execute new lines without validating behavior. Option C abandons difficult areas rather than improving generation. The standards should also direct Claude to inspect nearby tests and fixtures before writing new cases, identify the behavior or regression each test protects, and run the relevant suite afterward. Because CLAUDE.md consumes context in every session, the guidance should remain concise; lengthy testing procedures are better placed in a reusable skill referenced from the project instructions.

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

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 D preserves the evidence instead of manufacturing certainty. The two estimates are not directly interchangeable: one is an industry estimate with unspecified methodology, while the other is a peer-reviewed estimate with an explicit confidence interval. Converting both into model-generated confidence scores and calculating a weighted average would create a new figure that neither source reported and that may have no statistical validity. Anthropic’s hallucination-reduction guidance recommends making claims auditable through quotations, citations, and supporting evidence rather than presenting unsupported synthesis as fact. Its Citations documentation similarly emphasizes retaining the exact source passages supporting individual claims. Filtering uncertain findings, option B, would remove decision-relevant information. Requiring two-source corroboration, option C, could also discard credible evidence concerning emerging or specialized subjects. The synthesis agent should report the estimates separately, explain their methodological differences, identify which findings are strongly supported or disputed, and state what evidence would resolve the disagreement. This produces calibrated, useful reporting without arbitrary selection, excessive hedging, or false precision.

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

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.

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

Claude Code’s --bare option is specifically designed for faster scripted execution. It skips automatic discovery of CLAUDE.md files, hooks, skills, plugins, MCP servers, and auto-memory while retaining essential built-in capabilities such as Bash, file reading, and file editing. Because --bare also prevents automatic loading of the root CLAUDE.md, the required standards must be added explicitly.

Option C accomplishes both objectives. --append-system-prompt-file ./CLAUDE.md loads the project standards into the current invocation while preserving Claude Code’s default coding-agent system prompt and tool-use guidance. According to the official Claude Code CLI reference , append flags add file contents to the default system prompt, whereas replacement flags discard that default guidance.

Option A could work functionally but duplicates the standards in every command and creates configuration drift. Option B replaces the complete default prompt, removing useful coding, safety, and tool-use instructions. Option D improves prompt-cache reuse across different machines, but it does not disable hooks, plugins, skills, MCP servers, or CLAUDE.md discovery and therefore does not directly address the measured initialization delay.

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

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

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

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

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

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

Formatting is deterministic and should be enforced by deterministic tooling rather than stronger natural-language instructions. A PostToolUse hook executes after a successful tool operation. Matching Edit|Write restricts the hook to file modifications, allowing the edited file path to be passed directly to Prettier.

Anthropic provides this exact pattern in its official hooks guidance: configure a PostToolUse event with an Edit|Write matcher and run Prettier against the modified file. This ensures formatting occurs automatically after every relevant edit instead of depending on Claude remembering to execute a formatter. ( https://code.claude.com/docs/en/hooks-guide )

Option A still relies on instruction-following and unnecessarily loads procedural material. Option B asks another probabilistic model evaluation to determine whether formatting is correct, even though Prettier can enforce the result directly. A Stop hook also runs later than necessary. Option C improves contextual relevance but does not guarantee compliance; path-scoped rules remain instructions rather than enforcement controls.

The hook should be stored in project settings so the workflow is shared by the team. The formatter’s exit status should also be monitored so configuration or syntax failures are visible instead of silently ignored.

Official references/topics: Claude Code Hooks; PostToolUse; Edit|Write Matchers; Deterministic Formatting Enforcement.

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

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

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

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 corrects the weak selection signal presented to the model. Claude chooses among available tools using their names, descriptions, parameter schemas, and the current request. “Extracts a function from code” does not explain whether the tool understands syntax trees, preserves imports, updates call sites, validates scope, or offers advantages over Write and sed. Anthropic identifies prompt-engineering tool descriptions as one of the most effective ways to improve agent tool use. Descriptions should state what the operation performs, when it should be selected, what inputs are required, what output it returns, and any limitations.

Option A adds a separate probabilistic routing layer without improving the tool contract Claude ultimately sees. Option B ignores the server’s intended value. Option D removes a broadly useful capability and may prevent unrelated edits without guaranteeing that the MCP tools are used correctly. Each refactoring tool should instead describe its semantic behavior and contrast it with plain text manipulation—for example, that rename_variable performs scope-aware symbol renaming and updates references. Clear schemas, concrete examples, and evaluation against real refactoring tasks should accompany the improved descriptions.

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

Option A gives the report generator the finished narrative context plus the evidence required to verify and cite its claims. The 3,000-token synthesis draft supplies organization and conclusions, while the source index preserves URLs, supporting excerpts, and claim-to-source mappings without transferring 120,000 tokens of raw search material. Anthropic’s effective context-engineering guidance recommends curating the smallest high-signal context and having subagents return condensed, distilled results rather than flooding later stages with their complete working history. Anthropic’s citation guidance likewise depends on retaining specific supporting passages and source locations. Option B is complete but inefficient and introduces context pollution that can reduce attention to relevant evidence. Option C separates citation insertion from the reasoning that produced the claims, making incorrect or unsupported matches more likely. Option D retains source names but discards the passages needed to demonstrate that each source actually supports the associated claim. The structured index should use stable source IDs and include only the excerpts necessary for the report’s factual claims, with validation that every cited claim maps to at least one evidence entry.

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

MCP allows a Claude application to connect to multiple servers and expose their enabled tools within the same agentic interaction. Anthropic’s MCP connector documentation explicitly supports connecting to multiple MCP servers in one request. Once connected, Claude can invoke a server’s tool when the user’s request corresponds to the capability described by that tool. ( https://docs.anthropic.com/en/docs/agents-and-tools/mcp-connector )

In this scenario, the git server can provide the branch-creation operation, the documentation server can locate the relevant links, and the Jira server can update ticket JIRA-123. The agent can coordinate these capabilities without requiring a separate conversational turn that restricts it to only one server. Tool descriptions and schemas tell Claude what each operation does and what inputs it requires.

Option B incorrectly describes sequential capability discovery. Server identity and tool definitions are established through the MCP configuration rather than discovered by querying every server for each operation. Option C is incorrect because connecting several servers does not inherently restrict the agent to a single selected server. Option D imposes a one-server-per-turn limitation that MCP does not require.

Access can still be controlled through allowlists, denylists, permissions, and per-tool configuration. Those controls restrict which tools are enabled; they do not change the fundamental ability to make tools from multiple configured servers available together.

Official references/topics: MCP Server Configuration, Multi-Server Tool Access, Tool Discovery, MCP Tool Permissions.

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.

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

The agent must preserve durable state for several concurrently open issues without keeping every conversational turn in the active context window. Option D creates a structured issue ledger containing identifiers, issue type, requested action, current status, completed steps, unresolved questions, and relevant tool outputs.

Anthropic recommends structured note-taking for long-horizon agents. In this pattern, critical state is written outside the context window and retrieved later, allowing the agent to preserve dependencies and progress across dozens of tool calls. Anthropic also describes compaction as retaining critical details while discarding redundant raw messages and historical tool output. ( https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents )

Option A is better than retaining the entire transcript, but a narrative summary can merge separate issues or obscure exact identifiers and statuses. Option B will discard the refund conversation because it occurred outside the most recent 30 turns. Option C may recover current backend facts, but it cannot reconstruct conversational commitments, prior explanations, or why a particular action remains pending.

A structured context layer should maintain one record per issue and be updated after every material action. The active prompt can include compact summaries of all open issues and expanded details only for the issue currently being discussed.

Official references/topics: Structured note-taking, external agent memory, context compaction, multi-issue state management.

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.

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

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 .

Option A separates competing objectives so each review call can devote its attention and examples to a coherent concern. Anthropic’s Building Effective AI Agents describes sectioning as a parallelization pattern in which independent aspects are handled by separate model calls and then aggregated. It specifically notes that models generally perform better on complex tasks when each consideration receives focused attention. The evaluation results demonstrate prompt interference: optimizing business-logic detection reduces API-design recall.

A security and API-design reviewer can use examples, terminology, and evidence criteria appropriate to interfaces and vulnerabilities. A business-logic reviewer can focus on state transitions, arithmetic boundaries, invariants, and domain-specific edge cases. Their structured findings can then be deduplicated and ranked before posting. Option B may improve only the weak category and can overfit to known quiz-scoring failures. Option C assumes that model capacity alone removes prompt interference without evaluation evidence. Option D adds substantial unrelated context and does not isolate the competing review objectives. The split prompts should be evaluated independently and together so consolidation does not reintroduce omissions or duplicate findings.

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