Free Claude Developer Practice Test — CCDV-F (Claude Certified Developer Foundations, Anthropic)

Prepare for Anthropic's Claude Certified Developer – Foundations (CCDV-F) exam with a free Claude Developer practice test and Claude developer questions across all 8 official domains. The real exam is 53 questions in 120 minutes with a passing score of 720/1000, costs $125, and is valid for 12 months.

CCDV-F Exam Domains (Official Anthropic Outline)

Domain 1: Applications and Integration (33.1%)

Free CCDV-F practice questions on the Messages API, streaming responses, vision and file inputs, structured outputs, message batches, error handling, and rate limits — the heaviest domain on the exam. Practice this domain →

Domain 2: Model Selection and Optimization (16.8%)

Free CCDV-F practice questions on choosing between Claude model tiers, cost vs latency trade-offs, prompt caching, token counting, extended thinking, and context window management. Practice this domain →

Domain 3: Agents and Workflows (14.7%)

Free CCDV-F practice questions on agent loops, workflows vs agents, orchestration patterns, subagents, agent memory, and multi-step task decomposition. Practice this domain →

Domain 4: Prompt and Context Engineering (11.0%)

Free CCDV-F practice questions on system prompts, XML tags, few-shot examples, chain of thought, prefilling, and long-context strategies. Practice this domain →

Domain 5: Tools and MCPs (10.6%)

Free CCDV-F practice questions on the tool use API, tool definitions and JSON schemas, tool choice, parallel tool calls, and Model Context Protocol servers and clients. Practice this domain →

Domain 6: Security and Safety (8.1%)

Free CCDV-F practice questions on prompt injection defense, jailbreak mitigation, guardrails, data privacy, content moderation, and responsible AI practices. Practice this domain →

Domain 7: Claude Code (3.1%)

Free CCDV-F practice questions on the Claude Code CLI, CLAUDE.md configuration, hooks, slash commands, permissions, and headless automation. Practice this domain →

Domain 8: Eval, Testing, and Debugging (2.6%)

Free CCDV-F practice questions on eval design, graders and rubrics, regression testing, prompt iteration, and debugging model behavior. Practice this domain →

10 Free Claude Developer Practice Questions with Answers

Each question below includes 4 answer options, the correct answer, and a detailed explanation drawn from the FlashGenius CCDV-F question bank — aligned to the official Anthropic exam outline.

Sample Question 1 — Agents and Workflows

A team is automating monthly expense report handling with Claude. Every report must follow the same sequence: extract fields, check policy rules, route exceptions to a human queue, and generate a summary. The branching conditions are fixed and success is easy to verify. Which architecture is the best fit?

  1. A. A deterministic workflow that calls Claude only at defined steps (Correct answer)
  2. B. A fully autonomous agent that decides each next action
  3. C. A manager agent that delegates every report to subagents
  4. D. A long-running agent that stores every report interaction

Correct answer: A

Explanation: Correct answer (A): A deterministic workflow is the best fit because the process has a known sequence, predictable branching, and clear success criteria. Claude can still be used inside defined steps, but the orchestration should not be left to an autonomous agent when the application already knows the correct order and routing logic. Why the other options are wrong: - Option B: An autonomous agent may appear flexible, but the task does not require dynamic planning or open-ended tool choice. It would add unnecessary variability and complexity. - Option C: Subagents may help with specialized decomposition, but this scenario is a simple fixed process. A manager/subagent pattern would add coordination overhead without a clear benefit. - Option D: Long-running memory is not needed for a predictable monthly workflow. Keeping every interaction would risk context bloat without improving the fixed routing process.

Sample Question 2 — Agents and Workflows

A developer is building a Claude-powered internal research assistant. User requests vary widely, and the assistant must decide whether to search documentation, inspect previous notes, ask a clarifying question, synthesize findings, or stop based on intermediate results. Which design is most appropriate?

  1. A. A fixed workflow with the same steps for every request
  2. B. An agent loop that plans, acts, observes, and stops (Correct answer)
  3. C. A batch job that summarizes all notes nightly
  4. D. A single prompt that forbids asking clarifying questions

