CCDV-F Sample Questions Answers

Option D applies the correct hybrid pattern. Anthropic distinguishes workflows—where LLMs and tools execute along predefined code paths—from agents, where the model dynamically determines how to proceed. Anthropic recommends choosing the simplest architecture that meets the requirement: workflows provide predictability and consistency for well-understood tasks, while agents are valuable where flexible model-driven decisions are necessary.

Standard invoice processing is explicitly described as a small number of known steps. That makes a deterministic workflow the appropriate default because the path can be tested, monitored, and reproduced. The unexpected-format branch is different: the system must reason among rerouting, requesting clarification, or human escalation. That decision point is where agentic flexibility adds value.

A makes the entire process autonomous even though most steps do not require autonomy, increasing cost, latency, and unpredictability. B introduces multiple specialized agents despite no demonstrated need for that complexity. C collapses deterministic processing and exception handling into one monolithic model call, making validation and debugging harder.

Therefore, D combines workflow predictability with targeted agentic reasoning. Relevant Study Guide topics: workflows versus agents, routing, exception handling, hybrid agentic architecture, escalation, and complexity minimization.

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

Option B addresses the actual architectural failure: low-value historical material is crowding out the high-signal information required for current reasoning. A larger context window does not guarantee better attention to important constraints. Effective agent architecture actively manages what remains in context as the workflow progresses.

Anthropic's Context Editing documentation explicitly provides tool-result clearing for agentic workflows with heavy tool usage. Once Claude has processed an older result, verbose file contents, search output, or API responses may no longer need to remain in full. Older results can therefore be removed while recent and important state remains available. Anthropic also documents compaction, where accumulated history is summarized and replaced with a smaller representation that preserves important task state.

A removes an important agent capability rather than solving context growth. C retains all accumulated noise and merely gives it more space. D repeatedly destroys valuable task state and creates artificial workflow boundaries.

Therefore, B preserves goals, decisions, unresolved constraints, and necessary results while reducing irrelevant historical content. Relevant Study Guide topics: context engineering, tool-result clearing, compaction, long-running agents, context quality, and task-state preservation.

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

The supplied exam source identifies C . Tool descriptions are part of Claude's runtime decision context. A descriptive function name can indicate what a tool appears to do, but it may not clearly tell Claude when to use it, when not to use it, what assumptions apply, or how it differs from similar tools .

Anthropic's official tool-use documentation states that Claude determines whether to call a tool based on the user's request and the tool's description. Its tool-definition guidance defines description as detailed plaintext describing what the tool does, when it should be used, and how it behaves. Anthropic's troubleshooting guidance also identifies ambiguous descriptions as a cause of selecting the wrong tool and recommends differentiating tools by when they should be used, not only by what they do.

A can supplement descriptions with examples but should not universally replace them. B incorrectly assumes names provide sufficient semantics. D removes the information from Claude's actual decision context.

Therefore, tool descriptions are operational metadata for model routing, not merely documentation for developers.

Relevant Claude Developer topics: Agent Construction, tool definitions, tool descriptions, tool selection, schema design, disambiguation, routing, and reliable tool use .

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

D is the only option that addresses all three identified production-readiness defects. The supplied Claude Developer item explicitly selects D. A functioning happy path is insufficient for a maintainable Claude integration.

Prompt and model selection are configuration concerns that will change as prompts are evaluated, model versions evolve, or environments require different behavior. They should therefore be separated from unrelated business logic rather than scattered as inline constants. Claude API failures must also be handled deliberately. Anthropic documents typed SDK exceptions and defined HTTP error categories, including invalid requests, authentication failures, rate limits, server errors, overload, and timeouts. The official SDKs additionally retry appropriate transient failures.

Tests are required to verify the integration boundary, including successful behavior, malformed or unexpected responses, API error handling, and critical user workflows. Approving code without those controls pushes known reliability debt directly into production.

A and B knowingly merge incomplete production behavior. C improves configuration and test coverage but leaves a known API-failure path unhandled.

Relevant Claude Developer topics: SW Eng Foundations, code review, separation of configuration, error handling, integration testing, API resilience, maintainability, and production readiness .

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

Option C applies an orchestrator-worker architecture to a request containing several distinct domains. Rather than making one agent continuously switch between billing, shipping, and product reasoning, an orchestrator can decompose the ticket, delegate each concern to an appropriately scoped specialist, track completion, and consolidate the resulting recommendations.

Anthropic describes this architecture directly: an orchestrator dynamically breaks down a task, delegates subtasks to worker agents, and synthesizes their results. Anthropic's multi-agent Research system similarly uses a lead agent that coordinates specialized subagents operating with independent contexts.

