Everything Claude Code: CCDV-F Developer Exam Guide

If you have searched for everything claude code and how it maps to the CCDV-F exam, this guide covers every point of contact. Claude Code appears by name in Domain 3, but its configuration concepts, MCP integrations, and agentic patterns touch five of the eight domains. Understanding where the boundaries fall is the first step to allocating study time correctly.

What is Claude Code's role in the CCDV-F exam?

Claude Code earns its own domain on the Claude Certified Developer, Foundations exam, but Domain 3 carries only 3.1% of the 53-item, 120-minute assessment. That translates to roughly one or two questions. The real reason to study Claude Code deeply is that it serves as the environment in which you demonstrate skills from heavier domains: Applications and Integration (33.1%), Agents and Workflows (14.7%), and Tools and MCPs (10.6%).

Source: Official CCDV-F exam guide, 2026-07-08.

The passing score is 720 on a 100-to-1000 scale. Anthropic does not publish a raw-to-scaled conversion, so we cannot state an exact question count as the pass mark.

What does Domain 3 actually test?

Domain 3 covers the operational mechanics of Claude Code as a developer environment. Items test whether you can configure the tool correctly and distinguish the purposes of its configuration layers. The three-level configuration hierarchy covers global user settings, project-level CLAUDE.md, and directory-scoped CLAUDE.md files. Exam scenarios typically present a developer who needs a rule applied everywhere versus one that should stay within a single repository, then ask which configuration layer to use.

Version control implications appear in scenario items too. A CLAUDE.md committed to a repository becomes part of the team's shared context; user-level configuration stays local. The exam rewards precise answers about scope.

Custom slash commands and skills extend Claude Code's default behaviour. An item might describe a team that wants Claude Code to run a specific security scan before every file write and ask how to wire that up without modifying the model's system prompt. The answer involves hooks, not instructions. Hooks execute outside the model loop, making them immune to prompt injection and consistent across every interaction. A PreToolUse hook can validate a file path before Claude Code writes to it; a PostToolUse hook can normalise the output format. The exam tests whether you understand that hooks are the correct mechanism for this class of requirement, not an elaborated system prompt.

How does Claude Code connect to the highest-weight domain?

Domain 2 (Applications and Integration, 33.1%) is where most exam points live. Claude Code is a primary integration surface: developers embed it into CI/CD pipelines, call the Claude API from scripts Claude Code generates, and use Claude Code to scaffold the applications the exam tests.

A common scenario pattern in Domain 2 presents a developer who needs to integrate Claude's API into a web service. The item tests which request pattern is appropriate: a streaming call for a latency-sensitive user-facing endpoint, a batch request for asynchronous report generation, or a simple synchronous call for a short internal task.

# Streaming response for low-latency user-facing endpoints
import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarise this report."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Cost-reduction questions in Domain 2 often hinge on prompt caching and context reuse. When a system prompt contains several kilobytes of static policy text, caching that content reduces per-request cost significantly. The exam tests whether you know when caching helps versus when fresh context is required.

What does the CCDV-F exam test about agents and workflows?

Domain 1 (Agents and Workflows, 14.7%) tests the boundary between agentic loops and deterministic pipelines. The exam asks you to identify when an agent should make its own sequencing decisions versus when you should hard-code the steps. If the task structure is known in advance and errors are hard to reverse, a fixed pipeline is the correct choice. If the task requires adaptive branching based on intermediate results, an agent loop is appropriate.

Agentic Architecture and Orchestration supplies the vocabulary for these scenarios: orchestrators delegate to subagents, each subagent receives only the context it needs, and the coordinator synthesises results. The exam tests whether you can identify the failure mode when a coordinator passes too much or too little context to a subagent.

Termination conditions are a high-frequency topic. An agentic loop without an explicit stopping criterion can exhaust tokens or cycle indefinitely. Anthropic's guidance on agent design emphasises that in agentic contexts mistakes may be difficult to reverse and could have downstream consequences within the same pipeline. The exam tests this principle directly: items present a partially specified loop and ask what safeguard is missing.

How does Claude Code connect to tools and MCPs?

Domain 8 (Tools and MCPs, 10.6%) covers the Model Context Protocol and how tools are exposed to Claude. Claude Code ships with built-in tools and also supports external MCP servers, which extend what Claude can do inside a project. The Tool Design and MCP Integration concepts are the backbone here.

A common exam scenario describes a team that has connected a database MCP server to Claude Code. The question asks how Claude selects among available tools: the answer is through tool descriptions, not system prompt instructions. Writing precise, unambiguous tool descriptions is the primary lever for correct tool routing.

