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

Question 490

A document parser should inspect confidential attachments without leaking their raw contents into the main coordinator's thread. How should this requirement be met?

  1. Load task-specific memory at the start
  2. Start a fresh isolated context for a subtask
  3. Run independent read-only tool calls concurrently
  4. Summarize old steps before continuing

Explanation

Correct Answer

B:

A separate worker receives only the necessary files and reports a minimal result; the implementation must still recognize that isolation only works when tool rights and returned text follow the same boundary.

Incorrect Answers

A:

Relevant stored facts are retrieved and inserted into the allowed context for the current task; this addresses a separate concern, not the fact that a separate worker receives only the necessary files and reports a minimal result; the context selection must be scoped to the authenticated customer.

C:

Concurrent dispatch shortens latency when tool requests are independent and safely isolated; the missing capability is more specific: a separate worker receives only the necessary files and reports a minimal result; shared write operations require separate coordination and consistency protections.

D:

A compact summary can replace bulky intermediate transcripts for the next model call; by comparison, the intended solution relies on this: a separate worker receives only the necessary files and reports a minimal result; summaries can lose details unless critical facts and provenance are retained.

Question 491

A prompt demands an arbitrary multi-page answer for a simple classification and wastes tokens. What should be implemented to solve this problem?

  1. Avoid unnecessary verbosity constraints
  2. Use application-controlled system instructions
  3. Use named sections for long complex requirements
  4. Specify a strict response schema

Explanation

Correct Answer

A:

Output guidance should match the amount of reasoning and explanation the task actually needs; longer responses can add unsupported details rather than increasing precision.

Incorrect Answers

B:

The system-level field communicates application guidance separately from task content, whereas the requirement calls for another behavior: output guidance should match the amount of reasoning and explanation the task actually needs; backend authorization still must be enforced in code and tools.

C:

Structured headings make independent instructions easier to distinguish and check; however, the critical mechanism here is that output guidance should match the amount of reasoning and explanation the task actually needs, and structure cannot rescue contradictory or factually impossible requirements.

D:

Schema constraints and subsequent validation improve consistent downstream parsing; the requirement instead turns on this behavior: output guidance should match the amount of reasoning and explanation the task actually needs; they cannot guarantee that the values are factually correct.

Question 492

A template designer wants to paste real customer transcripts into demonstration prompts. What is the appropriate next design choice?

  1. Evaluate examples for data leakage
  2. Use zero-shot instructions for a straightforward task
  3. Use one representative example to clarify format
  4. Use a fixed regression dataset for stable comparisons

Explanation

Correct Answer

A:

Approved synthetic or sanitized cases teach the format without disclosing unrelated private content; the implementation must still recognize that good few-shot performance does not justify embedding sensitive identifiers.

Incorrect Answers

B:

Direct instructions define the output without consuming tokens on demonstrations; the missing capability is more specific: approved synthetic or sanitized cases teach the format without disclosing unrelated private content; complex edge cases may still need examples and evaluations.

C:

A single illustrative input-output pair can demonstrate the intended pattern; by comparison, the intended solution relies on this: approved synthetic or sanitized cases teach the format without disclosing unrelated private content; one example may overfit to a narrow case and should be tested on alternatives.

D:

Repeated evaluation over the same representative cases reveals distributional quality differences; the needed capability is different—approved synthetic or sanitized cases teach the format without disclosing unrelated private content—and one identical answer does not prove full determinism across deployments.

Question 493

A previously called client tool has finished and Claude must be shown its output in the next conversation step. Which technical control is appropriate?

  1. Return a tool_result with the matching tool_use_id
  2. Return structured tool errors to the model
  3. Dispatch each returned tool_use by its name
  4. Preserve the assistant tool_use turn in history

Explanation

Correct Answer

A:

The caller adds a user-side tool_result block tied to the earlier tool use identifier; an unrelated message cannot reliably bind a result to the invocation it completes.

Incorrect Answers

B:

A clear error result tells the agent what failed and whether it can try an alternative, whereas the requirement calls for another behavior: the caller adds a user-side tool_result block tied to the earlier tool use identifier; swallowing the error as an empty success invites fabricated conclusions.

C:

