Claude Certified Developer – Foundations: Certification Overview and Developer Skills

Claude Certified Developer – Foundations validates a developer's foundational ability to design, integrate, operate, evaluate, optimize, and secure production-oriented applications, agents, and workflows built with Claude. It is aimed primarily at AI and machine learning engineers, technical leads, and senior software engineers. Its scope is organized into eight domains and 25 named skills that form a practical route from requirements and API integration through agents, prompting, testing, security, tools, and Model Context Protocol (MCP) systems.

The best way to navigate that scope is as a connected engineering life cycle, not as eight isolated study lists. Start with requirements and application boundaries, establish reliable Claude API and Claude Code practices, make explicit model and context decisions, then add evaluation, security, tools, and MCP integration. The official exam guide fixes the blueprint at version 1.0, effective July 2026; current product documentation governs implementation details that can change after that date.

What the CCDV-F Credential Represents

Anthropic announced Claude Certified Developer – Foundations as a foundational, role-based credential for people who build applications with Claude. The credential is active as of the verification date, and the current Anthropic Partner Certifications catalog provides the registration context. The certification and exam share the official name Claude Certified Developer – Foundations, while CCDV-F is the exam code.

The credential's organizing idea is production responsibility. A qualified developer must understand more than how to send a prompt and read a response. The blueprint connects software engineering fundamentals with probabilistic model behavior, operational controls, security boundaries, and external capabilities. In practice, that means being able to reason about the whole system around a Claude model:

requirements, interfaces, data boundaries, and ownership;
Claude API, Claude SDK, and Claude Code behavior;
workflows, agents, tools, and MCP integrations;
prompts, context, structured output, and model selection;
evaluation, error isolation, deployment controls, and secret management.

This is a foundational credential, but “foundational” does not mean introductory programming. The guide recommends approximately one to five years of software engineering experience and at least six months of experience using Claude or a comparable large language model. Candidates benefit from working knowledge of Python or TypeScript, Representational State Transfer (REST) APIs, JavaScript Object Notation (JSON), asynchronous programming, command-line tools, version control, agents, and context engineering.

Certification Baseline and Time-Sensitive Facts

The blueprint baseline is the CCDV-F Exam Guide v1.0, effective July 2026. At the 2026-08-28 verification date, the guide describes 53 multiple-choice and multiple-response items, a 120-minute appointment, and a scaled passing score of 720 on a 100–1000 scale. The program materials describe proctored online and test-center delivery, a USD 125 fee, and a credential validity period of 12 months. These delivery, price, eligibility, scoring, and validity details are program facts that can change, so candidates should verify them in the current certification FAQ before registering.

No mandatory prerequisite is stated. Recommended experience is preparation guidance rather than an eligibility requirement. The official preparation path can help candidates locate current training, but the blueprint should remain the source of truth for domain scope.

The exam version and the product version must also be kept separate. Domain names, skill names, and weights belong to the July 2026 guide. Claude Platform, Claude API, Claude SDKs, Claude Agent SDK, Claude Code, model availability, pricing, limits, and feature status are living product surfaces. Study should therefore pair the fixed blueprint with current first-party product documentation rather than treating a dated exam guide as an implementation manual.

The Eight-Domain Developer Skill Map

The eight domains describe one end-to-end developer role. The weights indicate the exam blueprint's emphasis; they are not a recommended allocation of engineering effort or a guarantee about any individual assessment.

