Free Practice Questions for Anthropic CCDV-F Exam

Option C is correct. Claude Code uses CLAUDE.md as the standard mechanism for supplying persistent project-level instructions and context. Anthropic's Claude Code documentation states that project instructions can be stored in ./CLAUDE.md or ./.claude/CLAUDE.md and shared with team members through source control. Appropriate content includes coding standards, architectural decisions, project conventions, build/test commands, preferred workflows, and information developers would otherwise need to repeat to Claude during every session. The /init command can also generate an initial CLAUDE.md based on the repository.

A wiki may be valuable for human documentation, but Claude Code does not automatically receive that material as project context. B creates developer-specific configuration and risks inconsistency across the team. D places the information in a human-facing README but does not use Claude Code's purpose-built persistent instruction mechanism.

Therefore, C gives the repository a shared, version-controlled source of Claude-specific project guidance. Relevant Study Guide topics: CLAUDE.md, project configuration, persistent instructions, repository context, team standards, and configuration management.

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

The supplied exam source marks B as correct. The first debugging action should be evidence collection rather than immediately modifying prompts or configuration. A trace exposes the complete conditions under which the refusal occurred: user input, system instructions, accumulated conversation state, tool results, parameters, and resulting model output.

This is important because a refusal can originate from several interacting causes. A particular input pattern may trigger it; system instructions may unintentionally conflict with the requested task; prior conversational context may alter Claude's interpretation; or contextual information may make an otherwise acceptable request appear out of scope. Without examining the failing execution path, changing instructions is speculative.

Option A jumps directly to remediation before identifying the cause. C provides useful aggregate analysis but is more appropriate after individual failing executions have been inspected. D is also valuable for comparative debugging, but determining what changed requires the detailed execution data that traces provide.

The correct troubleshooting sequence is therefore: capture or inspect representative failed traces, determine the trigger, compare against successful interactions, formulate a hypothesis, make a targeted change, and re-evaluate.

Relevant Claude Developer topics: Systems Life Cycle, observability, production debugging, tracing, failure analysis, refusals, regression investigation, and evaluation-driven remediation .

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

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.

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

Option B is the correct fault-tolerance pattern for a long-running stateful workflow. A checkpoint captures enough durable execution state—completed steps, intermediate results, pending work, identifiers, and other necessary task state—to restart from a known consistent point rather than replaying the entire workflow after interruption.

This pattern is consistent with Claude's current stateful agent architecture. Anthropic's Managed Agents documentation describes persistent sessions that preserve conversation history across interactions. When a session becomes idle, its sandbox can be checkpointed so filesystem and execution artifacts are available when work resumes. The certification concept is broader than that specific hosted implementation: long-running agent systems should externalize recoverable state at meaningful boundaries.

A longer timeout does not protect against process crashes, infrastructure restarts, network failures, or deployment interruptions. C doubles resource consumption and creates consistency problems without providing deterministic recovery. D wastes completed work and may repeat external side effects.

Therefore, B provides controlled resumability and minimizes repeated processing. Relevant Study Guide topics: checkpointing, persistent state, resumable workflows, long-running agents, fault tolerance, idempotency, and recovery architecture.

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

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 .

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

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 D precisely matches Anthropic's SDK behavior. Official SDK documentation states that transient conditions are automatically retried two times by default with exponential backoff. The default retry set includes connection failures, HTTP 408 Request Timeout, 409 Conflict, 429 Rate Limit, and 5xx server errors. Developers can alter or disable this behavior through the SDK's retry configuration.

This directly eliminates A because the retry count is configurable. B is incorrect because rate-limit responses are among the conditions automatically retried by the supported SDKs; the API also provides retry-after information where applicable. C is incorrect because the SDK does not merely log these failures and continue without attempting recovery.

Application-level handling is still necessary after the configured retry policy is exhausted. Production code should distinguish permanent errors from transient failures, preserve request IDs for diagnostics, and decide whether higher-level fallback, queuing, or user-visible failure handling is appropriate.

Therefore, D correctly characterizes the SDK abstraction: useful retry defaults combined with developer control. Relevant Study Guide topics: Claude SDKs, transient errors, HTTP 429, retries, exponential backoff, configuration, and resilient 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 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.

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