Stop studying.
Start shipping.
The Claude Certified Developer - Foundations exam (code CCDV-F) is for engineers building production applications on Claude. Bayesian Knowledge Tracing maps every concept you'll need at the keyboard, the Messages API, streaming and caching, tool and MCP design, prompt and context engineering, structured-output validation, to a live probability of mastery. We show you exactly what's weak and drill it until it isn't.
- Concepts
- 77
- Mastery threshold
- 0.90
- Domains
- 8
Domain mastery
Your live mastery map
Updated after every answer. Threshold to retire a concept: 0.90.
Claude Certified Developer - Foundations
The Claude developer certification, officially the Claude Certified Developer - Foundations (CCDV-F), is Anthropic's foundations exam for engineers building applications on Claude. It covers 8 weighted domains from agents and the Agent SDK to the Claude API, tools and MCP servers, prompt and context engineering, and application security, across 53 questions scored 100 to 1000 with 720 to pass. This is the second exam our adaptive engine is built around.
- $125
- exam fee
- 53
- questions
- 120 min
- time limit
- 720
- to pass (of 1000)
- 12 mo
- valid for
Official resources
Book the exam and read the official guide
The official exam guide and registration live with Anthropic and Pearson VUE. Start there, then use our adaptive engine to get exam-ready.
Official Anthropic resources · AI Skill Certs is an independent prep platform, not affiliated with Anthropic.
The exam for developers
to pass.In 4 weeks.
The exam tests how you build Claude applications in production: the API and its mechanics, tool and MCP design, prompt and context discipline, and the safe handling of untrusted input. So that's exactly what we drill, until your readiness score clears 720. Below it after four weeks? Your next month is on us.
Diagnostic in 20 minutes. No credit card to start.
How we get you there
Diagnostic in 20 minutes. Plan in 1 hour. Pass in 4 weeks.
720 to pass · we don't release you below 800 in mock
Diagnostic and plan
- 20-minute scenario diagnostic across all five domains
- Initial mastery probability for each of 175 production patterns
- Daily plan locked onto your weakest 30 patterns first
Drill the build patterns
- MCP tool design, model routing, hooks, structured outputs
- Concepts retire only at 0.90 probability
- First scenario-based mock at end of week
Transfer to scenarios
- Archie sessions on every fragile pattern
- Cross-domain scenarios: agent loops + hooks + JSON in one question
- Mid-course mock targeting 700+
Mock until 800+
- Full-length scenario mocks every 48 hours
- We don't release you below 800 in mock
- Sit the exam with confidence, not hope
Mastery proof
Every concept, ordered by the graph.
Two artefacts every learner sees from day one: a live concept heatmap and the prerequisite graph that decides what you study next. The engine below is drawn from our live architect track; the developer graph runs on exactly the same machinery.
Concept space
175 concepts. One probability each.
Knowledge graph fragment
Prerequisites are non-negotiable
Domain 1: Agentic Architecture, 12 of 36 concepts shown
Mapped to the official exam
Eight domains. Twenty-five skills. Weighted to the developer job.
The Claude Certified Developer - Foundations exam (CCDV-F) validates that you can build, integrate, and ship reliable applications on Claude. The breakdown below comes straight from Anthropic's exam guide; the weightings are fractional because they follow a job-task analysis. We drill every skill under every domain, in prerequisite order.
Agents and Workflows
Choosing between a workflow and an agent, wiring manager and subagent hierarchies, and building loops with the Claude Agent SDK, custom harnesses, and deterministic hooks.
3 task statements
Applications and Integration
The largest slice of the exam: the Messages API, streaming, caching and batch, software-engineering foundations, application design across every Claude interface, and configuration management. The real software around the model.
6 task statements
Claude Code
Claude Code as a build surface: rules, skills, commands, agents and memory, the CLAUDE.md hierarchy, session management, and settings.json configuration.
1 task statement
Eval, Testing, and Debugging
Reading traces to isolate whether a failure came from your integration layer or the model, then choosing the recovery strategy that fits the error type.
1 task statement
Model Selection and Optimization
LLM fundamentals, model options and effort levels, Opus, Sonnet, and Haiku trade-offs across quality, latency, and cost, and token budgeting with prompt caching.
4 task statements
Prompt and Context Engineering
Context-window discipline, drift and bloat prevention, prompt construction and placement, and defensive parsing of Claude's output.
3 task statements
Security and Safety
Prompt-injection and jailbreak defence, untrusted-input handling, PII and secrets management, guardrail layering, and hooks that block destructive actions.
4 task statements
Tools and MCPs
Function calling and tool-set design, MCP server authoring and transport, and choosing between built-in tools, custom tools, Skills, and MCPs for the job at hand.
3 task statements
The exam, in numbers.
- Domains
- 8
- Task statements
- 25
- Scenarios
- 0
- Pass score
- 720
Scaled 100 to 1000. Scenario-based multiple choice. Source: Anthropic's official exam guide.
How it works
Three layers, one job: get you to 0.90 on every pattern you'll ship.
They run as a closed loop. The graph decides what you study, the engine measures whether it stuck, and Archie teaches the gap, then every answer flows back into the engine and re-orders tomorrow's plan. You never study the wrong thing twice.
Knowledge graph
77 concepts. Every one a thing you'll do at the keyboard, not just on the test.
MCP tool schemas, hook ordering, subagent context-passing, model-routing trade-offs, JSON repair patterns: every exam concept is mapped to the production pattern it represents and locked behind its prerequisites. No skipping ahead, no reasoning about hooks before you've nailed the agent loop.
DAG · 77 concepts · 25 task statements · 8 domains
Threshold 0.90
BKT engine
Mastery threshold 0.90. No shipping with a 0.7 on hooks.
Bayesian Knowledge Tracing keeps a live probability that you have actually mastered each pattern. We retire a concept at 0.90 and bring it back the instant a downstream scenario reveals regression. The exam catches a 0.7. So does production.
BKT · per-learner parameters · regression detection
Archie
A Socratic tutor that pressure-tests build decisions.
Archie is built on Claude and constrained to certification content. He never gives the answer. He asks the next question, about your routing decision, your tool schema, your loop termination logic. Every exchange feeds back into the BKT layer, so tomorrow's drills target what you actually struggled to ship.
Claude · graduated hints · misconception detection
Graph orders → engine measures → Archie teaches → engine updates → graph re-orders. The loop never opens.
Built around how you learn
One concept. Three ways in.
Some patterns land as prose. Some only make sense as a diagram. Some you have to watch someone build. So every concept comes three ways: read it, see it, or watch it. You pick the format that clicks for you when you start; it leads every topic. The other two stay one tap away.
The agent loop
An agent runs a loop: the model proposes a tool call, the harness executes it, the result is fed back, and the loop repeats until a stopping condition is met. Your job is to define that stopping condition precisely.
Key concepts
- Tool-call → execute → observe cycle
- Loop termination logic
- Context accumulation per turn
Rendered from the knowledge point's summary + key concepts
Set your default in onboarding · change it any time in settings · every format logs back to the engine
Browse every CCDV-F concept
Open the concept library filtered to this exam - every knowledge point with worked examples, diagrams, official Academy lessons, and practice questions.
Tutor in the loop
Every Archie exchange writes back to the engine.
You won't see the BKT update in real time, but it's happening on every reply. A clean reasoning chain pushes the concept's probability up. A near-miss marks the concept fragile and schedules a return.
- Avg. exchanges per concept
- 2.3
- Hint levels available
- 3
Live in the engine
Concept KP-042 just updated your mastery probability for Prompt Hierarchy from 0.62 to 0.71.
Frequently asked
The questions developers ask before they buy.
Engineers and developers building production applications on the Claude API. If you are shipping or about to ship code that calls the Messages API, designs tools and MCP servers, engineers prompts and context, or handles untrusted input safely, you are the target. We assume you can already write code; we drill the skills the exam tests, in the order that builds correctly.
The Claude Certified Developer - Foundations exam (CCDV-F) runs eight domains across twenty-five skills, scored 100 to 1000 with 720 to pass. It has 53 questions in 120 minutes. Unlike the architect exam it is not built around a fixed scenario bank; items are written directly against the weighted skills. Most items are single-answer, and a few ask you to select more than one option, with each item stating how many responses to pick.
Archie is a Socratic tutor built on Claude. He does not quiz you on definitions. He interrogates the decisions you would make in production: which model to route to, how to shape a tool schema, where context drifts, how to parse output defensively. Every exchange is grounded in a concept ID and a skill, and feeds back into the engine that picks tomorrow's drill.
BKT keeps a live probability that you have actually mastered each concept, between 0 and 1. Every answer nudges that probability. Once a concept clears 0.90 we stop drilling it and shift attention to your weak areas. It is the same model used by some of the best adaptive systems in education.
The CCDV-F exam costs $125, booked through Pearson VUE. We are prep only and not affiliated with Anthropic: you book the official sitting yourself. What we do is get you exam-ready, with a readiness score that maps tightly to actual performance.
Plan for 30 to 45 minutes a day across four weeks. We track your time and adjust the daily plan if you fall behind. The engine retires a concept only when your mastery probability clears 0.90, so the plan ends when you are ready, not on a fixed date.
Yes. Because we track mastery per concept rather than per course, the concepts this exam shares with the architect track, model selection, prompt and context engineering, tools and MCP servers, hooks and application security, count towards both. Eleven of the developer concepts are shared architect concepts, so time spent on either track is never wasted.
Your study history stays yours. We use it to personalise your plan and aggregate it anonymously to improve the question bank. We do not sell data, we do not train external models on it, and you can export or delete your account at any time.
Start your diagnostic
Stop studying. Start shipping.
20 minutes to your first mastery map. From there, the engine drills you on the skills you'll actually ship: the Claude API, tools and MCP, prompt and context engineering, and structured-output validation.