Claude Certified Developer Foundations (CCDV-F) Certification: Complete Guide [2026]

Anthropic's Claude Certified Developer - Foundations (CCDV-F) is the developer credential in the four-certification program Anthropic announced on July 23, 2026, alongside the Associate-level CCAO-F and the architect-track CCA-F and CCAR-P. CCDV-F certifies the engineer who builds applications on Claude: someone fluent in the Claude API and its client SDKs, the Claude Agent SDK, Claude Code, and the Model Context Protocol, who can pick the right model for a workload, engineer prompts and context deliberately, and ship systems with security and evaluation built in. The exam asks 53 scored questions in 120 minutes across eight domains, with a full third sitting in a single domain, Applications and Integration, which tells you what Anthropic believes a Claude developer does all day. This guide covers all eight domains in depth, the scoring model, a four-week preparation path, and the judgment patterns that decide whether you pass.

Why CCDV-F Matters in 2026

Building with large language models moved from a niche specialty to a mainstream engineering job during 2025 and 2026, and hiring managers have no reliable way to tell an engineer who has shipped an LLM-backed feature from one who has followed a tutorial. CCDV-F makes that distinction verifiable for the Claude ecosystem.

A Credential for the Builder, Signed by the Vendor

Plenty of engineers can call an API. Far fewer can explain why their pipeline should run on the Batch API instead of real-time calls, why their agent needs a hook instead of another prompt instruction, or why their production app broke when a model alias silently resolved to a newer version. CCDV-F is Anthropic's own definition of what a competent Claude developer knows, drawn from the surfaces developers touch daily: the Messages API, the client SDKs, the Claude Agent SDK, Claude Code, and the Model Context Protocol (MCP), the open protocol that standardizes how models discover and call external tools and data sources. The questions come from the people who build the platform, which is what gives the credential its signal.

The Partner Ecosystem Connection

Registration runs through the Anthropic Partner Academy, and sitting the exam requires membership in the Claude Partner Network, which is free to join at claude.com/partners. Consulting firms, system integrators, and product teams inside the partner ecosystem need a way to distinguish their Claude-capable engineers, and CCDV-F is becoming the marker for implementation roles the same way CCAR-P marks the architect track. If you work for a partner organization, or want to, the credential maps directly to billable delivery work.

What CCDV-F Proves About You

Passing signals several concrete things to employers:

1. API fluency: You can drive the Messages API correctly, including tool use, streaming, vision, extended thinking, prompt caching, and batch processing, and you know when each earns its place.
2. Model judgment: You choose between Opus, Sonnet, and Haiku on capability, cost, and latency evidence instead of defaulting to the strongest model.
3. Agent literacy: You know when a problem justifies an agent, how to build one with the Agent SDK, and how to keep it controllable with hooks and context isolation.
4. Production discipline: You version prompts, pin models, manage configuration, and design security and evaluation into the system from the first commit.
5. Tooling depth: You can extend Claude through custom tools, Skills, and MCP servers, and you can defend the choice between them.

Who Should Take CCDV-F (and Who Should Choose a Different Exam)

CCDV-F targets working software engineers:

• Backend and full-stack developers adding Claude-powered features to existing products, from summarization endpoints to support copilots.
• AI engineers whose day job is prompts, evals, agents, and integrations on Claude or a comparable LLM platform.
• Platform and developer-experience engineers rolling out Claude Code and shared tooling across teams.
• Consultants and freelancers who want a vendor-backed way to claim Claude implementation skill on proposals.

Anthropic publishes no formal prerequisites, but the recommended profile is 1 to 5 years of software engineering experience plus 6 or more months of hands-on work with Claude or comparable LLM systems, working fluency in Python and/or TypeScript, and comfort with REST APIs and the command line. The scenarios read like code review comments and production incidents rather than textbook definitions.

If you are deciding between tracks, the split is clean. CCDV-F centers the application developer's daily surface: API mechanics, SDKs, agents, tools, and Claude Code. The Claude Certified Architect - Foundations (CCA-F) exam climbs one level up toward system design, and CCAR-P above it covers the full solution lifecycle including governance and stakeholder work; our CCDV-F vs CCA-F comparison walks through the decision, and the CCA-F complete guide covers the architect exam. Non-technical colleagues who use the claude.ai product rather than the API belong in the $99 Associate exam instead.