A rigid workflow is inappropriate because not every ticket contains the same combination or ordering of issues. B can improve behavior but leaves one agent responsible for managing all competing concerns and state. D increases raw context capacity without addressing decomposition or responsibility boundaries.

C is therefore the strongest architectural change when separate issue categories can be handled independently and then reconciled by a coordinating component. Relevant Study Guide topics: orchestrator-workers, subagents, delegation, task decomposition, context isolation, coordination, and synthesis.

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

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 C follows the governing constraint in the scenario: data residency is an enterprise requirement, whereas minimizing infrastructure management is a preference. A deployment architecture cannot knowingly violate a mandatory compliance boundary merely to accelerate delivery. The question should therefore be interpreted under its stated assumption that the described BYOC environment satisfies the enterprise residency policy.

Anthropic's current Managed Agents documentation distinguishes Anthropic-managed cloud environments from self-hosted sandboxes running on infrastructure controlled by the customer. Self-hosting keeps tool execution, files, and network egress within customer infrastructure, although Anthropic documents that model-facing tool inputs and outputs can still pass through its control plane; therefore, actual regulatory approval must be based on the organization's precise data-flow requirements.

B and D explicitly defer or violate the existing policy. A unnecessarily introduces a planned migration away from the residency-compliant architecture without establishing that such a migration would be permissible.

Accordingly, C is the intended certification answer. Relevant Study Guide topics: deployment topology, data residency, self-hosting, compliance constraints, infrastructure ownership, security boundaries, and architecture tradeoffs.

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

B is directly supported by both the supplied examination source and Claude Code's configuration model. The source marks the hierarchical CLAUDE.md approach as correct. Claude Code supports instructions at multiple scopes, allowing broadly applicable standards to be separated from project-specific context rather than duplicated across every repository.

Anthropic documents several CLAUDE.md scopes. Organization-managed instructions can apply broadly; user-level instructions in ~/.claude/CLAUDE.md apply across a user's projects; project instructions in ./CLAUDE.md or ./.claude/CLAUDE.md provide repository-specific architecture, conventions, commands, and workflows. Claude Code loads applicable files according to the directory hierarchy, allowing broad instructions and more specific local instructions to coexist.

This arrangement improves maintainability because common coding standards are defined once at the appropriate scope, while each repository retains only the context unique to that project. A documentation website does not automatically inject rules into Claude Code context. C creates inconsistent manual configuration. D improperly couples unrelated repositories to one repository's configuration.

Relevant Claude Developer topics: Confia Management, CLAUDE.md hierarchy, organization scope, user scope, project scope, repository configuration, instruction inheritance, and configuration reuse .

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

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 .

The correct approach is to evaluate each customization independently against both its original requirement and the capabilities currently supplied by the Claude SDK. Custom code has an ongoing maintenance cost, but automatically removing it is unsafe because some modifications may encode genuine application requirements that the standard SDK behavior still does not address. Conversely, automatically retaining every customization can preserve obsolete complexity after the SDK has evolved.

This is particularly relevant because Anthropic's SDKs already provide capabilities that developers might otherwise implement themselves. Official Claude API documentation states that SDKs provide built-in request formatting, error handling, retries, timeouts, and other integration functionality. For example, transient connection, rate-limit, and server errors are retried automatically with exponential backoff.

Therefore, each custom history, retry, or error-management layer should be reviewed for its actual purpose. If an SDK primitive now provides equivalent behavior, removing duplicate code improves maintainability. If the customization still satisfies a distinct requirement, it should remain.

The supplied exam source explicitly identifies D as the intended answer. Relevant topics: Agent Construction, SDK capabilities, abstraction boundaries, technical-debt management, retries, error handling, and agent state management.

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

D applies configuration as code and is the answer explicitly selected in the supplied examination source. Claude Code treats project configuration as part of the repository's working context. Anthropic documents project-level CLAUDE.md as the mechanism for providing project instructions and context, while shared project configuration belongs in .claude/settings.json. Crucially, Anthropic states that .claude/settings.json is intended to be checked into source control and shared with the team .

Keeping these files alongside the code establishes a single versioned relationship between application behavior and the configuration that influences Claude Code. Standard pull requests then provide diffs, peer review, ownership controls, CI validation, audit history, and straightforward rollback. A particular commit can therefore reproduce both source code and its associated Claude project configuration.

A creates competing copies and synchronization risk. B artificially separates behavior configuration from the code version it affects. C creates the same problem specifically for settings.json.