Correct answer: B

Explanation: Correct answer (B): An agent loop is appropriate because the task requires dynamic planning, choosing among actions, reacting to intermediate observations, and deciding when to ask for clarification or stop. These choices cannot be fully enumerated as a fixed sequence for every research request. Why the other options are wrong: - Option A: A fixed workflow may seem easier to operate, but it is too rigid for requests that require different paths based on intermediate findings. - Option C: A nightly batch summary may be useful for a separate reporting use case, but it does not support interactive planning and adaptive research. - Option D: Forbidding clarifying questions removes a useful agent behavior. The scenario explicitly includes cases where clarification may be the right next action.

Sample Question 3 — Applications and Integration

A team needs to summarize 120,000 archived support tickets each night. No user is waiting for an immediate response, and the results only need to be available in the data warehouse by 8 a.m. Which integration approach is the best fit?

  1. A. Use synchronous Messages API calls from the web tier for each ticket.
  2. B. Use the Message Batches API for the overnight processing job. (Correct answer)
  3. C. Use streaming responses so every summary starts displaying immediately.
  4. D. Keep one long conversation session open for all ticket summaries.

Correct answer: B

Explanation: Correct answer (B): The Message Batches API is best for large numbers of requests that do not require immediate, user-facing responses. This workload is high-volume, latency-tolerant, and scheduled as an offline job, so batch processing matches the operational requirement better than synchronous realtime calls. Why the other options are wrong: - Option A: Synchronous Messages API calls are appropriate for interactive or latency-sensitive flows, but this workload is offline and high volume. - Option C: Streaming improves perceived responsiveness when a user is waiting, but it does not make an overnight batch job a better fit. - Option D: A single long session would mix unrelated tickets and create poor session boundaries rather than matching the batch workload.

Sample Question 4 — Applications and Integration

A customer-facing writing assistant often produces responses that take 8 to 12 seconds. Product wants users to see useful text as soon as it is generated, while still validating the final response before saving it. What is the most appropriate integration change?

  1. A. Enable streaming and render partial output while retaining final response handling. (Correct answer)
  2. B. Switch the feature to Message Batches API for all user requests.
  3. C. Remove response validation because streaming already confirms correctness.
  4. D. Concatenate all prior user sessions to make output start faster.

Correct answer: A

Explanation: Correct answer (A): Streaming is an integration pattern for receiving partial output progressively, which improves responsiveness in user-facing interactions. The application should still handle and validate the final response because streaming changes delivery behavior; it does not guarantee correctness or remove downstream integration responsibilities. Why the other options are wrong: - Option B: Batch processing is for requests that do not need immediate user-facing responses, so it conflicts with the interactive product goal. - Option C: Streaming changes delivery timing, not correctness guarantees; final response handling and validation are still needed. - Option D: Adding unrelated session history creates stale context and is not a valid way to improve progressive rendering.

Sample Question 5 — Claude Code

A team repeatedly tells Claude Code the same repository conventions at the start of every session. They want the guidance to be durable, reviewable, and reused by all contributors. Current onboarding note: ``` Before using Claude Code, paste: - Use pytest for backend tests. - Prefer existing repository helpers over new utilities. - Follow the service naming pattern in /services. ``` What is the BEST primary change?

  1. A. Move the conventions into a repository CLAUDE.md file. (Correct answer)
  2. B. Store the conventions in Agent Memory for each developer.
  3. C. Add the conventions as comments in settings.json.
  4. D. Paste the conventions into every new session prompt.

Correct answer: A