CCDV-F Exam Overview

The format shapes how you should prepare, so start with the structure.

Format and Structure

The exam presents 53 questions in 120 minutes, and every question is scored. That works out to roughly 2.3 minutes per question, a generous budget that hints at question style: expect scenario items that take real reading time. Question formats mix single-answer multiple choice with multiple-response items ("Select TWO" or "Select THREE"), which make up roughly a quarter of the exam. Delivery is proctored through Pearson VUE, either at a physical test center or online with identity verification, and the exam is English only. Passing candidates receive a digital badge through Credly by Pearson.

Scoring

CCDV-F uses scaled scoring: your raw correct-answer count is converted onto a common 100-to-1000 scale that accounts for difficulty differences between exam forms, and 720 is the passing bar. Because of the scaling, 720 does not translate to a fixed percentage of questions; treat 80% or better on realistic practice tests as the working target. Your score report shows percent-correct per domain, a useful diagnostic if you need a retake. With all 53 questions scored and no experimental items, multiple-response questions are the largest scoring risk, since a "Select TWO" item usually requires both selections correct for credit.

What the Questions Feel Like

Expect developer scenarios rather than trivia. A typical item describes a system (a support bot resending a 4,000-token policy preamble on every call, an agent with two overlapping search tools, a nightly pipeline blowing its budget on the strongest model) and asks for the best next move. The wrong answers are usually real techniques applied in the wrong situation, so the exam is really testing whether you recognize which constraint dominates: latency, cost, correctness, or security.

The Eight Exam Domains (Detailed)

The blueprint spans eight domains with weights from 33% down to 3%. Applications and Integration plus Model Selection and Optimization carry half the exam between them, and your study plan should be weighted the same way. For an even deeper treatment with worked scenarios per domain, see the CCDV-F exam domains complete breakdown.

Domain 1: Applications and Integration (33%)

At a third of the exam, roughly 17 to 18 questions, this domain alone can pass or fail you, and it covers the mechanics of actually building on Claude. The foundation is the Messages API. You should know the anatomy of a request (system prompt, the messages array of alternating user and assistant turns, max_tokens and sampling parameters) and, critically, that the API is stateless: the model remembers nothing between calls, so your application owns conversation state and resends the relevant history on every request, a fact that drives everything from cost growth in long chats to context-window overflow.

Layered on top are the API capabilities you must deploy in the right situations. Streaming delivers tokens as the model generates them, which fixes perceived latency in interactive products even though total generation time is unchanged. Vision accepts images as input for document and screenshot understanding. Extended thinking lets the model reason through intermediate steps before answering, buying accuracy on hard problems at the price of tokens and latency. Prompt caching reuses a stable prompt prefix across calls so repeated tokens are processed at reduced cost and latency, and the exam loves the scenario where a system resends an identical multi-thousand-token preamble on every request. The batch-versus-real-time decision is the domain's most reliable question pattern: the Batch API processes large asynchronous workloads at a substantial discount, so when a scenario has volume and no interactivity requirement (nightly classification, bulk extraction, offline evals), batch is the answer, and when a user is waiting, real-time wins regardless of the discount.

The rest of the domain is production discipline. Requirements questions test whether you translate a product ask into API capabilities before writing code. Lifecycle questions cover carrying an app from prototype to production: monitoring, iteration, and managing change. Configuration management gets specific attention: CLAUDE.md files that carry project instructions, settings.json for tool and permission configuration, model pinning (referencing an exact model version in production rather than an alias, so an alias update never silently changes behavior under you), and prompt versioning, which means treating prompts like code with review, versioning, and evaluation gates before rollout. A scenario describing a production app whose outputs shifted overnight with no deploy is pointing you at an unpinned model alias, and the exam expects you to spot it.

Domain 2: Model Selection and Optimization (17%)

