Claude Certified Developer - Foundations

Claude Certified Developer – Foundations is Anthropic's entry-level developer credential: $125, 53 items, 120 minutes, proctored through Pearson either online with OnVUE or at a test center. It is scored on a 100–1000 scale, and 720 passes. Items are multiple-choice and multiple-response, and every multiple-response item states how many options to select — read that number before you read the options. There are no prerequisites. The credential is valid for twelve months and is renewed by a free open-book assessment rather than a second proctored sitting.

It is aimed at people who already build. The recommended background is one to five years of software engineering, at least six months hands-on with Claude, fluency in Python and/or TypeScript, and comfort with REST APIs and the command line.

The distinction that matters most is against the Architect exams. Those ask which trade-off is right at enterprise scale — governance, cost envelopes, platform strategy. CCDV-F asks whether you can implement the thing correctly: which stop_reason you branch on, which errors you retry, where the cached prefix ends, what a tool_result must carry. Answer every scenario as the engineer writing the code, not as the person approving the budget.

The blueprint is deliberately uneven:

• Applications and Integration — 33.1%, roughly 18 of 53 items
• Model Selection and Optimization — 16.8%, roughly 9 items
• Agents and Workflows — 14.7%, roughly 8 items
• Prompt and Context Engineering — 11.0%, roughly 6 items
• Tools and MCPs — 10.6%, roughly 6 items
• Security and Safety — 8.1%, roughly 4 items
• Claude Code — 3.1%, one or two items
• Eval, Testing, and Debugging — 2.6%, one or two items

Plan against those numbers rather than against the list. The top three domains are about two thirds of the paper; the bottom two together are perhaps three items. Eight domains invite eight equal study blocks, and that instinct is the most expensive mistake a candidate makes before sitting down. Weight your hours the way the exam weights its items.

Eight domains, one paper, and nothing like an even split. Turn the percentages into items and the shape is unmistakable: Applications and Integration is a third of the exam on its own, the top three domains are roughly 35 of 53 items, and the bottom two are one or two items each. Here is a twenty-hour plan, scaled to that reality.

• Applications and Integration, 33.1% — 7 hours. API request and response shape, stop_reason handling, streaming versus batch versus queued work, retries and idempotency, rate limits, key handling, model pinning. This is the domain you cannot pass around.
• Model Selection and Optimization, 16.8% — 3 hours. Tier choice against an eval, prompt caching and prefix placement, token and cost math, latency versus quality.
• Agents and Workflows, 14.7% — 3 hours. Workflow patterns versus autonomous loops, the tool-use turn, stopping conditions.
• Prompt and Context Engineering, 11.0% — 2 hours. Structure, examples, XML tagging, prefill, output contracts.
• Tools and MCPs, 10.6% — 2 hours. Tool schema design, the tool_use and tool_result exchange, what MCP adds and what it does not.
• Security and Safety, 8.1% — 1.5 hours. Prompt injection, least privilege on tools, argument validation, safe logging.
• Claude Code, 3.1% — 45 minutes. Skim.
• Eval, Testing, and Debugging, 2.6% — 45 minutes. Skim.

Skim means learn the shape, not the surface. For Claude Code, know the settings precedence order, allow/ask/deny with deny winning, and that claude -p is the headless entry point — do not memorize every CLI flag. For Eval and Testing, know that deterministic assertions run before model-based grading and that you change one variable at a time. Skip exhaustive parameter tables anywhere; the exam rewards decision rules over recall of field names.

Now the honest part. Claude Code and Eval/Testing are two of the most valuable things in this syllabus and two of the least valuable things on this exam. In real work, the engineer who can build an eval set and debug a trace is the one whose agent survives contact with production. On a 53-item paper they are worth about three items combined. Study them properly — after you pass. For the score, buy the items where the items are.

Read this in the last ten minutes before the exam, and nothing else. Eight words, one per domain, each holding a decision sequence you have already learned. In the room, when a scenario looks unfamiliar, name the domain, recall its word, and walk the letters — most items are asking which step the described system skipped.

• Applications and Integration — 33.1% — SCRIPT: Scope the criteria and eval set, Contract the request and response shape, Route sync/stream/batch/queue, Idempotency before any retry, Protect keys and pin the model, Tolerate errors with classified jittered backoff.
• Model Selection and Optimization — 16.8% — STAMPS: Size the tier from the cheapest up, Trim input and output tokens, Anchor the cacheable prefix first, Move offline work to batch, Perceived latency via streaming, Score against the baseline.
• Agents and Workflows — 14.7% — PILOT: Pattern before code, Instructions and tool interface, Loop on stop_reason returning every tool_result, Off switch named up front, Transfer back to the caller.
• Prompt and Context Engineering — 11.0% — SCRIBE: System prompt, Context above the question, Rules stated positively, Illustrate with diverse examples, Brainstorm before answering, Enclose in tags and extract.
• Tools and MCPs — 10.6% — MEDIATE: Match to a built-in first, Enumerate name/description/input_schema, Detect the tool_use block, Invoke in your own code, Answer with a matching tool_use_id, Trap failures as error results, Expose reusable capability over MCP.
• Security and Safety — 8.1% — GUARDS: Grade the data entering the prompt, Untrusted by default, Allowlist the capability, Restrict the arguments after resolution, Decide deterministically in code, Scrub the trail before logging.
• Claude Code — 3.1% — CLASP: CLAUDE.md first, Layered settings precedence, Allow/ask/deny plus permission mode with deny winning, Slash commands and Skills, Print mode for headless automation.
• Eval, Testing, and Debugging — 2.6% — TRACE: Trap the full trace, Reproduce with a failure rate, Assert cheaply before model grading, Classify the layer and change one thing, Enshrine the case in the eval set.