Claude Code Developer: CCDV-F Domain Skills Guide

Every candidate who sits the Claude Certified Developer, Foundations exam (CCDV-F) is, in effect, proving they can work as a competent claude code developer across eight distinct skill domains. The exam costs $125 USD, runs 53 items in 120 minutes, and scores on a 100-to-1000 scale with a passing bar of 720. What makes it unusual is the domain weight distribution: one domain alone accounts for 33.1% of the exam, while another sits at just 2.6%. Knowing which skills to prioritise is half the battle.

This guide maps every domain, explains what the exam actually tests within each, and gives you concrete preparation strategies. We also flag the "low-weight but tricky" domains that recent candidates consistently underestimate.

What does the CCDV-F exam actually test?

The CCDV-F is not a recall test. Every item is scenario-based and asks you to apply practical judgement. Per Anthropic's exam guide, the exam rewards candidates who can reason about trade-offs in real production contexts: latency vs cost, quality vs speed, deterministic enforcement vs probabilistic guidance.

The eight domains and their exact weights are:

Domain 2 (Applications and Integration) at 33.1% is the single largest slice. If you only have limited study time, that domain deserves disproportionate attention. Domains 3 and 4 together account for just 5.7%, but experienced candidates warn that the items in those domains are often the most technically specific and therefore the easiest to miss.

How should you approach Domain 2: Applications and Integration?

Domain 2 is the exam's centre of gravity. At 33.1%, it covers the mechanics of building real Claude-powered applications: the Messages API request-response cycle, streaming, image input, prompt caching, batching decisions, and how model IDs differ across Anthropic's direct API versus Bedrock and Vertex deployments.

The Messages API request-response cycle is foundational. Every Claude API call follows the same structure: you send a messages array with role and content fields, a model string, and a max_tokens value. The exam tests whether you know which fields are required versus optional, and what happens when you omit them.

A minimal valid request looks like this:

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain prompt caching in one paragraph."}
    ]
)
print(message.content[0].text)

Streaming is a common exam scenario. You will be asked to choose between a streaming response and a standard synchronous call given a set of latency and UX requirements. The rule of thumb: use streaming when you need to display tokens progressively to a user; use synchronous calls when you need the full response before doing anything with it (for example, parsing structured output).

Batching versus real-time is another recurring decision point. The Anthropic Batch API lets you submit up to 10,000 requests in a single batch at reduced cost, with results available asynchronously. Exam scenarios will describe a workload and ask you to choose. The decision rule is straightforward: if the task is latency-sensitive or user-facing, use real-time. If it is offline, bulk, or cost-sensitive, batching is the right answer.

Prompt caching is tested at a practical level. You need to know that caching works by marking a prefix of your prompt with a cache_control parameter, and that the cache is keyed to the exact token sequence. Changing even one token in the cached prefix invalidates the cache.

{
  "model": "claude-opus-4-5",
  "max_tokens": 1024,
  "system": [
    {
      "type": "text",
      "text": "You are a senior software engineer reviewing pull requests.",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  "messages": [
    {"role": "user", "content": "Review this diff: ..."}
  ]
}

How do you choose between Claude models for the exam?

Domain 5 (Model Selection and Optimisation) carries 16.8% of the exam. The core skill is matching a model to a scenario's constraints across three axes: quality, latency, and cost.

Anthropic's current model family gives you three tiers to reason about:

The exam will not ask you to memorise pricing. It will give you a scenario with explicit constraints and ask which model is appropriate. A customer-facing chatbot that must respond in under two seconds and handles thousands of requests per hour is a Haiku scenario. A legal document analysis pipeline that runs overnight and requires nuanced reasoning is an Opus scenario.

Extended thinking (reasoning controls) is tested at a conceptual level. When a scenario involves multi-step reasoning where intermediate steps matter, enabling extended thinking allows the model to work through a problem before producing its final answer. The trade-off is increased token usage and latency.

What do agents and workflows questions look like?

Domain 1 (Agents and Workflows) at 14.7% tests your ability to design and reason about agentic systems. The exam distinguishes between two fundamentally different approaches: fixed sequential pipelines (prompt chaining) and dynamic adaptive decomposition.

The agentic loop anti-patterns concept is directly relevant here. A well-designed agent loop inspects the stop_reason field on every response. If stop_reason is tool_use, the agent must execute the requested tool and append the result before continuing. If it is end_turn, the task is complete. Failing to check stop_reason correctly is the most common source of premature loop termination.

while True:
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=4096,
        tools=tools,
        messages=messages
    )

    if response.stop_reason == "end_turn":
        break
    elif response.stop_reason == "tool_use":
        tool_result = execute_tool(response.content)
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_result})
    else:
        # Handle unexpected stop reasons explicitly
        raise ValueError(f"Unexpected stop_reason: {response.stop_reason}")

The exam also tests when to use the Agent SDK versus a hand-rolled loop. The Agent SDK is appropriate when you need built-in orchestration, subagent management, and structured handoffs. A hand-rolled loop is appropriate when you need precise control over every step and the overhead of the SDK is not justified.

For multi-agent systems, hub-and-spoke architecture is the dominant pattern: a coordinator agent receives the task, decomposes it, delegates to specialised subagents, and synthesises results. The exam tests whether you understand the coordinator's responsibilities and how subagent context isolation prevents one agent's errors from contaminating another's.

How important is Prompt and Context Engineering (Domain 6)?

