Claude Code Skills: Master the CCDV-F Developer Exam

The CCDV-F (Claude Certified Developer, Foundations) exam tests whether you can apply claude code skills in realistic production scenarios, not recite definitions. At 53 items across eight domains in 120 minutes, the exam rewards developers who understand why a configuration decision holds under pressure, not just what the syntax looks like. This guide maps the highest-weight domains to the specific skills that move your scaled score past the 720 passing bar.

What does the CCDV-F exam actually test?

The CCDV-F is a 53-item, 120-minute proctored exam scored on a 100-to-1000 scale, with 720 as the passing score. Per Anthropic's official exam guide, items are written directly against skills in each domain rather than drawn from a scenario bank, so every question is grounded in a realistic developer situation. The score report gives you pass/fail, your scaled score, and percent-correct by domain, which makes post-exam diagnosis precise.

The eight domains and their exact weights are:

Domain 2 (Applications and Integration) alone accounts for a third of the exam. Domains 5, 1, and 8 together add another 42%. Directing study time proportionally to these weights is the single highest-leverage planning decision you can make.

Which configuration hierarchy rules appear in the Claude Code domain?

Domain 3 (Claude Code) carries 3.1% of the exam, but the configuration concepts it tests bleed into Domains 1 and 2 as well. The three-level configuration hierarchy governs how Claude Code resolves competing instructions: enterprise policy overrides user settings, which override project-level CLAUDE.md files. Understanding this precedence matters whenever a scenario describes conflicting instructions from different sources.

Within a project, the .claude/ directory holds skills, commands, and settings. Skills live under .claude/skills/ and are scoped to the session that loads them. The CLAUDE.md file at the project root acts as persistent context, injected automatically into every session. A common exam trap is assuming that a more specific file always wins; the actual rule is that the level in the hierarchy (enterprise, user, project) determines precedence, not file specificity.

Version control implications are also tested: CLAUDE.md belongs in version control so the whole team shares the same baseline, while personal skill customisations in ~/.claude/ should not be committed. Exam items will present a team scenario and ask which configuration approach is correct; the answer almost always hinges on this shared-vs-personal boundary.

How do MCP tool design skills affect the Tools and MCPs domain?

Domain 8 (Tools and MCPs) is 10.6% of the exam. The core skill is understanding how Claude selects tools at inference time: it reads tool descriptions, not just names. A vague description produces misrouting; a precise, action-oriented description produces reliable selection. This is the tool descriptions as selection mechanism principle, and it appears in scenario items that ask you to diagnose why an agent keeps calling the wrong tool.

MCP integration adds a layer of scoping. The MCP scoping hierarchy determines which servers are available in which contexts: global servers are always present, project servers are loaded from .mcp.json, and local overrides are possible. Exam scenarios frequently describe a tool that works in one environment but not another; the answer is almost always a scoping misconfiguration rather than a code bug.

Error handling is the other major MCP skill. The isError flag in MCP responses signals a tool-level failure without crashing the agent loop. Items in this area ask you to distinguish between an access failure (the tool could not reach a resource) and a valid empty result (the resource exists but contains nothing). Getting this distinction wrong leads to agents that silently suppress errors or retry indefinitely.

{
  "type": "tool_result",
  "tool_use_id": "toolu_01abc",
  "content": "No records found for the given date range.",
  "is_error": false
}

The above is a valid empty result. Setting is_error: true here would be incorrect and would cause the agent to treat a normal outcome as a failure.

What prompt and context engineering patterns does the exam test?

Domain 6 (Prompt and Context Engineering) is 11.0% of the exam. The items here test practical judgment: given a scenario where a model is producing inconsistent output, which technique fixes it most efficiently?

The hierarchy of techniques, from lowest to highest leverage, runs roughly as follows:

1. Clarify the instruction wording (low effort, often sufficient for simple tasks)
2. Add explicit output format constraints (medium effort, high reliability for structured output)
3. Introduce few-shot examples (high leverage for ambiguous or edge-case tasks)
4. Restructure the context window to put critical instructions near the top or bottom (addresses attention dilution)

The attention dilution problem is particularly relevant for long-context tasks: instructions buried in the middle of a large context window receive less model attention than those at the edges. Exam items will describe a scenario where a model ignores a constraint that is present in the prompt; the correct diagnosis is often positional, not logical.

For structured output specifically, schema design matters as much as the prompt. A schema that allows optional fields where required fields are needed will produce incomplete responses even with a perfect prompt. Items in this area ask you to identify the schema flaw, not just the prompt flaw.

# Fragile: optional field allows the model to skip critical data
schema = {
    "type": "object",
    "properties": {
        "summary": {"type": "string"},
        "confidence": {"type": "number"}  # not in "required"
    },
    "required": ["summary"]
}