Domain	Weight	Named skills	Production-oriented interpretation
Agents and Workflows	14.7%	Agent Architecture; Agent Construction with Claude; Agent Patterns and Frameworks	Choose an appropriate level of autonomy, construct bounded agent behavior, and understand common orchestration patterns.
Applications and Integration	33.1%	Understanding Requirements; Systems Life Cycle; Claude API Mechanics; Software Engineering Foundations; Claude Application Design; Configuration Management	Turn a business need into a maintainable Claude application with explicit interfaces, configuration, lifecycle, and operating constraints.
Claude Code	3.1%	Claude Code Operation	Use Claude Code's instruction, configuration, extension, session, and execution surfaces deliberately.
Eval, Testing, and Debugging	2.6%	Debugging and Error Handling	Separate model-quality problems from application, API, and tool failures, then choose an evidence-based recovery path.
Model Selection and Optimization	16.8%	LLM Fundamentals; Technical Fundamentals; Model Selection and Tradeoffs; Cost and Token Management	Select models and inference controls with explicit quality, latency, compatibility, token, and cost tradeoffs.
Prompt and Context Engineering	11.0%	Context Engineering; Prompt Engineering; Output Handling	Construct useful instructions and context while controlling drift, bloat, response contracts, and downstream validation.
Security and Safety	8.1%	AI Application Security; Guardrails and Safe Deployment; Claude Hooks; Identity, Secrets, and Key Management	Protect data and actions through layered controls, least privilege, approvals, and secure credential handling.
Tools and MCPs	10.6%	Tool Implementation; MCP Server Development; Agentic Customization	Expose external capabilities through focused tools and interoperable MCP components while preserving user control and security boundaries.

Together, these rows account for all 25 named skills in the public blueprint. They also reveal why Applications and Integration has the largest weight: every higher-level feature still depends on requirements, sound software engineering, stable interfaces, configuration control, and lifecycle ownership.

How the Domains Connect in Real Development

Establish the system before increasing autonomy

Applications and Integration provides the base layer. Understanding Requirements and Systems Life Cycle turn a proposed use case into functional, infrastructure, integration, reliability, security, and operational requirements. Software Engineering Foundations supplies the REST, JSON, asynchronous programming, version-control, code-review, and refactoring practices needed to maintain the result. Claude API Mechanics, Claude Application Design, and Configuration Management then place Claude-specific interfaces and behavior inside that engineering system.

Agents and Workflows builds on that base. Agent Architecture asks whether a deterministic workflow or a more autonomous agent is justified. Agent Construction with Claude covers the implementation approach, while Agent Patterns and Frameworks covers recurring designs such as tool-use loops, supervisors, subagents, memory, and context management. At overview level, the governing principle is simple: increase autonomy only when the task benefits from flexible model-directed decisions and the surrounding controls can manage the resulting risk.

Treat developer tools and runtime applications as distinct surfaces

Claude Code Operation concerns the coding agent used in a developer workflow. It includes instruction and memory hierarchy, settings, Skills, commands, agents, sessions, headless use, streaming behavior, and related extension surfaces. Claude Code should not be conflated with an application calling the Claude API, and neither should be treated as interchangeable with Claude Desktop or claude.ai. A developer needs to identify the specific surface before reasoning about configuration, data, permissions, or behavior.

Technical Fundamentals reinforces this distinction by connecting SDK abstractions to underlying REST APIs and transport behavior. The objective is not to memorize one library call. It is to understand which layer owns authentication, serialization, streaming, retries, state, and error handling so defects can be isolated correctly.

Make model behavior an explicit engineering variable

Model Selection and Optimization begins with Large Language Model (LLM) Fundamentals: tokens, context, sampling, non-determinism, and next-token generation. Model Selection and Tradeoffs then applies those fundamentals to choices among the Claude Opus, Claude Sonnet, and Claude Haiku families without assuming that the current catalog or model identifiers will remain fixed. Cost and Token Management adds workload economics, token accounting, and caching considerations.

Prompt and Context Engineering controls what the model receives and how the application consumes what it returns. Prompt Engineering covers clear instructions, roles, examples, constraints, iteration, and delimiting untrusted input. Context Engineering covers context-window pressure, drift, bloat, pruning, compaction, isolation, and the boundary between active context and durable memory. Output Handling completes the loop by requiring schemas where useful, validation against application contracts, defensive parsing, and skepticism toward fluent but unverified output.

Build feedback, safety, and interoperability into the design

Eval, Testing, and Debugging is small by blueprint weight but central to production quality. Debugging and Error Handling asks developers to classify failures, inspect traces, select recovery strategies, and distinguish weak model output from integration or tool defects. Evaluation is therefore not a final checkpoint; it is the feedback mechanism for requirements, prompts, model choices, context policies, and agent behavior.