MCP scoping is a second high-frequency topic. Tools registered globally are available in every project; tools registered at project scope are available only when that project's CLAUDE.md is active. An exam item might ask what happens when a developer runs a script that depends on a project-scoped MCP tool outside the project directory. The answer is a tool-not-found error, not a silent fallback.

{
  "mcpServers": {
    "database": {
      "command": "node",
      "args": ["./mcp-server/index.js"],
      "env": {
        "DB_URL": "${DATABASE_URL}"
      }
    }
  }
}

Environment variable expansion in MCP configuration (as above) avoids hardcoded secrets. The exam tests this pattern in security-adjacent scenarios.

What security topics appear in CCDV-F for Claude Code users?

Domain 7 (Security and Safety, 8.1%) has grown in importance as Claude Code has become a production tool with file-write and shell-execution capabilities. Three concepts appear repeatedly in Claude Code scenarios.

First, prompt injection. A coding agent that fetches content from external sources before acting on it is vulnerable to injected instructions hidden inside that content. Exam items ask you to identify the injection vector and the appropriate mitigation.

Second, blast-radius reduction. The principle is that a tool should request only the permissions it needs. A file-read tool should not also have write access; a shell command tool scoped to a single directory should not have system-wide execution rights. Items present an over-permissioned tool and ask what the minimal correct configuration is.

Third, safe tool use in agentic contexts. When Claude Code drives an agentic loop with the ability to delete files or push code, irreversibility is the key consideration. The exam rewards pausing for human confirmation before actions that cannot be undone.

A fourth pattern worth knowing is the distinction between a tool error and a valid empty result. A security-focused MCP server that fails to connect to a permission service should return an error, not an empty permit list. The exam tests this in scenarios where a silently failing tool produces dangerous downstream behaviour.

How do prompt and context engineering apply to Claude Code?

Domain 6 (Prompt and Context Engineering, 11.0%) overlaps with Domain 3 in an important way: CLAUDE.md files are both configuration documents and prompt engineering artefacts. A well-structured CLAUDE.md shapes Claude Code's behaviour across every interaction in a repository. A poorly written one creates conflicting instructions that the exam is designed to surface.

Prompt Engineering and Structured Output covers the techniques that apply here: explicit role definitions, few-shot examples inside CLAUDE.md, and XML-style delimiters to separate instruction blocks from reference content. The exam tests whether you can diagnose a CLAUDE.md that produces inconsistent behaviour and identify which section is the cause.

Context management under Domain 6 also appears in scenarios about long-running Claude Code sessions. As a session accumulates tool results and conversation history, the effective context shrinks. Items ask how to address this: options typically include summary injection, session forking, or trimming tool results. The exam rewards answers that preserve task continuity without discarding information that is still load-bearing.

How does CCDV-F compare to CCAR-F on format?

The CCDV-F exam has 53 items and a 120-minute time limit, scored 100 to 1000 with a passing mark of 720. Unlike the Claude Certified Architect, Foundations exam (CCAR-F), the developer track has no scenario bank. CCAR-F draws four scenarios at random from a bank of six per sitting; CCDV-F items are written directly against domain skills, so every sitting covers the same coverage map.

Both exams are delivered online-proctored or at a Pearson VUE test centre and cost $125 per attempt.

How should developers sequence their CCDV-F study?

The domain weights suggest a clear priority order: spend roughly one-third of preparation time on Domain 2 (Applications and Integration), then split the remainder across Domains 1 and 5 before filling in the smaller domains. Domain 3 (Claude Code) deserves focused but brief attention: understand the configuration hierarchy, hooks, and MCP integration, then move on.

Our adaptive engine tracks per-domain mastery using Bayesian Knowledge Tracing with a 0.90 mastery threshold. When Domain 3 concepts appear in practice questions, the engine surfaces them in the context of the larger domains they enable, which mirrors how the real exam scenarios are constructed.

The 53 questions at 120 minutes gives you just under 2.3 minutes per item. Scenario-based items tend to run longer than a single-fact question, so practising timed sets under real conditions is the most direct preparation. Our CCDV-F practice exams present 53 timed questions scored on the 100-to-1000 scale with full domain breakdowns after each sitting. Archie provides Socratic hints when you are stuck, guiding you toward the reasoning the exam tests without giving the answer directly.

AI Skill Certs is an independent prep platform, not affiliated with or endorsed by Anthropic.