The supplied question identifies B as the intended answer. Tool schemas are contracts between Claude and executable application code. When the downstream service accepts only a defined set of arguments, relaxing that schema merely shifts invalid data farther into the system and increases runtime failures.

Anthropic's current tooling provides an even stronger implementation of this principle through strict tool use . Setting strict: true constrains tool inputs to the declared JSON Schema, preventing undeclared properties, missing required values, and incompatible parameter types where the supported schema subset is used. Anthropic explicitly recommends strict tool use for validated parameters, type-safe function calls, and reliable agentic workflows.

In a non-strict or legacy implementation, the application should still validate arguments before dispatch and convert invalid calls into structured tool errors that Claude can interpret and potentially correct. A prompt instruction can reinforce behavior, but it should not replace deterministic validation. C and D weaken the system boundary and knowingly send invalid calls downstream.

Therefore, maintain the contract rather than adapting the contract to malformed model output.

Relevant Claude Developer topics: Agent Construction, tool schemas, strict tool use, JSON Schema, parameter validation, structured errors, retry behavior, and defensive execution boundaries .

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

Option D addresses the architectural cause of the failure: an ambiguous tool surface. Claude chooses tools partly from their names, descriptions, schemas, and the relationship between the request and the capability described. If multiple tools appear to perform substantially the same task, selection becomes unnecessarily difficult.

Anthropic’s tool-definition guidance explicitly recommends consolidating related operations into fewer tools and making descriptions clear about both what a tool does and when it should be used. The documentation notes that fewer, more capable tools reduce selection ambiguity and make the available tool surface easier for Claude to navigate.

Option A makes the ambiguity worse by expanding an already overlapping tool set. B destroys required application capabilities. C could improve selection somewhat, because examples can clarify complex inputs, but it leaves the underlying duplication intact. Examples complement good tool design; they are not a substitute for distinct tool responsibilities.

Therefore, D is the strongest solution: remove unused tools, merge functions that represent the same conceptual operation, and write discriminative descriptions defining appropriate and inappropriate usage. Relevant Study Guide topics: tool design, tool selection, descriptions, tool consolidation, agent construction, and reducing ambiguity.

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

The question presents a trust-boundary failure: model-generated tool arguments are being accepted without sufficient validation before an external operation executes. A tool call should therefore be treated like input arriving at any typed application interface—the application must ensure that the tool name and arguments satisfy the declared contract before dispatch.

Anthropic describes tool use as a contract in which the application defines the tool's schema and Claude returns structured tool_use input. Current Claude functionality also supports strict: true, which guarantees schema-compliant tool inputs through constrained generation and specifically addresses invented parameters, incompatible types, and missing required fields. For applications not using strict tool use, explicit application-side validation and a controlled error path remain essential.

B knowingly executes invalid input. C relies on uncontrolled repetition rather than deterministic validation and bounded recovery. D eliminates a useful capability instead of correcting its execution boundary.

Therefore, A provides the correct defensive design. Relevant Study Guide topics: tool calling, tool_use, input_schema, strict tool use, schema validation, defensive execution, error handling, and secure tool dispatch.

Option B is correct because destructive production operations require deterministic enforcement outside the model’s probabilistic reasoning. Claude Code hooks can intercept lifecycle events before tool execution and explicitly allow, deny, or request further handling based on concrete rules.

Anthropic’s hooks documentation provides this exact security pattern. A PreToolUse hook can inspect a proposed command before execution and return a blocking decision. Anthropic’s example demonstrates blocking destructive operations such as drop table, while other commands proceed normally.

That mechanism can be adapted to database controls: block DROP, destructive DELETE, unauthorized schema modifications, or production writes; require explicit approval for high-risk operations; and allow read-only or known-safe queries automatically.

A merely increases the probability that someone might notice an unsafe operation and does not prevent execution. C assumes model capability can replace access controls, which is an unacceptable safety boundary. D is useful behavioral guidance but remains probabilistic and cannot guarantee prevention.

Therefore, B creates a deterministic control between model intent and side-effect execution. Relevant Study Guide topics: Claude hooks, PreToolUse, tool governance, deterministic enforcement, approval gates, least privilege, and destructive-operation protection.

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