Security and Safety supplies the constraints under which every other domain operates. AI Application Security covers privacy, prompt injection, jailbreaks, untrusted input, data leakage, and personally identifiable information. Guardrails and Safe Deployment covers layered policy, access control, and least privilege. Claude Hooks covers deterministic gates around sensitive actions. Identity, Secrets, and Key Management covers credentials, authentication, authorization, approvals, and monitoring. Model instructions alone are never a substitute for application-enforced controls.

Tools and MCPs extend a Claude system beyond model generation. Tool Implementation covers focused descriptions and schemas, execution loops, error handling, approval points, and the distinction between client and server tools. MCP Server Development covers hosts, clients, servers, resources, tools, prompts, transports, and authorization. Agentic Customization asks where a reusable capability belongs: a built-in or custom tool, a Skill, a plugin, or an MCP server. The current normative MCP baseline for this series is specification revision 2026-07-28; earlier behavior belongs only in explicitly labeled compatibility context.

A Practical Learning Sequence

A useful study sequence follows dependencies rather than descending domain weight alone:

Translate a real application idea into testable requirements, boundaries, and lifecycle responsibilities.
Trace a basic Claude API request through authentication, serialization, model response, validation, and application handling.
Compare a deterministic workflow with an agent and identify where tools, approvals, and subagents change the risk model.
Document model, prompt, context, configuration, token, and cost choices as versioned engineering decisions.
Define evaluations and traces that can distinguish model behavior from application, API, and tool failures.
Add identity, secret, data, permission, sandbox, and human-approval controls before granting broader capabilities.
Map reusable external capabilities to focused tools or MCP primitives with explicit ownership and authorization.

This sequence deliberately alternates concepts with system decisions. Reading documentation is necessary, but production understanding improves when each concept is applied to a small, observable application. A useful practice project might include one constrained API integration, a structured response contract, a small evaluation set, one low-risk tool, and documented security boundaries. It should not attempt to reproduce assessment items.

Common Scope and Preparation Mistakes

Studying product features as disconnected facts

Feature recall does not establish whether a developer can select the right boundary. Connect each feature to a requirement, owner, failure mode, evaluation, and control. For example, tool use is simultaneously an API interaction, an agent pattern, an output-handling problem, and a security boundary.

Treating blueprint weights as a complete priority model

A lower-weight domain can govern the safety or reliability of a higher-weight implementation. Debugging, hooks, and secret management deserve hands-on practice even though their individual blueprint weights are smaller than Applications and Integration.

Freezing living product behavior to the exam-guide date

The exam guide establishes scope, but current documentation establishes current behavior. Recheck model IDs, supported controls, prices, limits, feature availability, SDK surfaces, and beta or research-preview status before implementing or publishing advice.

Confusing surface names and responsibility boundaries

“Claude” may refer to a model, hosted user experience, API, or developer tool. Use the exact surface name—such as Claude API, Claude Code, Claude Agent SDK, Claude Desktop, or claude.ai—when behavior differs. Likewise, distinguish model-selected tools from application-executed functions and MCP resources from MCP tools.

Replacing engineering practice with assessment speculation

The safest and most durable preparation method is to learn the published domains through documentation and implementation. Reconstructed questions, memorized items, answer keys, and claims of guaranteed outcomes are outside the credential's legitimate learning path.

Where to Continue

The next useful step is to convert the domain map into system responsibilities. Turning Claude Application Requirements into a Systems Life Cycle develops that foundation by showing how business needs become testable requirements, interfaces, ownership, review points, and change controls.

When model and workload economics become the immediate concern, Claude Model Selection, Thinking, Token, and Cost Tradeoffs provides the related decision framework. The broader series then deepens API integration, agents, Claude Code, prompting, context, evaluation, security, tools, and MCP without changing the certification baseline established here.

Conclusion

Claude Certified Developer – Foundations validates a connected developer skill set: define the system, integrate Claude responsibly, choose models and context deliberately, evaluate behavior, secure actions and data, and extend the application through tools and MCP with clear control boundaries. Its eight domains and 25 named skills are most useful when treated as stages and cross-cutting responsibilities in one production life cycle.

For candidates, the practical goal is not merely to recognize terminology. It is to explain why a design choice fits a requirement, how it will be tested and operated, what can fail, and which control owns the risk. That approach serves both the public CCDV-F blueprint and day-to-day Claude application engineering.