Anthropic CCDV-F (Claude Certified Developer - Foundations) Practice Test 9

Question 80

A support bot must quote the latest policy instead of relying on older snippets in a conversation. How should the implementation handle this need?

  1. Identify external integration contracts
  2. Specify human-in-the-loop responsibilities
  3. Document data-handling and retention constraints
  4. Identify the upstream source of truth

Explanation

Correct Answer

D:

Architecture requirements name the maintained policy repository and its freshness constraints; in production, instructing Claude to remember policy text does not keep that source current.

Incorrect Answers

A:

Interface requirements document endpoints, authentication, payloads, limits, and failure handling; this addresses a separate concern, not the fact that architecture requirements name the maintained policy repository and its freshness constraints; a prose-level prompt is not a substitute for a validated service contract.

B:

Requirements distinguish permitted recommendations from authority to execute a binding business commitment; here, the controlling capability is that architecture requirements name the maintained policy repository and its freshness constraints, but a general claim that the assistant is safe does not enforce this distinction.

C:

Privacy requirements identify permitted collection, transmission, storage, retention, and deletion controls; the missing capability is more specific: architecture requirements name the maintained policy repository and its freshness constraints; developer convenience cannot override legal or organizational handling obligations.

Question 81

An assistant may recommend deleting archived customer records but must await a human decision before deletion. Which action most directly closes the gap?

  1. Apply a per-run timeout
  2. Persist failure checkpoints for resumability
  3. Configure an allowlist of available tools
  4. Require explicit approval for irreversible actions

Explanation

Correct Answer

D:

The side-effect layer blocks execution until an authorization token or confirmation arrives; notably, labeling a step dangerous in the prompt does not implement authorization.

Incorrect Answers

A:

The host checks elapsed time and cancels or stops further tool iterations at the limit, whereas the requirement calls for another behavior: the side-effect layer blocks execution until an authorization token or confirmation arrives; increasing token capacity does not impose a real execution deadline.

B:

Checkpoint records allow a restart to continue without re-running completed side effects; however, the critical mechanism here is that the side-effect layer blocks execution until an authorization token or confirmation arrives, and replaying the whole conversation may duplicate irreversible changes without idempotency controls.

C:

Its registered and authorized tool set excludes mutating functions before Claude can request them; the requirement instead turns on this behavior: the side-effect layer blocks execution until an authorization token or confirmation arrives; an instruction not to delete data is insufficient if destructive tools remain callable.

Question 82

Claude needs a company's private CRM lookup that only the application's network can reach. Which approach targets the deciding condition?

  1. Validate and execute the tool outside the model
  2. Use a client-executed custom tool
  3. Use an MCP-provided tool through a configured client
  4. Use an Anthropic server-executed tool where supported

Explanation

Correct Answer

B:

The API returns a tool_use request and the application performs the authorized operation itself; the important constraint is that tool declarations do not grant the vendor access to private infrastructure.

Incorrect Answers

A:

Application code enforces permission checks and performs the actual side effect or read, whereas the requirement calls for another behavior: the API returns a tool_use request and the application performs the authorized operation itself; the presence of tool_use content is not evidence the backend was queried.

C:

The MCP client discovers the server's tools and invokes permitted operations through a standardized protocol; the requirement instead turns on this behavior: the API returns a tool_use request and the application performs the authorized operation itself; MCP transport does not replace authentication or authorization of the business system.

D:

Server tools execute on the service side and return associated results during the model interaction; this cannot substitute for the behavior that the API returns a tool_use request and the application performs the authorized operation itself, because they have distinct data and capability boundaries from the customer's custom functions.

Question 83

An incoming message only needs a low-cost intent label before dispatch to a fixed downstream workflow. Which approach best meets this requirement?

  1. Use a fast tier for request classification
  2. Use a specialized deterministic tool instead of any model
  3. Update cost and context assumptions
  4. Use a staged escalation strategy

Explanation

Correct Answer

A:

A small capable classifier avoids spending top-tier reasoning cost on simple routing; a crucial qualification is that poor routing accuracy can still misdirect expensive follow-up steps.

Incorrect Answers

B:

Trusted software calculates deterministic numeric results independently of language-model tier; by comparison, the intended solution relies on this: a small capable classifier avoids spending top-tier reasoning cost on simple routing; upgrading to a larger model does not supply an arithmetic correctness guarantee.

C:

Recalculating budgets avoids relying on stale token or feature assumptions; the needed capability is different—a small capable classifier avoids spending top-tier reasoning cost on simple routing—and product names alone do not prove pricing or capacity parity.

D:

An escalation policy retries only the genuinely hard or failed cases on a higher-capability tier, whereas the requirement calls for another behavior: a small capable classifier avoids spending top-tier reasoning cost on simple routing; escalation thresholds must be evaluated to avoid excessive retries.

Question 84

An existing summarizer is being replaced and leadership wants measurable improvement. Which measure directly addresses the problem?

  1. Benchmark baseline latency and cost
  2. Prototype with a representative evaluation set
  3. Implement a narrow vertical slice
  4. Optimize for correctness before model speed

Explanation

Correct Answer

A:

Capturing tokens, response times, failure rate, and quality before changes makes comparisons meaningful, subject to this requirement: subjective demos cannot quantify a regression from the original system.

Incorrect Answers

B:

A focused spike with real representative examples exposes feasibility and failure modes early; here, the controlling capability is that capturing tokens, response times, failure rate, and quality before changes makes comparisons meaningful, but a polished front end does not demonstrate model accuracy on difficult inputs.

C:

A small end-to-end slice tests integration boundaries and production assumptions together; the missing capability is more specific: capturing tokens, response times, failure rate, and quality before changes makes comparisons meaningful; building many disconnected components first delays discovery of interface mismatches.

D:

The acceptance process emphasizes measured quality and human review before pursuing latency reductions; by comparison, the intended solution relies on this: capturing tokens, response times, failure rate, and quality before changes makes comparisons meaningful; a fast answer is not suitable if it violates the required error threshold.

Question 85

The same tool is consumed by several applications and its request format is changing. Which option best fits the described workflow?

  1. Mock model responses for deterministic unit tests
  2. Commit prompt templates as versioned files
  3. Use a sandbox backend for tool integration tests
  4. Run contract tests against a versioned API schema

Explanation

Correct Answer

D:

Contract tests enforce agreed field names, types, and error shapes across producer and client, subject to this requirement: casual manual testing may miss a breaking field change.

Incorrect Answers

A:

A mock response supplies controlled payloads so application logic can be tested repeatably; the requirement instead turns on this behavior: contract tests enforce agreed field names, types, and error shapes across producer and client; it does not prove a real model will produce the same semantic output.

B:

Version control makes prompt changes auditable alongside application code and tests; this cannot substitute for the behavior that contract tests enforce agreed field names, types, and error shapes across producer and client, because storing production prompts only in an engineer's notebook prevents reproducibility.

C:

A nonproduction environment exercises authorization, payload mapping, and failures safely; in contrast, contract tests enforce agreed field names, types, and error shapes across producer and client, while faking every backend call can hide actual integration incompatibilities.

Question 86

A template includes untrusted record IDs and long free-form fields from another service. What is the appropriate next design choice?

  1. Treat attacker content as quoted data only
  2. Test prompt examples for representativeness
  3. Validate prompt variables before interpolation
  4. Separate policy from editable templates

Explanation

Correct Answer

C:

Input checks constrain length, types, and permitted resource scopes before prompt assembly; its operational boundary is that merely surrounding an unsafe value with quotation marks does not establish authorization.

Incorrect Answers

A:

The application preserves the page as untrusted input and excludes it from control instructions; the requirement instead turns on this behavior: input checks constrain length, types, and permitted resource scopes before prompt assembly; a malicious instruction can still be persuasive, so execution permissions remain bounded.

B:

Broader cases reveal where examples bias the model toward a narrow pattern; this cannot substitute for the behavior that input checks constrain length, types, and permitted resource scopes before prompt assembly, because more examples do not automatically fix poor dataset coverage.

D:

The application holds non-negotiable policies in protected configuration independent of user-edited prose; this addresses a separate concern, not the fact that input checks constrain length, types, and permitted resource scopes before prompt assembly; allowing end users to rewrite enforcement instructions weakens trust boundaries.

Question 87

One machine needs environment-specific permissions that other contributors must not inherit. How should this requirement be met?

  1. Use user-level guidance for personal defaults
  2. Use organization-managed policy for enforced restrictions
  3. Use local settings for workstation-only behavior
  4. Check effective settings across scopes

Explanation

Correct Answer

C:

Local configuration can hold machine-specific client preferences outside shared version control; the important constraint is that committing private machine policy could surprise teammates.

Incorrect Answers