Explanation: Correct answer (A): CLAUDE.md is the appropriate Claude Code mechanism for durable, human-readable project or repository instructions. It avoids repeated ad hoc prompting and makes conventions easier for the team to review and maintain across sessions and contributors. Why the other options are wrong: - Option B: Agent Memory can retain context or preferences, but shared project conventions should be explicit and reviewable in repository guidance rather than hidden per developer. - Option C: settings.json is for Claude Code configuration, not for storing human-readable coding standards as comments or policy guidance. - Option D: Repeating the guidance manually is exactly the brittle workflow the team is trying to eliminate.

Sample Question 6 — Claude Code

A monorepo uses Claude Code across frontend and backend teams. Repository layout: ``` /CLAUDE.md "All code must use the shared logging wrapper." /web/CLAUDE.md "Use the design-system components for UI work." /api/ payment handlers, database migrations, service tests ``` The API team wants Claude Code to consistently follow API-only conventions for migrations and service tests without affecting web work. Where should the team place this guidance?

  1. A. In a new /api/CLAUDE.md file near the API code. (Correct answer)
  2. B. In /web/CLAUDE.md so all nested teams can see it.
  3. C. In Agent Memory for the API team's lead developer.
  4. D. In settings.json as a repository-wide configuration value.

Correct answer: A

Explanation: Correct answer (A): A CLAUDE.md hierarchy lets teams place broad guidance at the repository root and narrower guidance closer to the subdirectory it governs. API-specific conventions belong near the API code so they apply to that scope without polluting unrelated web guidance. Why the other options are wrong: - Option B: The web CLAUDE.md is scoped to frontend work and is the wrong location for API-only guidance. - Option C: Agent Memory is not the best place for shared API project policy because it is not explicit repository guidance for all contributors. - Option D: settings.json configures Claude Code behavior, but coding conventions for a subdirectory belong in human-readable CLAUDE.md guidance.

Sample Question 7 — Eval, Testing, and Debugging

A staging chatbot suddenly fails before returning any assistant message. The trace shows: ``` request_id: req_4821 POST /v1/messages status: 401 response: {"error":"invalid API key"} model_response_received: false retry_count: 3 ``` What is the BEST classification of this failure?

  1. A. A model-output failure caused by an unhelpful response
  2. B. An integration-layer failure caused before model generation (Correct answer)
  3. C. A schema validation failure in the post-processing layer
  4. D. A prompt-quality failure caused by unclear instructions

Correct answer: B

Explanation: Correct answer (B): The log shows an HTTP 401 and explicitly says no model response was received. That places the first failure boundary before Claude generated output, so the correct diagnosis is an integration-layer issue involving authentication or request setup. Retrying without fixing the API key will not address the root cause. Why the other options are wrong: - Option A: A model-output failure may seem plausible because the chatbot produced no useful answer, but the log shows no model response was generated. - Option C: Schema validation is a post-processing concern, but the request failed at authentication before any response content could be validated. - Option D: Prompt quality can affect generated content, but the model was never reached, so prompt changes are not the right diagnosis.

Sample Question 8 — Eval, Testing, and Debugging

A team tests a Claude-powered support reply generator. The failing test log shows: ``` expected: "Your refund will be processed in 5-7 business days." actual: "We’ll process your refund within five to seven business days." policy_check: passed required_fields: passed customer_tone: passed ``` The task does not require exact wording. What is the BEST test change?

  1. A. Replace the exact-string assertion with semantic acceptance checks (Correct answer)
  2. B. Increase retry count until the exact sentence is produced
  3. C. Fail the response because it differs from the golden text
  4. D. Disable automated testing for this generated reply

Correct answer: A

Explanation: Correct answer (A): Because the task does not require exact wording and all task-specific checks passed, the test is brittle. LLM output can vary while still satisfying the requirement. A better test validates semantics, required constraints, structured fields, and acceptance criteria instead of a single exact sentence. Why the other options are wrong: - Option B: Retries may occasionally reproduce the target wording, but they increase cost and hide a brittle test design rather than fixing it. - Option C: Golden text can be useful when exact wording matters, but the scenario says equivalent wording is acceptable. - Option D: Disabling testing avoids false failures but removes regression coverage instead of improving the assertion.

