CCDV-F Questions and Answers

Option D treats prompts as production configuration and executable application behavior rather than informal text. A prompt modification can change output format, tool-selection behavior, policy enforcement, downstream compatibility, token usage, or model quality just as materially as an ordinary source-code change. Consequently, prompt changes need traceability, review, testing, and rollback.

A single source of truth prevents different application paths from silently using inconsistent prompt versions. Version control provides an immutable history showing who changed the prompt, what changed, and which application release used it. Pull-request review enables peer assessment and automated evaluation before deployment. The same configuration-as-code principle appears throughout Claude Code’s project configuration model, where shared project configuration is designed to live with version-controlled project artifacts.

A removes governance and creates an uncontrolled external state. B increases hidden runtime behavior and bypasses normal review. C solves fragmentation but leaves the exact governance failure described in the scenario—the ability to ship prompt changes without review.

Therefore, D provides reproducibility and controlled change management. Relevant Study Guide topics: prompt versioning, configuration management, source control, change review, reproducibility, regression testing, and rollback.

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

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 applies the correct context-engineering strategy: remove stale tool results once they no longer contribute useful information to subsequent reasoning. Agentic workflows frequently accumulate search results, file contents, API responses, and intermediate artifacts. Keeping all of them indefinitely consumes the finite context window, raises token cost, and can reduce model focus by introducing low-value information.

Anthropic specifically documents tool result clearing for this situation. Context Editing can remove older tool results when the conversation grows, while preserving recent interactions and optionally retaining tools whose results must remain available. Anthropic describes old tool outputs such as retrieved files or search results as candidates for clearing after Claude has processed them.

Prompt caching in B solves a different problem: it can lower cost and latency for repeated static prompt prefixes, but cached tokens still constitute context and therefore do not eliminate context-window pressure. C changes model capability without solving the architectural cause. D maximizes context pollution.

The correct architecture is therefore to preserve high-signal state while pruning ephemeral intermediate outputs. This aligns with Claude Developer coverage of context engineering, long-running agents, context-window management, tool-result clearing, and efficient agent state management. Anthropic's broader context-engineering guidance likewise emphasizes curating the smallest high-signal context necessary for successful inference.

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

Option C matches Anthropic's efficiency-first model-selection guidance. For a straightforward, high-volume workload where latency and unit cost are explicit constraints, the correct starting point is a faster, economical model that can meet the task's quality threshold. Anthropic specifically lists high-volume straightforward tasks, tight latency requirements, and cost-sensitive implementations as cases where an efficiency-first model choice is appropriate.

The crucial qualification is that “smaller” does not mean accepting inadequate quality. The team should evaluate the candidate against representative classification examples and defined accuracy criteria. If it passes, moving to a larger model adds cost and often latency without delivering required business value.

A selects a mid-tier model by convention rather than workload evidence. B multiplies inference calls, generally increasing both latency and cost for a simple classification problem. D optimizes maximum capability even though the task does not require frontier-level reasoning.

Therefore, C is the appropriate initial model choice, followed by workload-specific validation. Relevant Study Guide topics: Claude model selection, efficiency-first design, classification workloads, throughput, latency, per-request economics, evaluation, and quality/cost tradeoffs.

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

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 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 A is the technically verified answer. Anthropic documents that multi-turn agentic requests resend the growing conversation context on subsequent turns. Prompt caching allows repeated prompt prefixes—such as system instructions, tool definitions, and prior unchanged conversation content—to be reused at the lower cache-read rate rather than repeatedly charged as ordinary uncached input. Anthropic specifically identifies caching repeated context as a major production cost optimization.

B is incorrect even though the supplied PDF contains a duplicated screenshot in which B appears selected. The Batch API is designed for asynchronous workloads that can tolerate delayed completion; it is not the appropriate mechanism for every interactive turn in a multi-turn conversation. Because the user requested verified answers rather than blindly reproducing marked selections, A is retained.

C discards potentially essential conversation state arbitrarily. D is a valid context-management technique in some long-running workflows, but summarizing after every turn creates additional model work and loses detail; it does not exploit repeated-prefix caching.

Therefore, A directly addresses the stated cost pattern while preserving conversation fidelity. Relevant Study Guide topics: Messages API, stateless conversation history, prompt caching, cached input tokens, multi-turn applications, token economics, and cost optimization.

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

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

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.

C addresses the failures at the correct architectural layer: orchestration and supervision . The supplied exam item identifies C as correct. The primary agent is responsible not merely for forwarding subordinate output but for governing delegation, resource usage, stage boundaries, and result quality.

Anthropic's current guidance recommends explicit control over subagent use because excessive delegation multiplies latency and cost. Its documentation specifically supports deterministic limits on subagent spawning and SDK budget controls such as max_budget_usd. Tool contracts can also use defined input schemas and strict validation so malformed data cannot silently propagate between processing stages.

Explicit handoff contracts are equally important. Retrieval should provide an agreed structure to analysis; analysis should provide validated findings to report generation; and the manager should reject, retry, reconcile, or escalate outputs that violate those contracts.

