How to Prepare for Claude Certified Developer – Foundations (CCDV-F)

Claude Certified Developer – Foundations (CCDV-F) is Anthropic's proctored exam for engineers who build, integrate, and ship applications on the Claude API, Agent SDK, tools, and MCP. It costs $125, has 53 scored items in 120 minutes, passes at 720/1000, and is valid for 12 months with free on-time renewal. You register through Pearson Professional Assessments.

This study plan is from the PrepGenAICerts editorial team, using official format facts and the eight domain weights. No exam items. Start at the Claude Certified Developer exam hub. Free lessons: CCDV-F prep course. Also /claude-certified-developer/exam-guide, /claude-certified-developer/reference, and /claude-certified-developer/study-plan. Premium unlocks full mock exams and the AI tutor.

Who this exam is for

CCDV-F is built for people who write application code against Claude: AI/ML engineers, technical leads, and software engineers who own API integration, tool schemas, streaming, evals, and shipping. The exam is not a prompt-only quiz and it is not the Architect credential. If your job is designing multi-agent production systems and governance, read the Architect hubs instead. If you use Claude in Claude.ai or Projects without writing code, look at CCAO-F.

Recommended background from Anthropic's own description: fluent in Python and/or TypeScript, comfortable with REST APIs and CLIs, with roughly six months of hands-on Claude or comparable LLM work. You do not need to train models. You do need to reason about what happens when a tool fails, when a prompt cache misses, and when a cheaper model is the right production default.

Study order: domains by weight

Study the heaviest domains first. The eight CCDV-F domains and their official weights are: 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%, and Eval, Testing, and Debugging 2.6%. Those percentages are the share of scored items, so a small gain on Applications and Integration moves the scaled score more than an equal gain on Claude Code.

• Applications and Integration (33.1%) — API client usage, streaming, errors, multi-format input, and wiring Claude into a real codebase. Spend about a third of study time here.
• Model Selection and Optimization (16.8%) — which Claude tier fits a latency, cost, and quality constraint; prompt caching; batch processing; token budgets.
• Agents and Workflows (14.7%) — Agent SDK loops, tool-use turns, stop reasons, and when a workflow should hand off or stop.
• Prompt and Context Engineering (11.0%) — prompts that hold up under real user input; context that does not drift in long sessions.
• Tools and MCPs (10.6%) — custom tools, function schemas, MCP servers versus built-in tools, and the tradeoffs.
• Security and Safety (8.1%) — prompt injection, hooks-based guardrails, least privilege on tools that can write or delete.
• Claude Code (3.1%) — CLAUDE.md, settings, Skills. Small weight; do not skip it, but do not let it eat the integration week.
• Eval, Testing, and Debugging (2.6%) — traces, failure modes, structured-output validation. Short, high-leverage if you already ship tests.

What question styles look like (prose only)

CCDV-F items are multiple-choice and multiple-response. They are scenario-shaped: a short production situation, a constraint, and several designs that all look plausible. The exam is not asking you to paste SDK method names from memory. It is asking which design survives the constraint — a multi-tenant deployment, a hard latency budget, a tool that can take destructive actions, or a response that must be valid JSON before it hits a downstream system.

A typical integration item describes an application that already calls the Messages API and then changes one requirement: streaming to the user, batch overnight jobs, or attaching images. A typical tools item asks whether a capability should be a model-invoked tool, an MCP resource, or application-side retrieval. A typical security item puts a powerful write tool in the agent's reach and asks how to constrain it. We do not reproduce stems or options here.

2-week schedule

Use this if you already ship Claude in production and can study about two focused hours a day. Register only after a timed practice run feels boring, not heroic.

Week 1 — heavy domains

1. Day 1: Read the CCDV-F hub and the Applications and Integration domain list. Map each topic to something in your own repo. Note gaps; do not binge-read the entire API reference.
2. Day 2–3: Integration in depth — streaming versus non-streaming, error handling, retries that do not duplicate side effects, and multi-format input. Work the free CCDV-F prep course lessons that match this domain.
3. Day 4: Model selection and optimization — caching, batch, token ceilings. Write one paragraph on when you would not cache.
4. Day 5: Agents and workflows — Agent SDK loop, stop reasons, when to add a subagent versus a tool. Keep it to production patterns, not toy chatbots.
5. Day 6: Prompt and context engineering plus Tools/MCP. Draw the Tools / Resources / Prompts split from memory.
6. Day 7: Mixed review of week 1. List the three failure modes you still cannot explain out loud.

Week 2 — remaining domains and mocks

1. Day 8: Security and Safety — injection, tool permissions, hooks. Practice explaining a deny-by-default tool policy in two sentences.
2. Day 9: Claude Code plus evals — settings.json, CLAUDE.md, what an eval set is for. Keep both proportional to their small weights.
3. Day 10: Timed mixed practice (Premium mock if you have it; otherwise course quizzes and the hub FAQ). Score by domain, not just overall.
4. Day 11: Remediate the two weakest domains only.
5. Day 12: Second timed run. Compare domain percents. If Applications and Integration is still weak, stop studying Claude Code.
6. Day 13: Light review of facts: $125, 53 items, 120 minutes, 720 pass, 12-month validity, Pearson registration.
7. Day 14: Exam window or rest. Do not cram new APIs the morning of.

How to use this site without mixing certs

PrepGenAICerts hosts four credentials. The nav, glossary, and learn library still have Architect Foundations depth because that exam shipped first. For CCDV-F, treat the Developer hub, Developer prep course, and Developer reference as the spine. Use glossary terms that name the API, MCP, or Claude Code when they match a Developer domain; skip Architect-only orchestration essays until you have integration hours in the bank. The compare page CCDV-F vs CCAR-F exists so you can sanity-check that you picked the right exam before you pay Pearson.

