CCDV-F Claude Certified Developer-Foundations Questions and Answers

Option C correctly identifies threat categories introduced or significantly amplified by LLM-based application architecture. Prompt injection attempts to manipulate Claude into following adversarial instructions. Jailbreaks seek to circumvent behavioral or application safeguards. Data leakage can expose confidential information contained in system prompts, retrieved context, tool results, or conversation state. Unsafe model output becomes particularly serious when output is consumed by downstream systems or translated into tool actions.

Anthropic's official guardrail documentation explicitly distinguishes jailbreaks and direct prompt injection from indirect prompt injection. It recommends input screening, hardened system prompts, structured handling of untrusted tool content, least-privilege access, output screening, and continuous monitoring. Anthropic also warns that sensitive prompt/context data can leak and recommends post-processing and output filtering where required.

Traditional threats such as SQL injection or XSS remain relevant to the surrounding application, but they are not the additional AI-specific categories requested. B similarly describes conventional infrastructure threats. D is far too narrow because the SDK is only one component of the attack surface.

The supplied exam source explicitly marks C. Relevant topics: Claude App Design, threat modeling, prompt injection, jailbreaks, data leakage, output safety, least privilege, and defense in depth.

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

The supplied question marks C , and Anthropic's API documentation directly supports it. Claude API rate limits are enforced using dimensions such as requests per minute (RPM), input tokens per minute (ITPM), and output tokens per minute (OTPM) . Anthropic also notes that short traffic bursts can exceed effective limits even when a longer-term average appears acceptable.

Applications should therefore determine the organization's actual configured limits, model peak traffic against those boundaries, throttle or queue work as necessary, and handle 429 responses correctly. Rate-limit responses include a retry-after value indicating when another request should be attempted. Anthropic's official SDKs automatically retry transient connection failures, rate-limit errors, and server errors with exponential backoff by default.

Streaming does not exempt requests from rate limits, making A technically incorrect. Consolidating payloads in B may reduce request count but could increase token consumption and does not by itself address all rate-limit dimensions. D may smooth traffic, but it is only one optimization and does not substitute for rate-limit-aware application logic.

Relevant Claude Developer topics: Claude API Mechanics, rate limits, RPM, ITPM, OTPM, HTTP 429, retry-after, exponential backoff, throttling, and capacity planning .

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

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.

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 B establishes the correct trust boundary. Fluent or confident language is not evidence that a generated claim is factually correct. If downstream systems treat output as authoritative data, the application must independently establish whether the output meets its correctness requirements before accepting it.

Validation can take several forms depending on the workload: compare generated facts against authoritative records, require citations or source references, constrain output to retrieved evidence, apply deterministic business rules, or use separate evaluation/classification stages. Anthropic's agent engineering guidance repeatedly emphasizes explicit evaluation criteria and validation rather than relying on apparent confidence.

A confuses sampling behavior with factual reliability. Lowering temperature does not establish factual correctness and may only make an incorrect answer more repeatable. C supplies maximum oversight but is unnecessarily expensive and removes useful automation even for low-risk, easily validated cases. D communicates uncertainty to users but does not protect downstream systems that automatically consume the response.

Therefore, B treats model output as untrusted until verified to the level required by the application. Relevant Study Guide topics: output validation, grounding, factuality, confidence calibration, source verification, trust boundaries, and downstream safety.

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

The correct response is iterative prompt improvement backed by evaluation , making A the appropriate choice. The supplied Claude Certified Developer Foundations material explicitly selects A. When production input distribution changes, a prompt that previously met requirements can become inadequate. The correct engineering response is not to preserve the prompt merely because it once worked; prompts are application components that should evolve with observed workload behavior.

Anthropic's official evaluation guidance describes prompt development as a cycle involving test cases, an initial prompt, iterative testing and refinement, final validation, and deployment. Success criteria should be specific and measurable, and evaluations should include representative cases that expose known failure modes.

The underperforming category should therefore be incorporated into the evaluation set. The team can modify instructions, examples, context organization, or other prompt components, then compare the revised prompt against both the newly important category and existing common cases. This prevents improvement in one segment from silently producing regressions elsewhere.