Domain 6 carries 11.0% of the exam. The exam tests practical prompt construction, not theory. The key skills are: writing system prompts that constrain behaviour reliably, using few-shot examples to shape output format, and managing context windows to avoid the attention dilution problem.

The attention dilution problem is directly testable: as context grows, the model's attention is spread across more tokens, and information in the middle of a long context window receives less weight than information at the start or end. The practical fix is to place the most important instructions at the beginning of the system prompt and the most important data at the end of the user turn.

Context management strategy selection is a recurring scenario type. Given a task that requires processing a document longer than the context window, you must choose between chunking with summarisation, retrieval-augmented generation, or prompt caching. The right answer depends on whether the task requires the full document simultaneously or can be processed sequentially.

What does the Tools and MCPs domain test?

Domain 8 (Tools and MCPs) at 10.6% tests tool design and the Model Context Protocol. The exam distinguishes between well-designed and poorly-designed tools. A well-designed tool has a precise description that tells the model exactly when to use it, a narrow scope that prevents misuse, and a structured error response that the model can reason about.

Tool descriptions as a selection mechanism is the foundational concept. The model selects tools based on their descriptions, not their names. A vague description like "searches for information" will cause the model to misroute requests. A precise description like "searches the internal product catalogue by SKU or product name; use only for product lookup, not for customer data" will route correctly.

MCP (Model Context Protocol) servers extend Claude's capabilities by exposing tools, resources, and prompts through a standardised interface. The exam tests the MCP scoping hierarchy: project-level MCP servers are available to all sessions in a project, user-level servers are available across all projects for a user, and instance-level servers are available only for a specific session.

{
  "mcpServers": {
    "product-catalogue": {
      "command": "npx",
      "args": ["-y", "@company/product-catalogue-mcp"],
      "env": {
        "CATALOGUE_API_KEY": "${CATALOGUE_API_KEY}"
      }
    }
  }
}

Environment variable expansion in MCP configuration (using ${VAR_NAME} syntax) is a specific testable detail. Never hardcode credentials in MCP configuration files.

How should you handle Security and Safety (Domain 7)?

Domain 7 (Security and Safety) at 8.1% covers the practical defences that production Claude applications need. The exam tests four main threat categories: prompt injection, jailbreak resistance, data leakage, and PII handling.

Prompt injection is the most commonly tested attack vector. It occurs when user-supplied content contains instructions that attempt to override the system prompt. The defence is layered: validate and sanitise user input before it enters the prompt, use a strong system prompt that explicitly instructs the model to ignore instructions embedded in user content, and implement output validation to catch cases where the model has been manipulated.

PII handling scenarios ask you to choose between several approaches: redacting PII before it enters the prompt, instructing the model to avoid repeating PII in its output, or using structured output to ensure PII fields are never included in the response. The exam rewards layered approaches over single-point defences.

Why should you not skip Domains 3 and 4?

Domain 3 (Claude Code) at 3.1% and Domain 4 (Eval, Testing, and Debugging) at 2.6% together account for only 5.7% of the exam. That sounds negligible until you realise that on a 53-item exam, those domains represent roughly three items. Three items can be the difference between passing and failing at the 720 threshold.

Claude Code is Anthropic's agentic coding tool. As a claude code developer preparing for the exam, you need to understand the three-level configuration hierarchy: global configuration applies to all projects, project-level configuration (in CLAUDE.md) applies to a specific repository, and session-level configuration applies to a single Claude Code session. The exam tests which level of configuration is appropriate for a given requirement.

The eval domain tests your ability to design evaluation pipelines for Claude applications. The key concepts are: what makes a good eval (it should be automated, reproducible, and tied to a specific capability), how to use Claude as a judge in an eval pipeline, and how to detect regressions when you change a model or prompt.

Our adaptive study platform maps every practice question to the specific domain and task statement it tests. If you are running short on time, use the domain filter to focus your remaining sessions on Domains 2 and 5 first, then sweep Domains 3 and 4 before your exam date.

What is the most efficient study sequence for CCDV-F?

Based on the domain weights, we recommend the following study sequence:

1. Domain 2: Applications and Integration (33.1%) - Start here. Master the Messages API, streaming, batching, prompt caching, and image input before anything else.
2. Domain 5: Model Selection and Optimisation (16.8%) - Learn the model tier trade-offs and when extended thinking applies.
3. Domain 1: Agents and Workflows (14.7%) - Understand the agentic loop, stop_reason inspection, and the SDK vs hand-rolled loop decision.
4. Domain 6: Prompt and Context Engineering (11.0%) - Focus on system prompt construction, few-shot examples, and context window management.
5. Domain 8: Tools and MCPs (10.6%) - Learn tool description design, MCP scoping, and error response patterns.
6. Domain 7: Security and Safety (8.1%) - Cover prompt injection, PII handling, and layered guardrails.
7. Domain 3: Claude Code (3.1%) - Review the configuration hierarchy and Claude Code-specific workflows.
8. Domain 4: Eval, Testing, and Debugging (2.6%) - Cover eval pipeline design and regression detection.

The CCDV-F, unlike the CCAR-F Architect exam, does not draw from a scenario bank. Items are written directly against the skills in each domain, which means every domain can appear on every sitting. Skipping any domain is a calculated risk.

As of 3 June 2026, more than 10,000 individuals have earned certifications across the Claude Partner Network. The CCDV-F is one of four live tracks, alongside the CCAO-F ($99), CCAR-F ($125), and CCAR-P ($175). Our platform offers adaptive study and practice exams for both CCDV-F and CCAR-F, scored on the same 100-to-1000 scale with 720 as the passing bar.