Free Anthropic Claude Certified Developer - Foundations CCDV-F Exam Questions

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 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 A is correct because a model upgrade should be treated as a controlled application change, not a simple identifier substitution. Anthropic's evaluation guidance recommends defining measurable success criteria and running task-specific evaluations that mirror real production behavior, including edge cases. Its model-migration guidance likewise recommends testing replacement models before moving production workloads.

Here, the new model improves the highest-volume task but changes output formatting on structured-extraction prompts. That means the migration has both a quality benefit and a compatibility risk. The correct response is to tighten the output contract, re-run evaluations against the parsing/schema boundary, then deploy progressively with a feature flag and a per-workflow rollback path. This limits blast radius and preserves a known-good recovery option.

Option B pushes an unverified behavior change directly into production. Option C makes downstream parsing permissive, which can conceal schema drift instead of enforcing a stable contract. Option D permanently preserves a fragile implementation and discards the measured quality improvement.

Taking the model version stated in the question as the scenario, A is the correct lifecycle strategy. Relevant Study Guide topics: model migration, regression evaluation, structured output, compatibility testing, progressive rollout, rollback, and production change management.

Option B establishes a layered testing strategy rather than relying on a single testing granularity. Unit tests validate deterministic functions and isolated components quickly. Integration tests verify boundaries between application code and Claude-related components such as API clients, tool execution, parsing, persistence, and error handling. End-to-end tests then validate the most important user workflows across the complete application stack.

This separation is particularly useful for Claude applications because deterministic software failures and probabilistic model-quality failures should not be treated identically. Anthropic's evaluation guidance recommends defining specific, measurable success criteria and constructing representative test cases to determine whether model behavior meets those criteria. These evaluations complement conventional software tests rather than replacing them.

A focuses exclusively on test-driven development; TDD can be valuable but does not define all required test levels. C preserves the existing ad-hoc methodology rather than establishing a repeatable quality strategy. D overuses expensive and slower end-to-end tests while omitting the faster diagnostic value of unit and integration tests.

The supplied exam source marks B as correct. Relevant topics: SW Eng Foundations, test strategy, unit testing, integration testing, end-to-end testing, Claude evaluations, regression coverage, and production reliability.

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.

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

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

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

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

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

Option A correctly treats the MCP server as a reusable integration boundary rather than application-specific code. Model Context Protocol separates capability providers from consuming Claude applications by exposing standardized tools, resources, and prompts through an MCP-compatible interface. A shared server therefore needs explicit capability definitions, an appropriate transport or communication pattern, and a deployment location reachable by its intended clients.

Anthropic's MCP documentation distinguishes remote HTTP-based integrations from local/client-managed connections. For remotely shared services, the server must be reachable from the consuming environment; client-side MCP helpers additionally support broader MCP capabilities such as resources and prompts.

B unnecessarily couples the server design to the first consumer and encourages application-specific evolution of what should be a reusable service boundary. C prevents multi-application deployment because only local developer sessions could reach the service. D abandons MCP entirely and recreates duplicated integrations in every consuming application.

Thus, A provides the correct lifecycle: define the MCP contract, expose resources/tools/prompts appropriately, select the transport according to topology, deploy the service, and let multiple applications consume the standardized interface independently. Relevant Study Guide topics: MCP architecture, reusable services, tools, resources, prompts, transports, and deployment topology.

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

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

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

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.

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.