B avoids the defect instead of correcting it. C risks degrading previously successful behavior. D creates unnecessary architectural fragmentation.

Relevant Claude Developer topics: prompt iteration, evaluation-driven development, regression testing, representative test sets, prompt optimization, and production feedback loops .

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

Option C matches Claude Code’s documented Skill architecture. Agent Skills are filesystem-based extension artifacts rather than ordinary application modules or repeated prompt fragments. A Skill is represented by a directory containing a required SKILL.md file and can include optional supporting scripts, templates, examples, and reference material.

Anthropic documents project Skills under .claude/skills/ < skill-name > /SKILL.md. Project-level Skills can be shared through Git and automatically discovered when Claude Code loads project settings. Supporting scripts can reside alongside the Skill and be referenced from SKILL.md.

A incorrectly embeds reusable procedural material into every CLAUDE.md file, creating duplication and loading instructions even when they are irrelevant. B creates a conventional source-code library but does not register a Claude Code Skill. D makes the capability dependent on undocumented, developer-specific setup and undermines team reuse.

Therefore, C uses the extension mechanism specifically designed for discoverable, reusable Claude capabilities. Relevant Study Guide topics: Agent Skills, .claude/skills, SKILL.md, supporting resources, filesystem discovery, project-level configuration, and reusable Claude Code capabilities.

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

Option A follows disciplined production debugging: diagnose the actual failure mode before changing architecture or prompts. An output containing unsupported information might indeed be hallucination, but similar symptoms can result from stale conversation state, incorrect retrieval, unexpected tool output, prompt injection, incorrect request construction, or mismatched model/configuration versions.

A production trace should capture the user input, system instructions, relevant conversation history, retrieved content, tool calls and results, model/version, request parameters, response, and identifiers necessary to compare successful and failing cases. This establishes whether the model invented a fact or whether that fact entered context through another path.

B changes the model before establishing causality. C may eventually be useful if the confirmed problem is insufficient grounding, but implementing RAG before diagnosis can hide rather than explain the defect. D similarly changes prompting before verifying that prompt behavior is responsible.

The engineering sequence should be observe, reproduce, classify the failure, form a hypothesis, apply a targeted correction, and validate the correction with evaluations. Relevant Study Guide topics: production troubleshooting, observability, tracing, hallucination analysis, prompt injection, context failures, regression diagnosis, and lifecycle monitoring.

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

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

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.

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

Option A is correct because model selection requires measurable non-functional requirements, not an undefined objective such as “best.” Anthropic's model-selection guidance explicitly frames the decision around capabilities, speed, and cost and recommends identifying those requirements before narrowing the candidate models.

“Quality” must also be translated into task-specific success criteria—for example classification accuracy, extraction correctness, acceptable false-positive rate, or human preference. Latency may be constrained by an interactive SLA, and cost may be defined per request, per user, or per completed task. Once those thresholds exist, representative evaluations can compare candidate models using the actual prompts and data.

B uses a generic benchmark that may not correlate with the application's workload. C chooses a model tier without requirements or evidence. D optimizes only for raw capability and ignores latency and cost, potentially producing an unnecessarily expensive architecture.

Thus, requirements definition precedes technology selection. Relevant Study Guide topics: Understanding Reqs, functional versus non-functional requirements, quality thresholds, latency budgets, cost constraints, acceptance criteria, workload-specific evaluation, and model-selection tradeoffs.

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

Option A is the appropriate trust-boundary treatment for external content. Untrusted text can contain malformed data, adversarial instructions, prompt-injection attempts, or content deliberately constructed to alter the agent's behavior. It should therefore be validated or screened before inclusion and clearly represented as untrusted data rather than authoritative application instructions.

Anthropic's prompt-injection guidance distinguishes direct attacks from indirect prompt injection, where Claude processes third-party content such as webpages, emails, documents, or tool output containing hostile instructions. Anthropic recommends input validation and screening, least-privilege access, safe treatment of untrusted tool content, and screening content before Claude acts on it. Importantly, Anthropic notes that tool-result content is treated as untrusted data rather than as a reliable place for application instructions.