# Robust: both fields required
schema = {
    "type": "object",
    "properties": {
        "summary": {"type": "string"},
        "confidence": {"type": "number"}
    },
    "required": ["summary", "confidence"]
}

How does agentic orchestration logic appear across the highest-weight domains?

Domain 1 (Agents and Workflows, 14.7%) and Domain 2 (Applications and Integration, 33.1%) both test agentic orchestration, making it the single most important conceptual area on the exam. The key patterns to internalise are:

Hub-and-spoke vs. peer-to-peer. A hub-and-spoke architecture uses a coordinator that routes tasks to specialised subagents. This is the default pattern for most production systems because it keeps routing logic centralised and auditable. Peer-to-peer agent communication is harder to debug and rarely the right answer on exam items.

Goal-based vs. step-based prompts. Goal-based prompts tell the agent what outcome to achieve; step-based prompts prescribe the exact sequence. The exam consistently rewards goal-based framing for dynamic tasks and step-based framing for deterministic pipelines where deviation is dangerous.

Subagent context isolation. Each subagent should receive only the context it needs to complete its task. Subagent context isolation prevents context bleed between parallel workstreams and reduces token cost. Items that describe a subagent producing outputs that reference information it should not have access to are diagnosing a context isolation failure.

Error routing in multi-agent systems. When a subagent fails, the coordinator must decide whether to retry, reroute, or escalate. Multi-agent error handling and routing is tested in scenarios where the wrong choice (for example, retrying a deterministic failure) wastes resources without resolving the root cause.

Does practical experience substitute for structured study?

There is no stated experience prerequisite for the CCDV-F. However, the exam's scenario-based items assume familiarity with production failure modes that are hard to internalise from documentation alone. A developer who has debugged a real agentic loop will recognise a premature loop termination scenario immediately; one who has only read about it may not.

That said, experience without structured knowledge of the exam domains is also insufficient. The exam tests specific Anthropic terminology and API mechanics: stop_reason values, tool_use content blocks, cache_control headers, and the isError flag are all concepts that appear in items and require precise understanding, not just general familiarity with LLM APIs.

The practical preparation approach that works best combines three elements: domain-weighted study (allocate time proportional to the weights in the table above), scenario practice under timed conditions, and targeted review of weak domains using the percent-correct breakdown from practice exams. Our CCDV-F practice exams mirror the real format exactly: 53 questions, scored 100 to 1000, with 720 as the passing bar.

How should you approach timed exam simulation?

The CCDV-F gives you 120 minutes for 53 items, which works out to roughly 2 minutes 15 seconds per item. Unlike the CCAR-F, the CCDV-F does not draw from a scenario bank; items are written directly against domain skills, so you will not see the same four-scenario structure that CCAR-F candidates encounter.

A practical pacing strategy:

1. Work through all items at a steady pace, flagging any that require more than 90 seconds of thought.
2. After the first pass, return to flagged items with the remaining time.
3. On multiple-response items (where you must select more than one answer), eliminate clearly wrong options first, then evaluate the remaining candidates against the specific domain principle being tested.
4. Never leave an item blank; there is no penalty for an incorrect answer beyond the lost point.

The most common timing mistake is spending too long on Domain 3 (Claude Code) or Domain 4 (Eval, Testing, and Debugging) items, which together account for only 5.7% of the exam. Proportionate time allocation means these domains deserve roughly six minutes combined, not twenty.

What terminology do you need to know precisely?

The exam uses Anthropic-specific terminology throughout. Imprecise understanding of these terms leads to wrong answers on items that appear straightforward:

For a deeper treatment of the Messages API mechanics underlying these terms, see our concept on the Messages API request-response cycle.

Are third-party practice tests worth using?

We cannot verify the accuracy of third-party question banks (including those on Udemy or Coursera) against the official CCDV-F exam guide. The risk with unofficial materials is twofold: questions may test the wrong concepts, and they may reinforce incorrect mental models that are hard to unlearn under exam pressure.

The only practice materials we can confirm are aligned to the official exam guide are those built against Anthropic's published domain weights and task statements. Our platform's adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold, which means it continues surfacing a concept until your demonstrated accuracy is consistently high, not just occasionally correct. That is a meaningfully different preparation experience from working through a static question bank.

AI Skill Certs is an independent prep platform and is not affiliated with or endorsed by Anthropic. What we offer is rigorous alignment to the published exam guide, adaptive practice that surfaces your weakest domains, and Archie, our Socratic tutor that guides you to the right reasoning rather than giving you the answer directly.

The CCDV-F is a $125 exam with a 12-month credential validity. Passing it on the first attempt is the most cost-efficient outcome. Structured, domain-weighted preparation is the most reliable path to that outcome.