Sample Question 9 — Model Selection and Optimization

A team is adding a Claude-powered intent router in front of a support system. The task is to map each message to one of 12 categories and return a short JSON label. A validation set shows simple examples with little ambiguity. Artifact: Workload: 3 million requests/month Target: p95 latency under 700 ms Business priority: lowest cost that still passes validation Quality bar: 95% label accuracy on held-out examples Current plan: use the most capable model for all requests What is the best initial model-selection approach?

  1. A. Start with Haiku and validate accuracy before rollout. (Correct answer)
  2. B. Use Opus because it provides the highest capability.
  3. C. Use extended thinking for every routing request.
  4. D. Use multi-shot examples with the largest context.

Correct answer: A

Explanation: Correct answer (A): For a high-volume, low-latency, cost-sensitive classification or routing task, Haiku is generally the best starting point when validation can confirm it meets the quality bar. The scenario describes a simple constrained-label task, a strict latency target, and a cost priority, so the developer should test the smaller/faster model rather than defaulting to a more expensive model or higher reasoning configuration. Why the other options are wrong: - Option B: Opus may be attractive because it is the most capable model, but the task is simple and highly cost- and latency-sensitive. It is not the best initial choice when a smaller model can be validated. - Option C: Extended thinking can help complex reasoning tasks, but this router only needs simple classification. It would add latency and token use without matching the stated priority. - Option D: Examples can improve behavior, but using many examples and the largest context increases token usage. The stem asks for model selection under a low-cost, low-latency goal.

Sample Question 10 — Model Selection and Optimization

A developer is building an internal contract review assistant. It summarizes clauses and flags unusual obligations for a legal operations team, but lawyers still review the final output. Artifact: Quality need: strong reasoning over long legal text Latency need: interactive responses under a few seconds when possible Budget: moderate; cannot use the highest-cost path for every request Risk: important, but not autonomous final decision-making Which model strategy is most appropriate as the default?

  1. A. Use Sonnet as the default and evaluate edge cases. (Correct answer)
  2. B. Use Haiku for all reviews to minimize cost.
  3. C. Use Opus for every clause regardless of complexity.
  4. D. Use fast mode only and skip quality evaluation.

Correct answer: A

Explanation: Correct answer (A): Sonnet is commonly the balanced default when an application needs strong quality while preserving better latency and cost than the most capable model. The task requires meaningful reasoning over legal text, so the smallest model for all cases is risky, but the scenario does not justify using the most expensive model for every request because lawyers review outputs and budget is moderate. Why the other options are wrong: - Option B: Haiku may reduce cost, but the scenario calls for strong reasoning over legal language. Choosing it for all reviews without validation would underweight quality requirements. - Option C: Opus may help the hardest cases, but the scenario states a moderate budget and interactive latency needs. Using it for every clause is not the best default. - Option D: Fast mode may improve latency, but skipping quality evaluation is inappropriate for a legal-review workflow with stated reasoning requirements.

Quick 10-Question Claude Developer Practice Test

Take a free 10-question CCDV-F quick-start practice test covering all 8 domains. Get instant scoring with detailed explanations — perfect for a quick readiness check.

Frequently Asked Questions about the Claude Developer (CCDV-F) Exam

Is CCDV-F an entry-level certification?

It is a foundations-level certification for the Claude platform, but it assumes real developer experience — comfort with code, REST APIs, streaming, structured outputs, and tool schemas.

How long is CCDV-F valid?

12 months. The short validity reflects how quickly the Claude platform evolves — Anthropic requires annual recertification.

How long should I study?

Developers who already build with the Claude API typically need 2–4 weeks. Newcomers should plan 1–2 months and build at least one small Claude-powered project with tool use before sitting the exam.

How much does CCDV-F cost?

$125 USD, delivered online.

Why Choose FlashGenius for Claude Developer (CCDV-F) Prep?

Start your free CCDV-F practice test now | Quick start mock exam | All Sample Tests