B erases the trust distinction and exposes the application to instruction/data confusion. C introduces a deliberately weaker security boundary and does not sanitize the data. D prevents legitimate use cases unnecessarily; untrusted does not mean unusable—it means the data must be handled defensively.

Therefore, A correctly combines validation with explicit trust separation. Relevant Study Guide topics: prompt injection, untrusted content, input validation, sanitization, data/instruction separation, least privilege, and defense in depth.

Option D applies a fundamental production engineering principle: treat externally generated data as potentially malformed and parse it defensively before use. Downstream application logic should not assume that every field exists, every type is correct, or every unexpected property can safely be ignored. Instead, the parser should validate expected structures, handle optional or missing values deliberately, reject incompatible types, and convert failures into controlled application errors rather than process crashes.

Anthropic's Structured Outputs documentation identifies exactly these failure classes for unconstrained model output: malformed JSON, missing required fields, inconsistent types, and schema violations can break downstream applications. Current Structured Outputs and strict tool-use capabilities can eliminate many schema-level failures through constrained decoding, but defensive handling remains an important software boundary when unexpected data can still arise from external services, legacy paths, or semantic validation requirements.

A creates unnecessary outages. B hides failures and discards potentially recoverable data without observability. C deliberately postpones a reliability requirement until after deployment.

The supplied question identifies D as correct. Relevant topics: Claude App Design, defensive programming, structured output, schema validation, parsing, error handling, downstream reliability, and type safety.

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

B is correct because the architecture cannot be chosen intelligently until the team defines which quality attribute is more important to the actual business use case . The examination source explicitly selects B. Whole-document and chunked processing each perform better on different dimensions, so there is no universally superior option.

Anthropic's evaluation guidance emphasizes defining concrete success criteria first and validating candidate approaches against representative examples. The correct sequence is therefore to determine whether cross-section reasoning or citation precision is the more critical requirement, establish measurable acceptance thresholds, and evaluate both strategies on representative legal contracts.

Anthropic's legal summarization guidance also confirms that chunking or meta-summarization is useful for long documents, while acknowledging that processing an entire document can be appropriate when it fits within Claude's context window. For citations specifically, Anthropic provides native citation support that chunks document text into citation-addressable units and improves source-grounded citation behavior.

A and C each privilege one quality dimension before establishing business priority. D focuses on cost and latency even though the unresolved problem is quality tradeoff.

Relevant Claude Developer topics: Understanding Reqs, success criteria, requirement prioritization, long-context processing, chunking, citation accuracy, cross-document reasoning, representative evaluations, and architecture tradeoffs .

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 .

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

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

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

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 satisfies both the enterprise routing requirement and sound application architecture. Claude is available through Amazon Bedrock, and Anthropic provides Bedrock-specific SDK integration rather than requiring applications to call api.anthropic.com directly. Current Anthropic documentation describes Claude in Amazon Bedrock as operating through AWS-managed infrastructure with AWS-native authentication, billing, and security boundaries. Newer Bedrock integrations use the Messages API shape, allowing substantial application logic to remain consistent across provider environments.

Anthropic SDKs also provide dedicated Bedrock clients—for example, Python includes AnthropicBedrockMantle for current Bedrock deployments. Keeping business logic separated from provider-specific authentication, endpoints, model identifiers, and transport configuration reduces migration and maintenance risk.

A violates architectural simplicity by duplicating every call unnecessarily. B knowingly violates the enterprise requirement until migration occurs. D directly ignores the contractual routing constraint and is therefore invalid regardless of technical feasibility.

The correct approach is to make Bedrock the configured inference provider while keeping higher-level application and agent behavior decoupled from provider-specific implementation details. Relevant Claude Developer topics are Claude API mechanics, cloud-provider integrations, Amazon Bedrock, SDK configuration, authentication boundaries, model invocation, and provider abstraction.

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

Option A correctly applies selective enforcement. Claude Code hooks can execute automatically at lifecycle events such as PreToolUse, and matchers or conditions can narrow exactly which operations trigger a hook. Anthropic’s hook reference demonstrates this pattern by applying a PreToolUse hook specifically to destructive shell operations rather than indiscriminately processing every command. The documentation notes that if the matcher or conditional expression does not match, the handler is skipped, avoiding unnecessary process-spawn overhead.