The second-heaviest domain, around 9 questions, starts with the fundamentals that everything else in the exam quietly depends on. Tokens are the subword units a model reads and writes, and the unit you pay by, so token counts drive both cost and capacity. The context window is the maximum number of tokens the model can consider in a single request, covering the system prompt, conversation history, retrieved documents, tool results, and the response itself. Sampling explains why LLMs are non-deterministic: the model produces a probability distribution over next tokens and samples from it, with temperature controlling how adventurous that sampling is. The exam's favorite trap is the belief that temperature 0 guarantees identical outputs; it reduces variation without eliminating it, so the correct fix for a design that depends on byte-identical responses is validation on the receiving end rather than a sampling setting.

Model selection questions give you a workload profile and ask which tier fits. The working heuristics: Haiku is the fast, inexpensive tier for high-volume, well-bounded tasks like classification, routing, and simple extraction; Sonnet is the balanced default for most production work; Opus is the deepest reasoning tier for complex synthesis, hard debugging, and high-stakes output where accuracy justifies cost. On top of tier choice sit the dials: fast mode when latency matters more than depth, extended thinking with configurable effort levels when the task rewards deliberate reasoning. The tested principle is proportionality in both directions, since routing every request to Opus with maximum thinking is as much an error as forcing Haiku onto a task that needs multi-step reasoning.

Cost questions get concrete. Given a volume, a token profile, and a budget, you should identify the optimization sequence: move over-served traffic to a cheaper tier, cache the stable prefix, trim bloated context, cap output length where appropriate, and batch whatever has no interactivity requirement. The exam rewards answers that pair every optimization with an evaluation check, because cutting cost while silently cutting quality is the failure mode the domain is really about.

Domain 3: Agents and Workflows (15%)

Domain 3 opens with the decision the whole agent ecosystem hinges on. A workflow runs Claude through predetermined steps in a fixed pipeline, while an agent lets Claude decide its own next steps and tool calls dynamically inside a loop. Workflows win on cost, latency, and auditability whenever the steps can be enumerated in advance, and agents earn their complexity only when the path genuinely cannot be scripted, such as open-ended research, debugging, or tasks whose shape depends on what each step discovers. The exam presents processes with fixed, well-defined steps and rewards candidates who resist the agent, since an agent there adds nondeterminism and cost without adding capability.

When an agent is justified, the domain tests how you structure and control it. Manager-subagent hierarchies have an orchestrator decompose work and delegate to specialized workers, each with its own isolated context window, which keeps any one context lean and prevents one subtask's noise from degrading another's output. The Claude Agent SDK is Anthropic's framework for building these systems on the same agent engine that powers Claude Code, and you should understand its construction model: the loop of model calls, tool execution, and context management, plus hooks, which are deterministic scripts that run at defined points in the loop to enforce rules no matter what the model decides. Deployment questions weigh managed offerings (fast to ship, less operational burden) against self-hosting (more control, more responsibility), and framework questions name Strands, LangGraph, and PydanticAI. The exam wants selection criteria (state management needs, control granularity, ecosystem fit, team familiarity) rather than loyalty to any one tool.

Domain 4: Prompt and Context Engineering (11%)

This domain treats the context window as a scarce resource under active management. Long-running sessions accumulate history, tool results, and retrieved documents until quality degrades in two ways the exam expects you to name: bloat, where accumulated tokens raise cost and crowd out relevant information, and drift, where the model gradually loses hold of early instructions and established facts. The tested remedies are pruning (dropping content that no longer earns its tokens), compaction (summarizing older conversation into a compact form that preserves decisions and key facts while releasing the raw transcript), and context isolation, where independent subtasks run in separate subagent contexts so their intermediate noise never pollutes the main thread.

The prompting half of the domain is about making outputs dependable. Instruction clarity questions reward specific, positively framed, unambiguous instructions over vague ones, and few-shot prompting (adding worked input-output examples to establish a pattern) appears as the standard upgrade when instructions alone fail on edge cases, cheaper than fine-tuning and faster than trial-and-error rewording. Structured output patterns cover getting reliably machine-readable responses, and defensive parsing is the habit the exam checks hardest: real models occasionally wrap JSON in prose, omit fields, or invent enum values, so production code validates against a schema, handles deviations, and retries with the error fed back, rather than calling json.parse on raw model text and hoping.

