CCDV-F exam at a glance
Claude Certified Developer – Foundations · Foundations level
| Exam code | CCDV-F |
|---|---|
| Certification | Claude Certified Developer – Foundations |
| Level | Foundations |
| Number of questions | 53 |
| Duration | 120 minutes |
| Passing score | 720 on a scaled score of 100–1,000 |
| Question formats | Multiple choice and scenario-based multiple response |
| Delivery | Online proctored or at a Pearson test center |
| Exam cost | $125 USD before applicable partner-tier discounts |
| Languages | English |
| Certification validity | 12 months from the date earned |
| Prerequisites | No formal prerequisite |
For technical professionals who build, integrate, and ship production applications, agents, and workflows on the Claude platform.
Skills measured and their weighting
| Skill area | Weight |
|---|---|
| Applications and Integration | 33.1% |
| Model Selection and Optimization | 16.8% |
| Agents and Workflows | 14.7% |
| Prompt and Context Engineering | 11.0% |
| Tools and MCPs | 10.6% |
| Security and Safety | 8.1% |
| Claude Code | 3.1% |
| Eval, Testing, and Debugging | 2.6% |
Source: anthropic-partners.skilljar.com — official Claude Certified Developer – Foundations certification page. Figures were checked against Anthropic’s official certification documentation. Confirm current details there before booking.
The full bank covers every domain, with timed mode and per-domain scoring.
CCDV-F Practice Questions By Domains
8 domains covered1. Applications and Integration
7 free questions available
2. Prompt and Context Engineering
4 free questions available
3. Model Selection and Optimization
4 free questions available
4. Agents and Workflows
4 free questions available
5. Security and Safety
3 free questions available
6. Tools and MCPs
3 free questions available
7. Claude Code
3 free questions available
8. Eval, Testing, and Debugging
2 free questions available
Practice the full exam, not a sample
Unlock the full bank and practise every domain end to end.
Unlock all 82 questionsClaude Certified Developer – Foundations (CCDV-F) Practice Test
The Claude Certified Developer – Foundations practice test helps developers measure whether they can build reliable Claude-powered applications, agents, tools, and integrations—not merely send a basic prompt to an API. Strong preparation connects product knowledge with practical software decisions involving requirements, architecture, context, security, testing, cost, and deployment. You can Explore online practice exams by category while using this guide to organize your learning around Anthropic’s official CCDV-F domains.
Anthropic positions CCDV-F as the technical builder credential in its certification program. The official credential description says successful candidates can build, integrate, and ship production applications and agents using the Claude API, Claude Code, custom tools, and Model Context Protocol servers. This makes the certification relevant to developers who want to move beyond experimental prompts and understand how Claude applications behave when real users depend on them.
This guide explains the official domain structure in student-friendly language, identifies the skills a useful mock assessment should test, and provides a practical preparation framework. It does not contain copied, protected, or live certification questions. Use original exam-style practice alongside Anthropic’s current exam guide, preparation course, developer documentation, and hands-on projects.
What Is a CCDV-F Practice Test?
A CCDV-F practice test is a learning assessment aligned with the Claude Certified Developer – Foundations blueprint. It should test applied development judgment through short technical scenarios.
A useful question may ask you to:
- select an agent or workflow pattern for a requirement;
- use the Claude API or an SDK correctly;
- design streaming or asynchronous application behavior;
- define a tool schema that Claude can use reliably;
- manage context, memory, and long-running tasks;
- select a suitable model and control token costs;
- configure Claude Code for a development team;
- diagnose API, tool, or output failures;
- protect credentials and enforce authorization;
- build an MCP server with appropriate scope and controls.
Effective practice questions should include explanations for every option. The explanation should identify the requirement that controls the answer, show why the preferred approach works, and clarify why other choices are incomplete or unnecessarily risky.
Who Should Prepare for CCDV-F?
The certification is intended for hands-on developers building and shipping Claude-based applications. It is especially useful for:
- software developers working in Python or TypeScript;
- AI application developers;
- engineers integrating Claude through REST APIs or SDKs;
- developers building agent loops and tool-enabled workflows;
- teams using Claude Code in daily software work;
- engineers creating MCP servers;
- developers responsible for evaluation, security, cost, and production reliability.
You do not need to be an advanced machine-learning researcher. However, you should understand common software-engineering concepts, API requests and responses, command-line tools, configuration, source control, error handling, testing, and secure credential management. The exam focuses on building with Claude, so hands-on development is more useful than memorizing terminology alone.
Official CCDV-F Domains and Weightings
Anthropic’s CCDV-F blueprint contains eight domains. The published weights are unusually detailed and show that practical application development receives the greatest emphasis.
The percentages total 100%. Applications and Integration alone represent about one-third of the blueprint, so practice sets should give it noticeably more coverage than smaller areas such as Claude Code or debugging. Smaller does not mean optional: questions from every domain can influence your overall result.
Domain 1: Agents and Workflows (14.7%)
This domain focuses on systems that perform more than a single model call. You should understand when a defined workflow is enough, when an agent is justified, and how to keep agent behavior observable and controlled.
Compare workflows and agents
A workflow follows known steps. It is often easier to test, predict, and maintain. An agent chooses actions dynamically according to its goal, available tools, and intermediate results. Agents are helpful when the exact path cannot be fully defined in advance, but they introduce additional risk and complexity.
Do not select an agent merely because it sounds modern. Use the simplest pattern that meets the requirement. A fixed classification-and-routing process may need a workflow, while a research task that must choose sources and revise its plan may justify an agent.
Build a controlled agent loop
A basic loop gives the model a goal and available tools, receives a requested action, executes an approved tool, returns the result, and continues until a stopping condition is reached. A reliable implementation also needs:
- clear goals and boundaries;
- validated tool inputs;
- limits on steps, time, or spending;
- handling for failed tool calls;
- state management;
- human approval for sensitive actions;
- logging and traceability;
- a safe completion or cancellation path.
Use common patterns thoughtfully
Patterns may include routing, parallel work, sequential processing, evaluator-improver loops, and manager-worker designs. Each pattern has trade-offs. Parallel work can improve speed but complicates result combination. An evaluator loop may improve quality but increases cost and latency. Multi-agent designs should represent real separation of responsibilities, context, or permissions.
Practise failure scenarios
Good mock questions should include an agent that repeats actions, selects the wrong tool, loses state, exceeds a budget, or tries to complete a sensitive action without approval. The best answer usually improves the control at the correct layer instead of adding a vague instruction such as “be more careful.”
Domain 2: Applications and Integration (33.1%)
This is the largest CCDV-F domain. It covers how developers turn requirements into maintainable Claude applications and connect those applications to production systems.
Understand requirements before coding
Identify users, desired outcomes, input types, output requirements, integrations, security limits, quality expectations, latency needs, and operating cost. If an AI feature does not provide clear value, a normal deterministic component may be better.
A practice scenario may include an unclear request for “an intelligent assistant.” Before implementation, the developer should clarify what tasks it performs, what information it can access, what actions it may take, and how success will be measured.
Work with Claude API mechanics
You should understand the structure of requests and responses, authentication, roles, content blocks, model parameters, token limits, streaming, and error responses. Learn when an official SDK provides convenience and when direct REST interaction may be appropriate.
Production code should not assume every response is immediate or successful. Handle rate limits, timeouts, transient failures, malformed outputs, and network interruptions. Retrying can help with temporary failures, but retries should use limits and backoff so the application does not increase the problem.
Design for streaming and asynchronous work
Streaming can improve user experience by displaying output as it becomes available. The application must still handle interrupted streams, partial content, cancellation, and the final completion state.
Longer work may be better handled asynchronously. Users should receive a clear task status rather than hold an unreliable connection open. The design should define where progress, results, failures, and retries are stored.
Apply software-engineering foundations
Separate Claude-specific logic from business rules and external integrations. Use small components, clear interfaces, configuration outside source code, testable functions, structured logging, and version control.
Deterministic rules should remain deterministic. Do not ask a model to perform simple validation or authorization that ordinary code can enforce more reliably.
Manage the application lifecycle
Building the first demonstration is only one step. A production lifecycle includes discovery, design, implementation, evaluation, security review, deployment, monitoring, maintenance, and retirement. Model, prompt, tool, and data changes should follow controlled release practices.
Control configuration
Keep environment-specific values outside the code. Separate development, testing, and production settings. Validate configuration at startup and provide safe defaults only where they make sense. Credentials should use a secure secret-management method rather than source files.
After reviewing the largest domain, you can Prepare for another Claude certification and compare practice options across the Claude credential family.
Domain 3: Claude Code (3.1%)
Claude Code supports software work in a codebase, but effective use requires clear scope, review, and verification.
Use a disciplined working loop
A helpful approach is to explore the repository, plan the change, implement it, and verify the result. Ask Claude Code to identify relevant files and dependencies before making a broad change. For complex work, review the proposed plan before allowing edits.
Provide durable project guidance
Project instructions can describe commands, architecture, conventions, testing expectations, and areas that require caution. Keep them current and concise. Conflicting or outdated guidance can be worse than no guidance.
Control permissions
Developers should understand what actions Claude Code can take and when approval is required. High-impact or irreversible actions deserve stronger review. The model should not receive broad access simply for convenience.
Verify generated changes
Review diffs, run tests, apply linters or type checks, and confirm that the change meets the requirement. Claude Code accelerates development but does not remove developer accountability.
Domain 4: Eval, Testing, and Debugging (2.6%)
Although this is the smallest domain, evaluation and debugging affect every production application.
Separate failure types
When output is wrong, determine whether the cause is:
- an unclear requirement;
- a weak prompt;
- missing or excessive context;
- incorrect retrieval;
- a bad tool schema;
- application logic;
- an API or network failure;
- model limitations;
- invalid output handling.
Changing the model will not fix a broken authorization check or incorrect business rule.
Test at several levels
Use unit tests for deterministic helpers, contract tests for integrations, tool tests for schemas and execution, evaluation sets for model behavior, and end-to-end tests for the complete user flow.
Build representative evaluations
Include ordinary inputs, edge cases, known failures, ambiguous requests, and unsafe or unauthorized attempts. Define expected behavior before judging results.
Improve observability
Record request identifiers, latency, token usage, tool calls, errors, and relevant application decisions while protecting sensitive data. Structured information helps developers reproduce and diagnose failures.
Domain 5: Model Selection and Optimisation (16.8%)
This is the second-largest domain. It covers how language models behave, how applications call them, and how developers balance quality, speed, and cost.
Understand probabilistic behavior
Language models generate likely outputs rather than retrieving guaranteed truth. The same instruction can produce variations. Applications should use validation, grounding, deterministic constraints, or human review according to the risk of error.
Select models by workload
Consider task complexity, accuracy needs, latency, cost, context length, tool-use requirements, and expected volume. A demanding planning task and a high-volume extraction task may use different configurations.
Do not memorize a temporary model chart as your only preparation. Model families change. Learn the decision method and review current Anthropic documentation before the exam.
Manage tokens and context
Tokens affect context capacity, latency, and cost. Avoid repeatedly sending material that does not influence the answer. Use retrieval, summarization, state management, or caching when appropriate.
Apply caching and batching appropriately
Stable repeated content may benefit from prompt caching. Independent high-volume tasks may benefit from batch processing. Evaluate whether the workload can tolerate delayed results and whether the repeated prefix is stable enough to justify caching.
Optimize against a baseline
Measure quality, latency, token use, and cost before making changes. A cheaper configuration is not an improvement if task completion falls below the required level. Likewise, a small quality gain may not justify a large latency increase for an interactive feature.
Handle rate and capacity limits
Production applications should anticipate rate limits, use controlled concurrency, and apply suitable backoff. Queueing and workload shaping can prevent bursts from overwhelming the service.
Domain 6: Prompt and Context Engineering (11%)
This domain examines how developers provide instructions and information so Claude can perform reliably.
Write clear prompts
Define the task, inputs, expected output, constraints, and success criteria. Separate instructions from user-provided data so the application can handle both consistently.
Useful prompts may specify:
- role or responsibility where helpful;
- permitted sources or tools;
- output schema;
- rules for missing information;
- examples of correct format;
- boundaries and prohibited actions.
Manage context intentionally
Context engineering includes deciding what information Claude sees and when. Stable instructions, conversation history, retrieved knowledge, tool definitions, tool results, and working state all compete for attention and tokens.
Use progressive access when the full information set is large. Retrieve or load what is relevant to the current step rather than placing every possible document or tool definition in every request.
Handle structured outputs
If downstream code needs fields, request a clear schema and validate the result. Never assume that model-generated JSON or another format is automatically safe or complete. Check types, required properties, allowed values, and size limits before use.
Defend against instruction conflicts
External documents and tool outputs may contain text that looks like instructions. Treat untrusted content as data. Important authorization and security rules should be enforced by the application, not only stated in a prompt.
For broader study support, Discover learning tools for certification candidates while continuing to use Anthropic’s official guide and developer documentation as primary references.
Domain 7: Security and Safety (8.1%)
Claude applications introduce familiar software risks as well as risks related to untrusted instructions, powerful tools, and generated output.
Protect identity, secrets, and keys
Never embed API keys in public code or client-side applications. Use secure secret storage, rotate credentials, and grant the minimum permissions required. Associate user actions with the correct identity rather than allowing every request to operate under one broad service account.
Enforce authorization outside the model
Claude can help decide what action to request, but trusted code must decide whether that action is permitted. Validate every tool call and check the user’s authorization before reading data or performing a change.
Reduce prompt-injection risk
Assume external content may contain malicious instructions. Separate trusted instructions from untrusted data, restrict tools, validate actions, filter or isolate content where appropriate, and require approval for high-impact operations.
Use layered guardrails
Safety may include input checks, tool constraints, output validation, human review, monitoring, and incident response. A single prompt rule is not a complete security design.
Apply hooks responsibly
Hooks can automate deterministic checks or actions around development and agent workflows. Because they can execute powerful operations, review their source, scope, environment, failure behavior, and permissions.
Plan for safe failure
Decide what happens when validation, moderation, retrieval, or a tool is unavailable. For sensitive workflows, stopping or escalating may be safer than silently continuing.
Domain 8: Tools and MCPs (10.6%)
Tools let Claude interact with application capabilities, while Model Context Protocol provides a standard way to expose tools and resources.
Design usable tool schemas
Tool names and descriptions should clearly communicate purpose. Input schemas should use suitable types, required fields, descriptions, and constraints. Avoid overlapping tools that make selection unnecessarily difficult.
The application should validate inputs again before execution. A valid schema does not prove that the requested action is authorized or sensible.
Return useful tool results
Tool responses should provide the information Claude needs without unnecessary volume. Clearly distinguish success, failure, partial results, and retryable errors. Avoid returning sensitive fields that are not needed for the next step.
Build MCP servers with limited scope
An MCP server can expose tools, resources, and prompts. Keep its capabilities focused, document configuration, and use secure transport and authentication suitable for the deployment.
Understand scope and configuration
Configuration may apply at different levels, such as one project, one user, or a wider environment. Select a scope that supports collaboration without exposing credentials or tools more broadly than intended.
Secure tool access
Tool discovery does not equal permission. Enforce identity and authorization at execution time. High-impact tools may require confirmation, approval, or a separate restricted service.
Customize agents thoughtfully
Skills, commands, rules, subagents, and tool sets can make workflows reusable. Each addition should have a clear purpose. Too many overlapping capabilities can increase cost, confusion, and the chance of an incorrect action.
How to Use CCDV-F Practice Tests Effectively
Start with a mixed diagnostic assessment. Track results by domain rather than focusing only on a total score. The domain weights show that weak performance in Applications and Integration or Model Selection deserves significant attention.
Use this study cycle:
- Review one official objective area.
- Build or inspect a small working example.
- Answer a short practice set.
- Review every explanation.
- Record the reason for each mistake.
- Change the scenario and solve it again.
Classify mistakes with a simple table:
| Mistake type | Likely cause | Useful next action |
|---|---|---|
| API mistake | Request, response, streaming, or error behavior is unclear | Build a small API example and inspect raw responses |
| Design mistake | The pattern is too simple or too complex | Compare single calls, workflows, and agents |
| Context mistake | Claude received missing or noisy information | Map stable, retrieved, and step-specific context |
| Security mistake | The model was trusted to enforce access | Move authorization and validation into trusted code |
| Tool mistake | Schema, description, or execution behavior is weak | Redesign the tool contract and test edge cases |
| Optimisation mistake | Cost or speed changed without quality evidence | Establish a baseline and repeat evaluations |
After domain review, complete mixed timed sessions without documentation. Practise both multiple-choice and multiple-response questions. Read the requirement before the code or answer options, then identify the decisive constraint.
What You Get When You Prepare With Us
A useful CCDV-F preparation experience should help you connect technical concepts to working development decisions. It should provide:
- Official-domain alignment: Practice structured around all eight Anthropic blueprint domains.
- Weight-aware coverage: Extra focus on Applications and Integration, Model Selection, and Agents and Workflows.
- Original technical scenarios: Questions designed for learning without claiming to reproduce protected certification content.
- Clear explanations: Plain-language reasoning for the correct and incorrect options.
- Focused practice sets: Targeted review for APIs, agents, Claude Code, context, security, tools, and MCP.
- Mixed readiness assessments: Broader sessions that test several skills together.
- Progress awareness: Domain scores and error categories that identify where further study is needed.
- Practical learning: Guidance that encourages small builds, debugging, evaluation, and secure implementation.
The aim is to develop transferable skill. A candidate should be able to explain not only what to implement but why the design is reliable, secure, maintainable, and appropriate for the workload.
A Six-Week CCDV-F Study Plan
Week 1: API and application foundations
Build a small application using an official SDK or REST API. Review requests, responses, authentication, streaming, errors, retries, configuration, and logging.
Week 2: Agents and workflows
Compare direct model calls, fixed workflows, and agent loops. Implement a tool-using loop with step limits, failure handling, and approval for a sensitive action.
Week 3: Models, tokens, and performance
Study model-selection trade-offs, context limits, token use, caching, batching, concurrency, latency, and cost. Measure a small baseline before making improvements.
Week 4: Prompts, context, and structured output
Version prompts, create representative examples, manage retrieved context, and validate structured outputs. Test how the application handles missing or malicious input.
Week 5: Tools, MCP, and security
Design several clear tool schemas and build or inspect an MCP server. Review configuration scope, identity, secrets, authorization, prompt injection, guardrails, and hooks.
Week 6: Claude Code, evaluation, and mixed review
Use Claude Code on a controlled repository task, review every change, and run tests. Complete mixed practice assessments and revisit weak domains through changed scenarios.
Common CCDV-F Preparation Mistakes
Memorizing code without understanding behavior
SDK syntax may change. Understand request structure, streaming, tool calls, errors, and application responsibilities.
Building an agent when a workflow is enough
Unnecessary autonomy makes testing, security, and cost management harder. Select the simplest suitable pattern.
Relying on prompts for security
Prompts can guide behavior but cannot replace authentication, authorization, input validation, secret management, and restricted tool execution.
Ignoring the largest domain
Applications and Integration represents 33.1% of the blueprint. Give it enough study and hands-on time.
Testing only one successful example
Include edge cases, errors, missing data, unsafe requests, invalid tool inputs, and interrupted streams.
Treating MCP as automatic trust
MCP standardizes connections; it does not grant permission or guarantee that a tool is safe. Apply normal security controls.
Using outdated model information
Review current Anthropic documentation close to the exam. Learn selection principles rather than depending on an old model comparison.
Frequently Asked Questions
What does CCDV-F validate?
It validates foundational skills for building, integrating, and shipping production applications and agents with the Claude API, Claude Code, custom tools, and MCP servers.
Which domain is most important by weighting?
Applications and Integration is the largest at 33.1%. Model Selection and Optimisation is next at 16.8%, followed by Agents and Workflows at 14.7%.
Is CCDV-F suitable for nondevelopers?
It is designed for developers and engineers. Candidates should be comfortable with software development, APIs, command-line tools, and practical implementation.
Should I know Python or TypeScript?
The official audience profile commonly emphasizes developers comfortable with Python and/or TypeScript. More important than memorizing syntax is understanding application and API behavior.
Does the exam cover Claude Code?
Yes. Claude Code is an official domain, although its individual weighting is smaller than the application, model, or agent domains.
Is MCP included?
Yes. Tools and MCPs is a full domain worth 10.6%, covering tool implementation, MCP server development, and agentic customization.
Are practice questions enough?
No. Combine practice tests with the official Anthropic preparation course, developer documentation, and hands-on projects.
How should I prepare for multiple-response questions?
Evaluate every option independently against the scenario. Do not stop after finding one correct statement, and read how many selections are required.
How can I improve debugging skills?
Trace the request through application code, context assembly, the Claude API, tool selection, tool execution, and output validation. Use logs and identifiers to locate the failing layer.
How do I know when I am ready?
Look for consistent domain results and the ability to build, explain, secure, test, and troubleshoot a small Claude application without relying on memorized answers.