The harness validates the tool identifier and arguments before invoking the corresponding local function; however, the critical mechanism here is that the caller adds a user-side tool_result block tied to the earlier tool use identifier, and the content block is a request to run a tool, not the executed inventory result.

D:

The assistant tool request and the following user tool result remain in the ordered message history; the requirement instead turns on this behavior: the caller adds a user-side tool_result block tied to the earlier tool use identifier; sending only the result removes context needed to interpret what was requested.

Question 494

A chat answer may explain a billing correction without actually updating the customer's invoice. Which engineering practice is the strongest match?

  1. Reject malformed structured responses safely
  2. Map model fields to application fields explicitly
  3. Separate code execution from generated text
  4. Separate display text from operational commands

Explanation

Correct Answer

D:

The service distinguishes a human-readable recommendation from an authorized tool action; the important constraint is that parsing ordinary prose to infer permission for a write is unsafe.

Incorrect Answers

A:

The application rejects or repairs through a controlled retry before updating the database; by comparison, the intended solution relies on this: the service distinguishes a human-readable recommendation from an authorized tool action; accepting partial data can corrupt downstream records and hide missing fields.

B:

An adapter transforms and validates values at the boundary rather than assuming identical schemas; the needed capability is different—the service distinguishes a human-readable recommendation from an authorized tool action—and directly sending raw model content to a write endpoint creates avoidable coupling.

C:

Text suggestions remain inert until authorized application logic validates and runs an approved operation, whereas the requirement calls for another behavior: the service distinguishes a human-readable recommendation from an authorized tool action; rendering a command in the answer is not an execution authorization.

Question 495

A high-volume metadata extractor must stay under a unit cost cap while meeting a validated accuracy minimum. Which approach targets the deciding condition?

  1. Optimize for fast first visible output
  2. Optimize for budget under a fixed accuracy floor
  3. Define fallback behavior under model outage
  4. Optimize for data minimization

Explanation

Correct Answer

B:

Candidate models are compared on both quality and total per-item spending across realistic inputs; notably, selecting the cheapest model regardless of failures can increase downstream operational costs.

Incorrect Answers

A:

Streaming and a suitable model can improve perceived responsiveness without changing the task's core accuracy bar; the requirement instead turns on this behavior: candidate models are compared on both quality and total per-item spending across realistic inputs; the first byte time and total completion time are different performance metrics.

C:

Availability requirements identify queueing, safe degraded responses, and recovery after service restoration; in contrast, candidate models are compared on both quality and total per-item spending across realistic inputs, while blindly waiting for an API call does not guarantee a usable service.

D:

Requirements enforce removal or redaction of irrelevant personal fields before model calls; this addresses a separate concern, not the fact that candidate models are compared on both quality and total per-item spending across realistic inputs; a larger context window is not permission to send more regulated data.

Question 496

An engineer needs to inspect a repository, ask follow-ups, and approve incremental file changes. Which technical control is appropriate?

  1. Use structured or streaming output for pipeline consumers
  2. Start a new session for an unrelated objective
  3. Use an interactive session for exploratory editing
  4. Use a fresh isolated CI workspace

Explanation

Correct Answer

C:

An interactive coding session supports iterative commands and review as context evolves; notably, automating every command without supervision is unnecessary for a human-led investigation.

Incorrect Answers

A:

Machine-friendly output formats allow programmatic consumers to handle individual events; however, the critical mechanism here is that an interactive coding session supports iterative commands and review as context evolves, and human-oriented terminal decoration is not a stable protocol contract.

B:

A clean context prevents old task details from biasing the new investigation; the requirement instead turns on this behavior: an interactive coding session supports iterative commands and review as context evolves; shared persistent project guidance may still apply independently of session history.

D:

Per-job isolation avoids file collisions and cross-run contamination; in contrast, an interactive coding session supports iterative commands and review as context evolves, while shared mutable directories can corrupt outputs even when prompts are correct.

Question 497

A long stream emits keepalive frames while the server is still generating. What is the most direct implementation choice?

  1. Enable streaming to show output progressively
  2. Handle partial failures inside a batch
  3. Handle ping events without treating them as content
  4. Aggregate content_block_delta events

Explanation