Domain 5: Tools and MCPs (10%)

Tool use, also called function calling, is how Claude acts on the world: you declare tools with a name, an input schema, and a description, the model decides when to call one and with what arguments, your code executes it, and the result returns to the model. The emphasis lands on the part developers underestimate: tool descriptions are prompts. The model routes between tools entirely on names, descriptions, and schemas, so two tools with overlapping descriptions produce intermittent misrouting, and the fix is sharper, mutually exclusive descriptions that state when to use each tool and when to use the other one. Execution location matters too: client-side tools run in your application where you control the environment and credentials, while server-side tools run on Anthropic's side; scenarios about private data that must stay inside a network boundary point at client-side execution.

The MCP half covers building servers, since MCP standardizes integrations so any compliant client can use them. You should know the three primitives a server can expose (resources for readable data, tools for callable actions, prompts for reusable templates) and the transports (stdio for a locally spawned server, network sockets for remote ones). The domain closes with the decision matrix the exam quizzes directly: built-in tools when the platform already provides the capability, a custom tool for a single application's bespoke need, a Skill for packaged instructions and procedures rather than executable integration, and an MCP server when the capability must be reusable and discoverable across multiple clients and teams. Distractors always propose a real mechanism at the wrong scope.

Domain 6: Security and Safety (8%)

The security domain is small but dense, and its center is prompt injection: an attack where adversarial instructions embedded in content the model processes (a scraped web page, a retrieved document, a user upload) hijack the model's behavior. The tested defense posture treats all external content as untrusted input and layers controls, because no single layer is reliable: system-prompt hardening shapes behavior, input and output filtering catches known patterns, and permission boundaries limit what a hijacked agent can actually do. Jailbreak questions cover users trying to talk the model out of its constraints, and data-leakage questions cover personally identifiable information (PII) flowing into prompts, logs, and third-party tools, where the expected answers involve redaction before model calls and discipline about what gets logged.

Authentication and authorization questions apply standard security thinking to agent systems: agents and tools should authenticate as constrained identities with least-privilege scopes, and an agent that inherits the full credentials of whoever launched it is a finding, since the model can be manipulated into exercising permissions its user never intended. Claude Hooks appear as the deterministic guardrail: because a hook is code that runs at fixed points in the loop, it can block a destructive command category outright, providing a hard guarantee that no amount of prompt wording can deliver. Key management rounds out the domain: API keys live server-side in environment variables or a secret manager, never in client-side code or prompts, and rotation should be routine.

Domain 7: Claude Code (3%)

At roughly two questions, this domain rewards anyone who uses Claude Code, Anthropic's command-line tool for AI-assisted development, as a daily driver. The customization surface is the likely target: Rules for persistent behavioral constraints, Skills for packaged capabilities, Commands for reusable slash-command workflows, Agents for delegated subtasks, and Agent Memory for state that persists across sessions. Expect a question that describes a need and asks which mechanism fits, such as turning a repeated multi-step review process into a single invocation, which is a Command.

Configuration knowledge matters too: CLAUDE.md files carry project instructions in a hierarchy where more specific scopes layer over broader ones, which is why shared team standards belong in project-level files committed to version control rather than in one developer's personal setup, and settings.json governs permissions and tooling. Headless mode, running Claude Code non-interactively inside scripts and CI pipelines, completes the picture.

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

The final domain is small on the blueprint and large in real life. Its core skill is failure attribution: when an LLM system misbehaves, the cause lives either in the integration layer (a failing tool, a malformed request, missing context, a rate limit) or in the model's output (a hallucination, an instruction misread, a task beyond the selected tier), and each attribution implies a different fix. An assistant giving confident wrong answers after a tool returned stale data has an integration problem, and rewriting the prompt wastes the cycle.