The question presents a trust-boundary failure: model-generated tool arguments are being accepted without sufficient validation before an external operation executes. A tool call should therefore be treated like input arriving at any typed application interface—the application must ensure that the tool name and arguments satisfy the declared contract before dispatch.

Anthropic describes tool use as a contract in which the application defines the tool's schema and Claude returns structured tool_use input. Current Claude functionality also supports strict: true, which guarantees schema-compliant tool inputs through constrained generation and specifically addresses invented parameters, incompatible types, and missing required fields. For applications not using strict tool use, explicit application-side validation and a controlled error path remain essential.

B knowingly executes invalid input. C relies on uncontrolled repetition rather than deterministic validation and bounded recovery. D eliminates a useful capability instead of correcting its execution boundary.

Therefore, A provides the correct defensive design. Relevant Study Guide topics: tool calling, tool_use, input_schema, strict tool use, schema validation, defensive execution, error handling, and secure tool dispatch.

Option D addresses the architectural cause of the failure: an ambiguous tool surface. Claude chooses tools partly from their names, descriptions, schemas, and the relationship between the request and the capability described. If multiple tools appear to perform substantially the same task, selection becomes unnecessarily difficult.

Anthropic’s tool-definition guidance explicitly recommends consolidating related operations into fewer tools and making descriptions clear about both what a tool does and when it should be used. The documentation notes that fewer, more capable tools reduce selection ambiguity and make the available tool surface easier for Claude to navigate.

Option A makes the ambiguity worse by expanding an already overlapping tool set. B destroys required application capabilities. C could improve selection somewhat, because examples can clarify complex inputs, but it leaves the underlying duplication intact. Examples complement good tool design; they are not a substitute for distinct tool responsibilities.

Therefore, D is the strongest solution: remove unused tools, merge functions that represent the same conceptual operation, and write discriminative descriptions defining appropriate and inappropriate usage. Relevant Study Guide topics: tool design, tool selection, descriptions, tool consolidation, agent construction, and reducing ambiguity.

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

The supplied question identifies B as the intended answer. Tool schemas are contracts between Claude and executable application code. When the downstream service accepts only a defined set of arguments, relaxing that schema merely shifts invalid data farther into the system and increases runtime failures.

Anthropic's current tooling provides an even stronger implementation of this principle through strict tool use . Setting strict: true constrains tool inputs to the declared JSON Schema, preventing undeclared properties, missing required values, and incompatible parameter types where the supported schema subset is used. Anthropic explicitly recommends strict tool use for validated parameters, type-safe function calls, and reliable agentic workflows.

In a non-strict or legacy implementation, the application should still validate arguments before dispatch and convert invalid calls into structured tool errors that Claude can interpret and potentially correct. A prompt instruction can reinforce behavior, but it should not replace deterministic validation. C and D weaken the system boundary and knowingly send invalid calls downstream.

Therefore, maintain the contract rather than adapting the contract to malformed model output.

Relevant Claude Developer topics: Agent Construction, tool schemas, strict tool use, JSON Schema, parameter validation, structured errors, retry behavior, and defensive execution boundaries .

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

Option A is correct because sensitive-data protection must occur before prohibited information crosses the application's trust boundary. If account numbers, passwords, or other secrets must not be sent to Claude, asking Claude to “ignore” those values after transmission does not satisfy the requirement. The application must determine which data is permitted to leave its controlled environment and transform or reject prohibited content before constructing the Claude request.

This principle is consistent with Anthropic's defense-in-depth guidance. Anthropic recommends input screening, limiting Claude's access to sensitive information, and applying least privilege so the model receives only information necessary for the task.

B is fundamentally too late: the sensitive information has already been transmitted to the model context before the system instruction can influence behavior. C is worse because logging can create an additional store containing the sensitive information and only detects exposure after it occurs. D implements some boundary filtering but deliberately leaves coverage incomplete until production incidents reveal additional patterns.

Therefore, A requires the boundary and its permitted data flows to be defined first, then enforced comprehensively through filtering, redaction, tokenization, or rejection. Relevant Study Guide topics: application boundaries, data minimization, sensitive-data handling, filtering, redaction, least privilege, and privacy-preserving design.

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

