Question 1

Your Claude application produces good responses for typical inputs but struggles with edge cases. You have several labeled examples of edge-case inputs and the desired response for each. You want to use these examples to improve the model's handling of edge cases.

What is the best way to use these examples?

AEmbed the examples in a database for the model to find during inference.

BAdd the labeled edge-case examples to the prompt as few-shot examples so the model can learn the pattern.

CTrain a custom model on the edge-case examples and deploy that custom model in place of the team's current Claude integration.

DTell users to avoid submitting the edge-case inputs to the application by adding warnings in the application's user interface.

Answer : B

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.

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

Question 2

Your Claude application's prompt was written months ago and has not been updated. The team has discovered through evals that the prompt produces good results on common cases but underperforms on a specific category of inputs that has grown in volume.

How would you respond?

AIterate on the prompt to address the underperforming category, validate the change with evals, and continue refining as needed.

BTell users to avoid the underperforming category by adding warnings in the application's user interface about handled inputs.

CReplace the prompt with a new one aligned to the underperforming category, treating any common-case performance change as a known tradeoff.

DAdd the underperforming category to a separate Claude application with its own prompt so the original prompt does not change.

Answer : A

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.

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

Question 3

A teammate has asked how to extend Claude Code with a custom Skill that the team can invoke during sessions. The Skill consists of a set of instructions and a few support scripts the team wants Claude to be able to call when the Skill is loaded.

Where is the right place to define the Skill?

ADefine the Skill as a long inline instruction at the top of every CLAUDE.md file in the team's repositories so Claude has access to it on every session.

BDefine the Skill inside the application's source code as a regular library module and call it from the application code instead of from Claude Code.

CDefine the Skill in a Skills directory recognized by Claude Code, where Claude can discover and load it during sessions for the team's repositories.

DDefine the Skill in a personal scratch directory on each developer's machine and load it manually before each Claude Code session that needs it.

Answer : C

Option C matches Claude Code's documented Skill architecture. Agent Skills are filesystem-based extension artifacts rather than ordinary application modules or repeated prompt fragments. A Skill is represented by a directory containing a required SKILL.md file and can include optional supporting scripts, templates, examples, and reference material.

Anthropic documents project Skills under .claude/skills/<skill-name>/SKILL.md. Project-level Skills can be shared through Git and automatically discovered when Claude Code loads project settings. Supporting scripts can reside alongside the Skill and be referenced from SKILL.md.

A incorrectly embeds reusable procedural material into every CLAUDE.md file, creating duplication and loading instructions even when they are irrelevant. B creates a conventional source-code library but does not register a Claude Code Skill. D makes the capability dependent on undocumented, developer-specific setup and undermines team reuse.

Therefore, C uses the extension mechanism specifically designed for discoverable, reusable Claude capabilities. Relevant Study Guide topics: Agent Skills, .claude/skills, SKILL.md, supporting resources, filesystem discovery, project-level configuration, and reusable Claude Code capabilities.

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

Question 4

You are building a Claude application that processes 10,000 customer emails overnight to extract structured dat

a. The work is non-interactive, runs once daily, and has a flexible completion window of several hours. Which Claude API would you use?

AThe Batch API, which is designed for non-interactive workloads with flexible completion windows.

BThe streaming responses API to process each email and return partial results to a database as the model generates them.

CThe real-time Messages API, processing the emails one at a time sequentially to ensure consistent ordering of results.

DThe real-time Messages API with concurrent requests to process the emails as fast as possible during the overnight window.

Answer : A

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.

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

Question 5

A team has deployed a multi-agent system in which a primary agent decomposes user requests and delegates subtasks to three specialized subagents: one for data retrieval, one for analysis, and one for report generation. In production, the team observes that subagents are making redundant tool calls, occasionally exceeding token budgets, and sometimes producing outputs that contradict each other --- all of which the primary agent passes along without catching.

What is the most appropriate way to address these failures?

AAdd retry logic to each subagent so that when a tool call fails, the subagent retries automatically before escalating --- and configure each subagent to log its tool calls and outputs to a shared trace so the team can audit redundancy and contradictions after the fact.

BGive each subagent read access to the other subagents' outputs so they can identify and resolve contradictions without routing back through the primary agent.

CStrengthen the primary agent's management layer to enforce per-subagent tool budgets, validate outputs against a defined schema before passing them forward, and establish explicit handoff contracts between stages.

DCollapse the three subagents into a single large-context model call that handles retrieval, analysis, and generation in one pass.

Answer : C

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.

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

Free Practice Questions for Anthropic CCDV-F Exam

Question 1

Question 2

Question 3

Question 4

Question 5