That architecture is particularly appropriate for costly or security-sensitive checks. High-risk events—destructive file operations, privileged commands, production changes, or access to sensitive resources—can receive deterministic pre-execution enforcement while routine low-risk actions proceed without additional hook latency.

B creates an avoidable period in which safeguards disappear entirely. C reduces application availability without addressing the actual source of overhead. D is technically weaker because system-prompt instructions influence model behavior but are not equivalent to deterministic lifecycle interception capable of blocking execution.

Therefore, hooks should be scoped using event types, matchers, and conditions according to risk. Relevant Claude Developer topics are Claude Code hooks, agent construction, tool governance, deterministic controls, permission boundaries, safety/performance tradeoffs, and lifecycle interception.

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

Option B is correct because the official Anthropic Python SDK is the supported abstraction for calling the Claude REST API from Python. Anthropic documents both synchronous and asynchronous clients, standardized request/response objects, streaming support, error classes, timeouts, request IDs, and built-in retry behavior for common transient failures. Using those documented primitives reduces boilerplate and keeps integration behavior aligned with the API.

Option A is technically possible, but it unnecessarily reimplements authentication headers, serialization, error mapping, retries, timeouts, and response handling that the SDK already provides. Direct HTTP is appropriate only when there is a specific reason not to use the supported client. Option C introduces another provider’s abstraction and a translation layer that is unrelated to the stated requirement and increases compatibility risk. Option D invokes shell commands from Python, creating needless process-management, security, and error-handling complexity.

The correct engineering principle is to use the highest-level supported client that satisfies the application’s requirements while retaining access to lower-level HTTP controls when genuinely needed. Therefore, B is the appropriate Claude integration pattern. Relevant Study Guide topics: Python SDK, REST abstraction, authentication, retries, exceptions, response parsing, synchronous/asynchronous clients, and maintainable API integration.

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

Option B is the correct automation pattern. A CI pipeline must operate non-interactively, so Claude Code should be invoked in its programmatic/headless execution mode and given only the permissions required for the predefined workflow. Output can then be captured by the pipeline and supplied to subsequent build, testing, reporting, or deployment stages.

Claude Code's configuration system supports explicit permission rules in JSON settings. Anthropic documents that settings.json controls, among other behavior, what Claude Code can execute without asking. For example, permissions.allow can authorize specific commands while permissions.deny prevents sensitive operations. Project-level .claude/settings.json can be version-controlled so CI behavior is reproducible across runners.

This is substantially safer than C, which disables confirmation behavior globally and expands the blast radius beyond the CI workload. D defeats automation because a human must remain present. A is unnecessary because Claude Code is explicitly configurable for automation scenarios.

The principle is least-privilege non-interactive configuration: authorize only the commands and resources required by the pipeline and capture machine-readable output for downstream processing. Relevant Claude Developer topics are Claude Code automation, configuration management, permissions, CI/CD integration, headless execution, and reproducible project settings.

Option D is the strongest enforcement design because an unconditional content policy requires an application-level control between model generation and user delivery. Prompt instructions are valuable for steering Claude, but they are probabilistic controls and should not be treated as the sole enforcement mechanism when prohibited categories must never be exposed.

Anthropic’s guardrail guidance recommends layered safeguards including screening, validation, monitoring, and filtering rather than relying exclusively on prompts. Its prompt-leak guidance specifically recommends output screening and post-processing, including deterministic techniques such as keyword matching, regular expressions, or other text-processing mechanisms where appropriate.

A improves the probability of policy compliance but cannot guarantee that every generated response will satisfy an externally defined application policy. B explicitly abandons the requirement. C detects violations only after exposure, which is unsuitable when the content must not reach users.

A production architecture can combine system instructions, structured classification, policy engines, deterministic rules, and model-based moderation, but the decisive requirement is enforcement before output delivery. Relevant Claude Developer topics are guardrails, output filtering, content moderation, deterministic enforcement, defense in depth, safe application boundaries, and production 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.

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