4-week schedule

Use this if you are newer to the Claude API or cannot study every day. Week 1 is foundations only. Week 2 walks domains in weight order. Week 3 is mostly practice. Week 4 is mocks, remediation, and Pearson logistics (ID name match, OnVUE versus test centre, 14/30/90-day retake waits).

• Week 1: Finish the CCDV-F prep course overview and any official Academy courses you still lack. Take notes on surprises only.
• Week 2: One heavy domain cluster per two days: Integration; then models/caching; then agents.
• Week 3: Prompt/context, tools/MCP, security. First timed practice at the end of the week.
• Week 4: Claude Code and evals in one sitting; two more timed runs; hub + cost-registration reread; sleep.

What each domain actually tests

What Applications and Integration actually tests

This domain is about shipping Claude inside software you already maintain. You should be able to explain how a Messages API call is authenticated, how streaming changes error handling, and how you keep a user-visible response in sync with tool-use turns. Integration also covers attaching files or images when the product needs them, and not treating the API as a fire-and-forget HTTP POST. Expect scenarios where the 'clever' design ignores retries, idempotency, or a client that must cancel an in-flight stream. If you cannot walk through a production call path — request, stream or complete, tool loop, persist, display — this is the domain to practise first, because it is a third of the scored items.

What Model Selection and Optimization actually tests

Professional developers pick a Claude model tier against cost, latency, and quality, then use caching and batch where they actually help. The exam is not a pricing-spreadsheet quiz; it is 'which default would you ship'. Prompt caching belongs when a large prefix is stable; batch belongs when latency can wait; a smaller model belongs when the task is classification-like. Wrong instincts include always using the largest model, caching a prefix that changes every turn, or sending interactive chat through a batch path. Write down one sentence for cache, batch, and model step-down before exam day.

What Agents and Workflows actually tests

Agents here are application-owned loops: the model may call tools, you must handle stop reasons, and you must know when to stop or ask a human. The Agent SDK is in scope as the harness Anthropic ships for that loop. Scenarios contrast a single-shot completion with a tool-using agent, or a coordinator that delegates too broadly. You should be able to say what happens after tool_use versus end_turn, and why an unbounded loop is a production incident waiting to happen. Keep examples in your own words; do not memorise SDK file names.

What Prompt and Context Engineering actually tests

CCDV-F prompting is about reliability in an application, not chat cleverness. Structured output, schemas, and keeping long-running context from drifting show up as design choices. A good answer usually names a validation step or a context policy (what is summarised, what is kept, what is retrieved). A weak answer is a longer prompt with no check. Practise explaining one production prompt in terms of inputs, constraints, and failure handling.

What Tools and MCPs actually tests

Tools are model-invoked actions; MCP is how you expose tools, resources, and prompts to Claude in a standard way. The exam cares whether a capability is a tool, a resource, or something the application should do itself. Custom MCP servers versus built-in tools is a tradeoff question, not a brand question. If you can draw the ownership model and give one example of a dangerous tool that needs a confirmation hook, you are in the right neighbourhood.

What Security and Safety actually tests

Treat untrusted text as untrusted, including retrieved documents and user paste. Tool permissions should default closed. Hooks can block or require approval for destructive calls. Scenarios often look like a helpful agent that can send email or delete files. The Foundations developer exam is not a full security certification, but it does expect you not to give the model a loaded write tool with no policy.

What Claude Code actually tests

Small weight: CLAUDE.md, settings, Skills, and when Claude Code is the right interface versus a custom app. Do not skip the vocabulary; do not spend a weekend on it. One sitting mapping user, project, and local settings is enough for most candidates who already use the CLI.

What Eval, Testing, and Debugging actually tests

Even smaller weight, but it separates people who ship from people who demo. Know what an eval set is for, why a held-out set matters, and that traces beat guessing when a tool loop fails. You will not need a full MLOps platform; you will need a story for 'how would you know this got worse after a prompt change'.

Exam day, scoring, and registration

CCDV-F is 53 scored items in 120 minutes at $125, passing at 720 on a 100–1000 scaled score. Pearson VUE delivers it OnVUE or in a test centre. You see pass/fail plus domain percents. The credential lasts 12 months; on-time renewal is a free Partner Academy assessment; a lapse means retaking the full exam. Retakes wait 14, then 30, then 90 days, max four attempts per rolling year.

Fifty-three items in two hours is a little over two minutes each. Integration stems can be long; flag and move rather than decorating an answer that still ignores the constraint. Confirm ID name match before exam day. Read the hub cost-registration page once the week before so Pearson logistics do not steal study hours.

Common mistakes

• Studying Architect (CCA-F) domains instead of the eight CCDV-F domains. The names overlap; the weights do not.
• Memorising parameter lists. The exam rewards constraint-driven design, not SDK trivia.
• Ignoring Applications and Integration because it feels like 'just the API'. It is a third of the exam.
• Over-investing in Claude Code or evals because they are comfortable. Together they are under 6% of scored items.
• Skipping security because you 'would never expose a delete tool'. The exam still tests how you would constrain one.
• Inventing a pass-rate target. Anthropic publishes a scaled 720/1000 cut score, not a public percent-correct or a 'typical pass rate'.

Free resources and Premium

Use the Claude Certified Developer hub as the canonical facts page (fee, items, domains, registration). Take the CCDV-F prep course for free lessons. Keep /claude-certified-developer/reference open during domain weeks. Build a calendar on /claude-certified-developer/study-plan. Compare CCDV-F with Architect on /claude-certifications/compare/ccdv-f-vs-ccar-f. Premium on this site adds full mock exams and the AI tutor; courses and the hub stay free. This site is independent and not affiliated with Anthropic.