Trace analysis is the diagnostic method the exam names: in multi-step systems the symptom often surfaces several steps downstream of the cause, so you follow the recorded sequence of calls, tool results, and intermediate outputs to the first point where reality diverged from expectation. Recovery questions cover the standard patterns, including retries with backoff for transient API errors, validation with corrective re-prompting for malformed output, and fallback behavior when a dependency stays down.

Your 4-Week Study Path

Candidates matching the recommended profile (a working engineer with some months of Claude experience) typically prepare in about four weeks of consistent part-time study. If the Agent SDK or MCP is new territory, budget extra hands-on time in week two rather than more reading. The full week-by-week schedule with daily tasks lives in our 4-week CCDV-F study plan; the outline below shows the shape of it.

The pattern that matters most: build during the middle weeks instead of only reading. CCDV-F questions test judgment formed at a keyboard, and one afternoon spent debugging your own MCP server or watching a hook block a bad command teaches more than a second pass through any document.

Preparation Resources

If you want the condensed version of this guide in video form first, our CCDV-F walkthrough covers the exam structure, the domain weights, and the preparation path in one sitting.

CCDV-F preparation draws on four resource categories, and each covers ground the others cannot.

Anthropic Partner Academy hosts the official developer course and the exam registration itself. The material defines the vocabulary the exam uses and is the closest thing to an official study guide, so treat it as required.

Official documentation at docs.anthropic.com is where course-level understanding becomes precision: the Messages API, tool use, streaming, vision, extended thinking, prompt caching, the Batch API, the Agent SDK, Claude Code, and MCP all have authoritative references, and exam distractors are written against these pages.

Practice tests convert knowledge into exam readiness. Preporato's CCDV-F practice tests give you 6 full-length, 53-question exams built on the 8-domain blueprint, with roughly a quarter multiple-response items to match the real format and an explanation for every answer, plus a 500-card flashcard deck for the terminology layer. They are available through Preporato Pro or the single-cert bundle, and they are the fastest way to find the domains where your judgment is still soft.

Hands-on building is the resource candidates undervalue most. The exam's scenario questions are compressed versions of real debugging sessions, and having lived a few of them is the difference between recognizing an answer and guessing at one.

Exam-Day Strategy (Condensed)

The full playbook, including question-type tactics and worked eliminations, is in How to Pass CCDV-F on Your First Attempt. The short version:

• Budget time by question type. With 53 questions in 120 minutes you have about 2.3 minutes each, so bank time on recall items and let scenario and multiple-response questions have three minutes when they need it. Flag and move on rather than stalling.
• Treat multiple-response items as independent true/false judgments. For a "Select TWO," evaluate each option on its own merits against the scenario instead of hunting for a pair that feels related. Disciplined elimination beats pattern-matching.
• Read for the dominant constraint. Most scenarios embed one deciding fact (a user waiting versus a nightly job, a budget cap, data that cannot leave a network, output that feeds a parser) that eliminates half the options before you weigh the rest.
• Prefer the proportionate answer. Across all eight domains the exam rewards the cheapest adequate model, the simplest sufficient architecture, and the lightest mechanism that fully meets the requirement. Over-engineered options are the standard trap for experienced candidates.
• Keep a keyword map for final review. Our CCDV-F cheat sheet condenses the per-domain triggers and decision rules into a last-week reference.

Frequently Asked Questions

Conclusion

Claude Certified Developer - Foundations certifies the job that emerged as Claude became a mainstream application platform: the engineer who can drive the API precisely, choose models on evidence, build agents that stay controllable, extend the platform through tools and MCP, and wrap the whole thing in the security and debugging discipline production demands. Its eight domains map that job faithfully, with the weights concentrated where the daily work happens.

The exam is passable in four focused weeks for a working engineer, but it is honest about what it measures. Fifty-three all-scored questions, a 720 scaled passing bar, and a steady stream of scenario and multiple-response items mean that reading alone leaves gaps that only building and realistic practice close.

Ready to find out where you stand? Preporato's CCDV-F practice tests include 6 full-length exams built on the exact 8-domain blueprint, with explanations for every answer and a 500-card flashcard deck alongside, available through Preporato Pro or the practice bundle. Take one cold, let the results set your study priorities, and follow the 4-week study plan from there.