A improves observability but mainly detects problems after they occur. B destroys context isolation and can create additional coupling. D abandons useful specialization instead of correcting deficient supervision.

Relevant Claude Developer topics: Agent Patterns, orchestrator/subagent architecture, delegation, budgets, handoff contracts, schema validation, output reconciliation, and multi-agent governance .

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

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.

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

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 .

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

The architecture is a manager/supervisor—or orchestrator/subagent—pattern with isolated subagent context. The defining characteristics are a coordinating top-level agent, specialized subordinate agents, delegated responsibilities, and distinct tool/context boundaries. The supervisor determines which specialist should act, sequences work where necessary, and integrates the specialists' outputs into the final result.

Anthropic's published multi-agent research architecture uses this same structural principle. Its Research system employs an orchestrator-worker pattern in which a lead agent analyzes the task, creates specialized subagents, delegates separate research responsibilities, and consolidates their findings. Anthropic emphasizes that good delegation requires each subagent to receive a specific objective, task boundaries, expected output, and appropriate tools.

The question additionally specifies that each travel specialist has its own conversation history and tool list. That eliminates B because context is explicitly not shared globally. C would involve fixed sequential processing rather than supervisor-directed specialization. D describes retrieval augmentation, not autonomous subordinate agents.

Therefore, A precisely matches both the hierarchy and context-isolation characteristics described.

The supplied examination set also marks A as the intended answer. Relevant topics: Agent Patterns, manager/supervisor architecture, orchestrator-worker systems, subagents, delegation, specialized tools, and context isolation.

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

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.

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

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 .

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

A is the correct lifecycle architecture. The supplied Claude Certified Developer Foundations item explicitly selects A . A session is a state boundary, so its lifecycle must define when accumulated conversation state remains valid and when that state must be discarded. Anthropic's Managed Agents documentation establishes that a session maintains conversation history across multiple interactions and provides explicit session operations including creation, update, archive, and deletion.

A therefore addresses all three required controls: expiration , reset , and fresh-session creation . Expiration prevents indefinitely retained conversational state. Reset triggers allow the application to clear state when events such as logout, workflow completion, tenant switching, or explicit user reset occur. Fresh-session rules prevent context belonging to an earlier task from influencing a logically unrelated conversation.

B relies exclusively on timeout and does not cover event-driven resets. C places lifecycle correctness on users instead of the application. D applies global reset behavior and omits independent per-session expiration semantics.

Relevant Claude Developer topics: Agent Architecture, session lifecycle, multi-turn state, context boundaries, state reset, stale-context prevention, and session management .

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

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.

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

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.

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

The supplied Claude Developer source explicitly marks A . The scenario contains the defining elements of an orchestrator/subagent architecture : decomposition of a larger objective, delegation of independent subtasks to specialized workers, and aggregation of their outputs by a coordinating agent.

This architecture is appropriate when subtasks can be performed with focused context or specialized tools. Instead of forcing one agent to carry every intermediate detail, the orchestrator can formulate assignments, launch suitable subagents, receive condensed results, identify missing information, and synthesize the final research product. This also enables context isolation and potentially parallel execution.

Anthropic's published multi-agent architecture uses this orchestrator-worker approach for research workloads: a lead agent decomposes a query, delegates work to specialized subagents, and then integrates their findings. This is particularly useful where exploration is broad and individual subtasks benefit from independent context windows. The broader model-selection guidance also identifies orchestrator strategies as useful where work can be partitioned among worker models.

B describes storage rather than delegation. C is a context-management technique, not a decomposition pattern. D centralizes all responsibilities in a single loop.

Relevant Claude Developer topics: Agent Patterns, orchestration, subagents, task decomposition, specialization, delegation, context isolation, and result consolidation .

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

The supplied Claude Developer question explicitly identifies D . The two mechanisms solve different extension problems. A Skill is a reusable package of domain expertise and workflow guidance. Anthropic describes Agent Skills as modular, filesystem-based capabilities containing instructions, metadata, and optional supporting resources such as scripts and templates, which Claude can load when relevant.

MCP, by contrast, defines a standardized mechanism for exposing external capabilities and context. Anthropic's MCP integration supports MCP tools and, through client-side helpers, MCP prompts and resources. This makes MCP appropriate when Claude must communicate with an external server or reusable service interface rather than simply load packaged expertise.

Thus, Skills are appropriate for packaging repeatable instructions, procedures, scripts, templates, or domain knowledge. MCP servers are appropriate for exposing callable operations, external data resources, and shared service capabilities using the Model Context Protocol.

A incorrectly treats them as interchangeable. B incorrectly describes the difference as merely generational. C invents a universal efficiency advantage that is not the architectural distinction.

Relevant Claude Developer topics: Agent Construction, Agent Skills, MCP, reusable capabilities, resources, prompts, tools, extension architecture, and cross-team component reuse .

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

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

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