A:

Personal configuration scopes recurring individual preferences independently of shared project rules; the needed capability is different—local configuration can hold machine-specific client preferences outside shared version control—and private defaults should not override necessary repository safety requirements.

B:

Managed settings supply centrally governed guardrails rather than relying on voluntary user configuration, whereas the requirement calls for another behavior: local configuration can hold machine-specific client preferences outside shared version control; ordinary project instructions are not equivalent to an enforced corporate security policy.

D:

Resolving effective configuration reveals higher-priority policy and machine-specific overrides; the requirement instead turns on this behavior: local configuration can hold machine-specific client preferences outside shared version control; reading only one settings file can miss the operative restriction.

Question 88

Previously reliable instructions produce subtly different extraction fields on a newer model. What is the most suitable pattern?

  1. Refresh prompt evaluations after upgrade
  2. Run a canary rollout for a new model version
  3. Recheck behavior after version migration
  4. Revalidate tool schemas and outcomes

Explanation

Correct Answer

A:

Re-running the fixed evaluation set detects behavior shifts requiring prompt adjustment; copying old pass rates forward would misstate new performance.

Incorrect Answers

B:

Limited exposure allows observation of quality, refusal, latency, and tool usage before full migration, whereas the requirement calls for another behavior: re-running the fixed evaluation set detects behavior shifts requiring prompt adjustment; a model upgrade can affect the entire user experience even when code is unchanged.

C:

Regression tests evaluate prompts, tool arguments, latency, and output shape on the new version; however, the critical mechanism here is that re-running the fixed evaluation set detects behavior shifts requiring prompt adjustment, and version changes can affect behavior even when the API request remains syntactically valid.

D:

Integration tests inspect requested tool names, arguments, and final answer handling; the requirement instead turns on this behavior: re-running the fixed evaluation set detects behavior shifts requiring prompt adjustment; syntax compatibility does not guarantee identical agent decisions.

Question 89

One embedded application has a narrow private function that no other MCP-aware client needs to reuse. Which capability is necessary for this outcome?

  1. Expose a custom API adapter outside MCP when local-only
  2. Use a client-side transport adapter
  3. Expose an MCP prompt for a reusable template
  4. Expose an MCP tool for an executable operation

Explanation

Correct Answer

A:

A direct adapter may be simpler than running and maintaining a separate protocol server, subject to this requirement: choosing MCP solely for naming consistency introduces unnecessary lifecycle work.

Incorrect Answers

B:

Transport abstraction lets the same protocol-level concepts operate over supported connection methods; here, the controlling capability is that a direct adapter may be simpler than running and maintaining a separate protocol server, but a transport switch does not erase server deployment or security requirements.

C:

Prompt templates provide reusable structured instructions rather than executing business operations; the missing capability is more specific: a direct adapter may be simpler than running and maintaining a separate protocol server; templates do not automatically grant access to any tool or private resource.

D:

An MCP tool advertises callable functionality with input schemas and returns execution results; by comparison, the intended solution relies on this: a direct adapter may be simpler than running and maintaining a separate protocol server; tool calls still need explicit runtime permissions and backend validation.

Question 90

A failing external dependency causes the entire app to build up pending requests and exhaust workers. What would best address the stated failure mode?

  1. Use a sandbox backend for tool integration tests
  2. Use a safe degraded response on dependency outage
  3. Use a circuit breaker for cascading 5xx failures
  4. Return actionable validation errors to callers

Explanation

Correct Answer

C:

A circuit breaker temporarily blocks repeated failing calls while permitting controlled recovery probes; in production, it should not be used to hide permanent programming errors.

Incorrect Answers

A:

A nonproduction environment exercises authorization, payload mapping, and failures safely; here, the controlling capability is that a circuit breaker temporarily blocks repeated failing calls while permitting controlled recovery probes, but faking every backend call can hide actual integration incompatibilities.

B:

A fallback can queue the request or return a limited verified response without fabricating model results; the missing capability is more specific: a circuit breaker temporarily blocks repeated failing calls while permitting controlled recovery probes; retrying indefinitely inside the user's HTTP connection harms availability.

D:

A structured 4xx response names the offending field without leaking internal implementation details; the needed capability is different—a circuit breaker temporarily blocks repeated failing calls while permitting controlled recovery probes—and a generic 500 would misleadingly suggest a server outage.

Claude Certified Developer - Foundations (CCDV-F) Practice Tests