Developer-local values remain distinct: .claude/settings.local.json exists specifically for settings that should not be committed.

Relevant Claude Developer topics: Confia Management, CLAUDE.md, settings.json, configuration as code, source control, pull-request review, reproducibility, auditability, and team-shared Claude Code configuration .

Option C is correct because operational error handling should distinguish failures by impact, urgency, and recoverability. Anthropic’s API documentation already separates error conditions by type and documents different recovery behaviors. For example, transient connection failures, rate limits, and many 5xx errors are automatically retried by official SDKs with exponential backoff, while other failures require application correction or investigation. Treating all of those conditions as the same operational severity creates either alert fatigue or missed incidents.

A production design should classify errors using criteria such as user impact, data integrity risk, security exposure, persistence after retry, affected request volume, and whether automatic recovery succeeds. High-severity failures that threaten service availability or correctness can page the on-call engineer. Recoverable or isolated failures can be logged with structured metadata, request IDs, and metrics for later review.

Option A pages on everything and quickly makes alerts noisy. Option B destroys observability for non-paging errors. Option D preserves the original defect by assigning the same severity to every condition. Therefore, C follows sound Claude application operations. Relevant Study Guide topics: API errors, retries, observability, incident response, severity classification, structured logging, and production operations.

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

C converts validation failure from an uncontrolled terminal condition into a first-class recoverable error path . The supplied exam item identifies C as correct. If structured output does not meet the application's contract, it should never be forwarded as though valid, but immediate user-visible failure is also unnecessary when bounded recovery is possible.

A robust flow can retry generation, ask Claude to repair the malformed structure using the validation error as feedback, switch to an approved fallback path, or ultimately return a controlled failure if the retry budget is exhausted. The application must cap these recovery attempts to avoid unbounded loops.

Anthropic's Structured Outputs documentation explains that unconstrained model generation can produce parsing errors, missing fields, inconsistent types, or schema violations that otherwise require error handling and retries. Current Structured Outputs can eliminate many schema-level failures through constrained decoding, although exceptional conditions such as refusal or output truncation still require explicit handling.

A violates the validation boundary. B removes a protective control. D transfers an engineering reliability responsibility to end users.

Relevant Claude Developer topics: Claude App Design, structured output, validation, retries, repair loops, fallback logic, bounded recovery, error paths, and resilient downstream integration .

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

Option C follows a prompt-chaining/workflow decomposition pattern. Ticket classification and reply generation are materially different tasks. Triage may require a constrained category, priority, or routing decision, while response generation requires richer context, tone, policy compliance, and customer-facing language. Splitting the stages allows each Claude call to use a prompt, context set, model configuration, output format, and evaluation criterion appropriate to that specific responsibility.

Anthropic's guidance on effective agentic systems distinguishes predictable workflows from open-ended agents and recommends using the simplest architecture that meets requirements. Predefined workflows are particularly appropriate where work can be divided into clear processing stages.

This decomposition also creates useful engineering boundaries: the triage output can be validated before becoming input to the drafting stage; triage accuracy and response quality can be evaluated independently; and either stage can later be optimized without rewriting the entire process.

A unnecessarily restricts the second stage to rules. B introduces expensive parallel generation and a selection step without a stated requirement. D optimizes solely for call count while sacrificing task separation and observability.

The supplied exam source marks C. Relevant topics: Agent Patterns, prompt chaining, workflow decomposition, focused prompts, stage-level evaluation, and modular Claude application design.

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

Option B is correct. A large prompt containing overlapping, contradictory, or obsolete instructions creates instruction ambiguity and increases the likelihood that Claude will apply an unintended rule, over-weight irrelevant guidance, or produce inconsistent behavior.

Anthropic's current prompting guidance reinforces this principle: Claude performs best when instructions are clear, explicit, and direct. Prompt design should minimize ambiguity and provide the model with precisely the context and behavioral requirements needed for the task. Refactoring should therefore remove obsolete requirements, consolidate duplicated instructions, resolve contradictions, and establish one authoritative formulation for each behavioral rule. The revised prompt should then be regression-tested against representative inputs.

A makes an already overloaded prompt larger and relies on instruction ordering instead of eliminating conflicts. C addresses only one defect while retaining redundant and obsolete material. D does not inherently solve contradictions and may fragment authoritative instructions across multiple locations.

Therefore, B addresses the root cause. Relevant Study Guide topics: system prompt design, prompt maintainability, instruction clarity, conflicting instructions, prompt refactoring, regression evaluation, and context quality.

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