Correct Answer

C:

Ping events maintain connectivity but do not represent assistant text to display; its operational boundary is that showing keepalives as answer content would corrupt the rendered response.

Incorrect Answers

A:

Streaming yields server-sent events as content is produced, improving time to first visible text; the requirement instead turns on this behavior: ping events maintain connectivity but do not represent assistant text to display; the client still needs to handle partial chunks and a final completion signal.

B:

Per-item result handling records and retries appropriate failures without duplicating successful work; this cannot substitute for the behavior that ping events maintain connectivity but do not represent assistant text to display, because a batch-level completion event does not imply every included request succeeded.

D:

Deltas update the current content block until its corresponding stop event arrives; this addresses a separate concern, not the fact that ping events maintain connectivity but do not represent assistant text to display; individual fragments are not complete JSON messages or guaranteed sentence boundaries.

Question 498

A research assistant needs a supported provider-operated search capability without building its own search backend. Which mechanism should the team prioritize?

  1. Validate and execute the tool outside the model
  2. Use a deterministic application function without model dispatch
  3. Use a client-executed custom tool
  4. Use an Anthropic server-executed tool where supported

Explanation

Correct Answer

D:

Server tools execute on the service side and return associated results during the model interaction—with this limitation: they have distinct data and capability boundaries from the customer's custom functions.

Incorrect Answers

A:

Application code enforces permission checks and performs the actual side effect or read; the needed capability is different—server tools execute on the service side and return associated results during the model interaction—and the presence of tool_use content is not evidence the backend was queried.

B:

Conventional code runs the calculation directly and avoids unnecessary probabilistic tool selection, whereas the requirement calls for another behavior: server tools execute on the service side and return associated results during the model interaction; a language-model intermediary would add cost without changing the arithmetic rules.

C:

The API returns a tool_use request and the application performs the authorized operation itself; however, the critical mechanism here is that server tools execute on the service side and return associated results during the model interaction, and tool declarations do not grant the vendor access to private infrastructure.

Question 499

A user submits a document job and may close the browser before processing completes. Which measure directly addresses the problem?

  1. Use server-sent events for streamed responses
  2. Use WebSockets for application-managed duplex traffic
  3. Queue overload rather than dropping accepted work
  4. Use a queue for disconnected long-running workloads

Explanation

Correct Answer

D:

Durable queued work survives client disconnection and exposes later status, although keeping an open WebSocket alone does not make background jobs persistent.

Incorrect Answers

A:

SSE carries incremental events from the service to the client as generation proceeds; the missing capability is more specific: durable queued work survives client disconnection and exposes later status; it is not a general-purpose bidirectional client messaging transport.

B:

A WebSocket supports messages in both directions on one persistent connection; by comparison, the intended solution relies on this: durable queued work survives client disconnection and exposes later status; its availability does not imply the standard Claude Messages endpoint is a WebSocket API.

C:

A persistent queue buffers approved tasks with controlled worker concurrency; the needed capability is different—durable queued work survives client disconnection and exposes later status—and unbounded in-process arrays risk memory exhaustion and data loss.

Question 500

Users can request short data transformations and the assistant may propose executable scripts. How should this requirement be met?

  1. Execute generated code only in a restricted sandbox
  2. Parse generated JSON with a real parser
  3. Treat generated SQL as untrusted text
  4. Use parameterized queries for user values

Explanation

Correct Answer

A:

Sandboxing limits filesystem, network, process, and credential exposure; notably, asking the model to promise safety is not an operating-system isolation mechanism.

Incorrect Answers

B:

Standard JSON parsing catches syntactic errors instead of relying on visual plausibility; in contrast, sandboxing limits filesystem, network, process, and credential exposure, while successfully parsed JSON can still violate expected business types.

C:

Query validation and read-only permissions constrain execution against approved tables and patterns; this addresses a separate concern, not the fact that sandboxing limits filesystem, network, process, and credential exposure; text generation does not certify the safety or accuracy of the SQL.

D:

Parameters keep values separate from SQL structure and prevent injection from changing the query grammar; here, the controlling capability is that sandboxing limits filesystem, network, process, and credential exposure, but escaping output for HTML would not prevent SQL injection.

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