Option A is correct because the Message Batches API is designed for asynchronous, high-volume processing where results do not need to be returned interactively. Anthropic’s API reference states that a Message Batch can contain many independent Messages requests and may take up to 24 hours to complete. That makes it appropriate for 10,000 overnight email-extraction jobs with a several-hour completion window.

Streaming in B solves a different requirement: it exposes partial response events while a single request is being generated, which is valuable for interactive user experiences or long-running synchronous requests, but it does not provide the workload-management advantages of a batch job. C processes items sequentially and unnecessarily sacrifices throughput. D can increase throughput with concurrent real-time calls, but it adds concurrency management and rate-limit pressure when the workload explicitly tolerates asynchronous completion.

The batch design also lets each request carry a custom identifier so results can be matched back to source emails even if completion order differs. Therefore, A is the intended Claude API choice. Relevant Study Guide topics: Message Batches API, asynchronous processing, high-volume workloads, request correlation, throughput, and non-interactive application design.

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

The supplied Claude Certified Developer Foundations source marks C . Model selection is a multidimensional engineering decision. There is no universally correct Claude model independent of workload requirements; the application must satisfy the required capability or quality while remaining within acceptable latency and cost envelopes.

Anthropic's official model-selection guidance explicitly identifies capabilities, speed, and cost as core considerations and recommends testing models against workload-specific benchmarks rather than selecting them from a single metric. The guidance further recommends evaluating actual prompts and data, comparing response accuracy, quality, and edge-case behavior, and then weighing the resulting performance and cost tradeoffs.

Options A, B, and D each establish one or two dimensions as primary and effectively defer the remainder. That can lead to a technically unsuitable model—for example, a cheap model that fails the quality threshold or a high-quality model whose latency makes the user experience unacceptable.

The correct method is to define minimum acceptable thresholds across all relevant dimensions and benchmark candidate models against the actual workload.

Relevant Claude Developer topics: Claude App Design, model selection, capability, quality, latency, cost, benchmarking, workload evaluation, tradeoff analysis, and production optimization .

D follows the principle of choosing the simplest architecture that satisfies demonstrated requirements . The supplied examination item explicitly marks D. In this scenario, portability is neither a present functional requirement nor a foreseeable roadmap requirement. Adding an abstraction therefore creates measurable complexity without delivering an identified product capability.

Anthropic provides official general-purpose SDKs for Claude in multiple languages. These expose the Messages API directly while adding idiomatic interfaces, type safety, streaming support, retries, and error handling. Anthropic separately describes compatibility layers and framework-specific libraries as alternative integration surfaces rather than requirements for ordinary Claude development.

A third-party abstraction becomes rational when there is a genuine requirement for multiple providers, vendor switching, standardized cross-model interfaces, or an existing architectural platform that mandates it. None exists here. Building that flexibility speculatively increases dependencies, debugging surface, version-compatibility work, and the possibility that provider-specific Claude capabilities are hidden behind a lowest-common-denominator API.

A optimizes for hypothetical future requirements. B doubles operational complexity. C creates an even larger maintenance burden.

Relevant Claude Developer topics: Claude App Design, SDK selection, abstraction boundaries, dependency management, YAGNI, integration architecture, and provider portability requirements .

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

Option C accurately captures Anthropic’s distinction. Prompt engineering primarily concerns how instructions are written, structured, and organized to obtain the desired behavior from a particular model invocation. Techniques include explicit instructions, examples, roles, XML structure, output requirements, and task-specific prompt construction. Context engineering operates at a broader architectural level: it determines which information should actually be present in the model’s context at each inference step.

Anthropic defines prompt engineering as methods for writing and organizing LLM instructions, whereas context engineering encompasses strategies for curating and maintaining the optimal set of tokens during inference. For long-running agents, context can contain system instructions, tools, MCP resources, retrieved documents, prior messages, tool results, summaries, and memory.

This distinction matters because multi-step agents continuously generate new state. Effective systems may prune obsolete results, retrieve information just in time, compact earlier conversation history, isolate subagent contexts, or store persistent state externally. B is incorrect because context engineering has not simply replaced prompt engineering; the two operate at different scopes. A defines context too narrowly, and D obscures an important architectural distinction.

Therefore, C correctly represents Claude Developer coverage of prompt engineering versus context engineering, context curation, agent state, long-horizon workflows, and context-window optimization.

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