Option B follows standard secrets-management practice and Anthropic's explicit guidance for API credentials. API keys are authentication secrets and should not be embedded in source code or committed to repositories. Anthropic's authentication documentation explicitly recommends storing API keys in a secrets manager, rotating them periodically, and revoking credentials suspected of compromise. Anthropic SDKs can load Claude credentials from environment variables such as ANTHROPIC_API_KEY, allowing the secret to be injected at runtime instead of compiled into the application.

The same principle applies to external service credentials used by a Claude application. Development, staging, and production should normally receive independently scoped credentials through the deployment environment or secret-management infrastructure.

A creates a high-probability credential leak because repository history can retain secrets even after a later deletion. C violates isolation and least privilege by sharing credentials across services and users. D uses email as an uncontrolled secret-distribution channel and creates inconsistent manual configuration.

Therefore, B supplies credentials only at runtime while keeping them outside source control and enabling rotation and environment-specific access. Relevant Study Guide topics: API-key management, secrets managers, environment configuration, credential rotation, least privilege, and secure configuration.

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

A is the appropriate configuration-change control. The supplied examination item selects A . A prompt is not merely editorial text; in a Claude application it functions as executable behavioral configuration. Changing a prompt can alter output structure, field population, language, classifications, tool-use decisions, refusal behavior, or other assumptions on which downstream consumers depend.

Staging success therefore proves only the scenarios actually covered by staging. Before production rollout, the team must perform impact analysis across every dependent system, identify contractual expectations, run representative regressions, and coordinate changes where a consumer may be affected. This is especially important where downstream applications parse structured output or expect stable semantics.

Anthropic's Structured Outputs guidance illustrates why interface contracts matter: missing fields, inconsistent types, and schema violations can break consuming applications. Even when output remains syntactically valid, prompt changes can produce semantic changes that require consumer validation.

B assumes staging coverage is universal. C communicates the change without determining its consequences. D arbitrarily defers systems instead of assessing them.

Relevant Claude Developer topics: Confia Management, configuration impact assessment, prompt versioning, dependency management, change control, downstream contracts, regression testing, and coordinated deployment .

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

Option D follows the fundamental optimization rule of measuring before changing. Without feature-level usage telemetry, the team cannot know whether cost growth comes from request volume, long prompts, excessive outputs, low cache-hit rates, expensive models, agent loops, tool results, or one particularly inefficient workflow.

Anthropic's Usage and Cost API exists specifically to provide granular historical usage and cost information. It supports token tracking and breakdowns by dimensions including model, workspace, service tier, API key, context window, and other usage characteristics. Anthropic describes this data as useful for monitoring, cost reconciliation, optimization, and determining whether system changes improve efficiency.

B applies a model downgrade indiscriminately and may damage features whose quality requirements genuinely demand a stronger model. C similarly imposes an arbitrary token reduction without identifying where waste exists. A abandons cost management entirely.

The correct lifecycle is instrument, establish a baseline, identify high-cost features, analyze why they are expensive, apply targeted optimizations, and measure again. Relevant Study Guide topics: observability, usage telemetry, cost attribution, token accounting, production monitoring, capacity planning, and evidence-driven optimization.

The supplied question selects D . If a downstream component requires an exact machine-readable structure, the expected structure must be communicated explicitly rather than left to Claude's discretion. The prompt should define required fields, types, nesting, permissible values where relevant, and instruct Claude not to emit surrounding prose.

Anthropic's consistency guidance states that developers should precisely specify the desired output format when format consistency matters. More importantly, current Claude APIs provide Structured Outputs for cases requiring guaranteed JSON Schema conformance; Anthropic explicitly recommends Structured Outputs instead of prompt-only techniques when valid schema-compliant JSON is mandatory.

Therefore, D is the strongest prompt choice among the listed alternatives. In a contemporary production implementation, the design can be strengthened further by supplying the schema through Claude's structured-output configuration and performing downstream semantic validation where business rules exceed JSON Schema.

A permits arbitrary formatting. B intentionally creates inconsistent representations. C assumes post-processing can reliably reconstruct missing or ambiguously formatted information, which is significantly less robust than specifying the contract up front.

Relevant Claude Developer topics: system prompts, JSON formatting, structured outputs, schema constraints, output contracts, validation, and downstream integration reliability .

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

The supplied Claude Certified Developer Foundations question identifies D as the correct answer. Anthropic prices input and output tokens separately, so application cost models must independently account for the number of tokens supplied to Claude and the number generated in response.

Anthropic's official pricing documentation confirms that output-token pricing is normally higher than base input-token pricing. For example, current Claude models maintain distinct columns for base input tokens and output tokens; the exact dollar amounts depend on the selected model. This distinction matters because an application with relatively small prompts but very large generated responses can incur substantial output-token expenditure even when input volume is modest.