Option D combines the three key properties of a reliable Claude tool: an explicit contract, clear tool-selection guidance, and controlled execution failure handling. Anthropic's tool documentation defines user tools using a name, detailed description, and JSON input_schema. The description should explain what the tool does, when it should and should not be used, parameter semantics, and relevant limitations. Anthropic emphasizes that precise descriptions materially improve Claude's ability to select the correct tool.

A clear schema prevents ambiguous parameter interpretation and allows validation before calling the external pricing API. Where stronger guarantees are required, Anthropic also supports strict tool use, which constrains generated tool inputs to the declared JSON Schema.

The application's execution layer must also convert pricing-service failures into explicit, handled error paths rather than uncontrolled exceptions. A deprives Claude of critical selection information. B increases malformed-call risk. C delegates infrastructure reliability to the reasoning loop instead of implementing appropriate integration error handling.

Therefore, D represents production-quality custom-tool construction. Relevant Study Guide topics: custom tools, JSON Schema, tool descriptions, validation, external API integration, and error handling.

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

Option A correctly treats this as a context-dependent format drift problem rather than an arbitrary model failure. Because the application initially produces valid JSON and progressively loses structure over subsequent turns, the investigation should focus on how accumulated conversation history changes the instructions and examples visible to Claude. Earlier malformed outputs, conflicting instructions, tool results, or unnecessary historical content can gradually reduce adherence to the intended format.

The application should therefore inspect the conversation state, preserve the authoritative formatting requirement, prune irrelevant content where appropriate, and validate outputs at the application boundary. Anthropic's Structured Outputs capability is specifically designed to prevent malformed structured responses by constraining Claude to a supplied JSON Schema. Official guidance states that Structured Outputs provide valid, parseable, schema-compliant results for downstream processing.

B destroys the response rather than correcting the failure mode. C resets state but prevents meaningful multi-turn operation and does not diagnose why context causes drift. D changes model characteristics without establishing that the model is responsible.

The supplied question on page 12 identifies A as correct. Relevant topics: Agent Architecture, context engineering, format drift, structured outputs, context evolution, schema validation, and long-running conversations.

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

The supplied examination page marks B . The scenario already demonstrates why model upgrades must be treated as evaluated software changes rather than automatic replacements: the new model improves one metric while introducing a regression in another.

Anthropic's official model-selection guidance recommends creating benchmark tests specific to the application's use case, testing models with the application's actual prompts and data, comparing response quality and edge-case performance, and weighing performance against operational tradeoffs. Therefore, the correct action is to adapt the multi-section system prompt to the new model's behavior and repeat the evaluation. Only after the formatting regression is eliminated—or reduced below an explicitly acceptable threshold—should the upgrade proceed.

A incorrectly assumes that an 8% reasoning improvement numerically compensates for a 3% malformed-output rate; these metrics measure different consequences and cannot simply be subtracted. C treats the known incompatibility only downstream instead of first correcting the prompt/model interaction. D permanently rejects future improvement and is inconsistent with controlled lifecycle evolution.

The engineering principle is migration through regression testing and adaptation , not blind upgrading or permanent version avoidance.

Relevant Claude Developer topics: Systems Life Cycle, model migration, regression evaluation, prompt adaptation, compatibility testing, deployment gates, and continuous evolution .

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

Option B creates a clear separation between persistent application instructions and per-request user content. Stable behavioral rules—role, output conventions, formatting constraints, policies, and other instructions intended to apply across requests—belong in the system-level instruction layer. User messages should primarily carry task-specific input and requirements that vary from interaction to interaction.

Anthropic’s Messages API defines the system prompt specifically as the mechanism for providing overarching context and instructions to Claude. Current guidance likewise recommends the top-level system field for instructions that should apply from the beginning of the conversation, while more transient information belongs in conversation messages.

A mixes persistent application behavior with user-controlled content and weakens separation of concerns. C preserves the inconsistent architecture responsible for the problem. D duplicates instructions unnecessarily, wastes context tokens, and increases the possibility that future edits create conflicting versions of the same rule.

Consolidating stable instructions also makes prompts easier to version, evaluate, review, and maintain. Therefore, B is the correct design. Relevant Study Guide topics: system prompts, instruction hierarchy, prompt organization, formatting consistency, separation of concerns, and maintainable prompt construction.