Therefore, cost forecasting should use approximately: input tokens × input rate + output tokens × output rate , with additional adjustments where prompt caching, batch processing, server tools, or other pricing modifiers apply. Option A incorrectly assumes equivalent rates, B reverses the normal relationship, and C incorrectly excludes generated tokens from billing.

Relevant Claude Developer topics: Claude API Mechanics, token accounting, model pricing, input/output token usage, cost modeling, prompt caching, and production API economics .

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

Option A correctly separates sampling configuration from context management. Temperature historically controlled the randomness of token selection; it did not increase the number of tokens Claude could accept within a request. Anthropic’s current Messages API documentation continues to describe temperature in terms of randomness and, for newer model generations, marks manual temperature control as deprecated. Therefore, changing temperature cannot solve a context-capacity problem.

Long transcripts instead require context-engineering techniques. Appropriate approaches include chunking documents, summarizing earlier material, retrieving only relevant sections, or using context editing/compaction so high-value information remains visible while unnecessary material is removed. Anthropic’s context-editing guidance explicitly supports summarization and replacement of growing conversation history to keep long-running workloads within usable context limits.

B incorrectly conflates generation parameters with context capacity. C may save some tokens but removes persistent application instructions and is therefore architecturally unsound. D modifies an unrelated parameter without addressing the root cause. Relevant Study Guide topics: context windows, token budgets, sampling parameters, summarization, chunking, and context engineering.

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

Option A is correct because the safest guardrail architecture is defense in depth, not dependence on one control. Anthropic’s guardrail guidance explicitly recommends combining multiple safeguards: input screening and validation, hardened system instructions, safe handling of untrusted tool content, least-privilege permissions, output screening, monitoring, and red-team testing. The important engineering property is independence: if one layer misses an attack or unsafe request, another layer can still prevent harmful behavior or block delivery.

Option B places control only at the output boundary. Human review can be useful for high-risk cases, but it does not protect tool execution, data access, prompt injection, or other failures that can occur before final output. Option C relies on a single system-prompt control; system instructions are probabilistic and cannot provide complete enforcement against adversarial or malformed inputs. Option D is weaker still because model-level safety alone does not enforce application-specific policies.

Therefore, A best matches Claude Developer security guidance: layer preventive, detective, and enforcement controls so there is no single guardrail whose failure exposes the application. Relevant Study Guide topics: guardrails, prompt injection, input validation, output screening, least privilege, defense in depth, and production monitoring.

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

Option A provides proper environment isolation and credential blast-radius control. Development, staging, and production represent different trust boundaries and should not share the same API credential. If a development machine, CI job, or staging service is compromised, a distinct credential prevents the attacker from automatically gaining the same access to production.

Anthropic's official workspace documentation explicitly recommends using separate workspaces for development, staging, and production. Workspaces can have their own API keys, members, resource limits, and usage tracking, and keys can be scoped to a specific workspace. Anthropic's authentication guidance also instructs developers to store API keys in a secrets manager, rotate them periodically, revoke suspected compromised keys, and use workspaces to scope credentials by project or environment.

B confuses rotation with isolation: rotating a credential that remains shared across all environments does not create independent security boundaries. C deliberately increases blast radius. D merely substitutes one globally shared key for another and therefore has the same architectural flaw.

The supplied exam source marks A as correct. Relevant topics: Confia Management, secrets management, API-key scoping, environment isolation, credential rotation, workspaces, least privilege, and production security.

Option B applies few-shot, or multishot, prompting, one of Anthropic's recommended techniques for steering Claude when examples of desired behavior are available. Labeled input/output pairs give Claude concrete demonstrations of how it should respond, which is particularly valuable when edge cases are difficult to express completely through abstract rules.

Anthropic states that examples are among the most reliable mechanisms for steering output format, tone, and structure. Its prompting guidance recommends relevant, diverse examples that cover edge cases while avoiding accidental patterns. For best results, examples should be clearly separated from the main instructions, such as by using < example > and < examples > tags.

A retrieval database could be useful if a very large or dynamically selected example collection were required, but that adds unnecessary complexity for the small labeled set described. C is disproportionate: a few examples do not justify replacing the application's Claude integration with custom model training. D avoids rather than solves the identified failure mode.

Therefore, B directly uses the available supervision at inference time and allows rapid iteration through evaluation. Relevant Claude Developer topics are prompt construction, few-shot prompting, edge-case handling, example selection, evaluation-driven iteration, and behavioral steering.

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