Claude Certified Developer – Foundations lesson one: how the exam is scored, and how its wrong answers are built
The first lesson of Alloy's Claude Certified Developer – Foundations (CCDV-F) course is about the exam as an assessment: how it is scored, where its weight sits, what shapes its questions take, how its wrong answers are built, and how to sit it. It is free, with its podcast, "How to Take This Exam". Its premise is that the items you lose are rarely on unfamiliar material. They offer several reasonable answers — one technically true but irrelevant, another an elaborate solution to a problem nobody asked — and the lesson trains you to see the difference.
Why item construction is worth studying
A certification question's wrong answers are written to compete with the right one. A distractor is not random debris: it is there because a knowledgeable person might pick it, for a nameable reason — it is true but does not answer what was asked, it is the right action at the wrong layer, or it addresses a problem the stem did not describe. "Not nonsense" is a very low bar, and most distractors clear it. So the lesson asks you to stop asking "could this be right?" and ask "is this the best answer to this exact request, at this exact layer, with this exact evidence?"
The credential, in published facts
| Detail | Published value |
|---|---|
| Fee | $125 USD per attempt |
| Items | 53 |
| Time | 120 minutes |
| Passing | 720 on a 100–1,000 scale |
| Format | multiple-choice and multiple-response; each item states how many to select |
| Validity | 12 months |
| Delivery | Pearson VUE, online proctored or at a test centre |
| Prerequisites | none |
Fifty-three items in 120 minutes is a shade over two minutes an item — comfortable for recall and tight for a question that hands you a session trace and asks which of three fixes is targeted. Developer stems run long, so budget reading time as well as deciding time.
720 is a scaled score, not a percentage, and does not convert to "answer this many of 53 correctly". The cut score is criterion-referenced, set by a formal standard-setting study rather than a curve, and you are judged on the total scaled score only: the per-domain percentages on your report are informational, not separate bars.
The blueprint, and the weights below it
Eight domains carry published weights: 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%. Multiplied by 53, that is roughly 18, 9, 8, 6, 6, 4, 2 and 1 items — the lesson's arithmetic, not a published count.
Applications and Integration is a third of the exam and more than the next two domains combined. Its six sub-objectives — Understanding Requirements, Systems Life Cycle, Claude API Mechanics, Software Engineering Foundations, Claude Application Design and Configuration Management — make requirements gathering and life-cycle placement gradeable content.
CCDV-F is the only certification in the family whose guide weights 25 sub-objectives, and those weights change what a plan can do. Claude Application Design, at 8.6%, outweighs the whole Security and Safety domain. Software Engineering Foundations, at 7.4%, outweighs Tool Implementation at 4.4%. Claude Hooks, at 1.0%, is about half an item. And the two most enjoyable topics, Claude Code and Eval, Testing, and Debugging, are together 5.7% — about three items, and the two worst places to spend a third of your revision.
What each domain is really asking
The lesson reads every domain the way Anthropic's courseware frames it: each topic exists because it prevents a specific production failure. Applications and Integration asks whether you can take a requirement, place the work in the right life-cycle phase and design an application that survives production, down to stop_reason branching, error paths, configuration and versioning. Model Selection and Optimization covers tokens, the context window as a fixed budget, sampling and non-determinism, cost, and the difference between choosing a model and enabling a reasoning mode. Agents and Workflows is workflow-versus-agent, loops that terminate, memory across sessions and human-in-the-loop checkpoints where actions are irreversible. Prompt and Context Engineering covers system prompts, XML structure, few-shot examples, output constraints, context management and output parsing. Tools and MCPs is schemas Claude selects correctly, results in the expected form, and MCP servers with the right transport and scope. Security and Safety is prompt injection, jailbreaks, untrusted input, scoped identity, secrets and data boundaries. Claude Code is the explore–plan–code loop, permission modes and durable project context; Eval is defining done, choosing a grading method, and retriable versus terminal errors.
The question shapes
The lesson describes the shapes the official courseware uses:
- The four-option scenario — for example, a teammate insisting two identical prompts must return identical text, with temperature, sampling and determinism beneath four differently wrong explanations.
- The three-option targeted fix, read off a trace — an assistant turn issuing
tool_useidtoolu_01, atool_resultreferencingtoolu_02, and aninvalid_request_error, with the stem stating that the schema is valid and the description specific. - Fill in the configuration blank — a hooks block needing the lifecycle event that runs before a tool call (
PreToolUse) and a command that blocks by exiting2, against distractors that log and exit0. - Match into buckets — deployment scenarios against transport-and-scope pairs such as
stdio + Local,HTTP + Project (.mcp.json)andHTTP + User (~/.claude.json). There are only three installation scopes, so an "Enterprise" bucket is a distractor. - Free text with a model-answer reveal — "the prompt contains one defect; write the corrected system prompt."
- The cumulative multi-layer debug — an agent with four planted bugs, one each in the schema, streaming, context and memory layers: name each bug and its layer, then correct it.
- Assemble the minimal configuration — four plausible pieces and the instruction to leave out anything that does not belong. The item is testing subtraction.
How a developer distractor is built
The five general shapes — the absolutist, true but not the question, right action at the wrong layer, the over-engineered one and the answer to a different question — each have a developer form:
- A plausible-but-wrong API shape. Real fields in a real order that fix a different class of defect than the error names: adding a
requiredarray to aninput_schemawhen the failure is a mismatchedtool_use_id. Read the error first, classify it — schema validation, message ordering, transport or authentication — and discard every option outside that class. - An anti-pattern wearing best-practice clothing. Rotating a key but updating the credentials file, which leaves the secret in the file; concatenating every past session transcript "for memory"; switching to
bypassPermissionsfor fewer prompts, which removes the protected-path guard. The tell is a stated benefit of thoroughness or convenience whose cost is a control you have removed. - Right action, wrong layer. A repair in the prompt when the defect is in the parser, in the schema when it is in the loop, in the tool when it is in the transport. Name the layer from the evidence before comparing options.
- The over-engineered one. An agent where one call works, a retrieval index where a cached prefix works, a stronger model where a corrected prompt works. Prefer the simplest option that fully satisfies the requirement.
- True, but not asked. A correct statement about
stop_reasonoris_errorin an item about ordering. Re-read the stem's final sentence.
The lesson's rule for changing an answer: only when you can name what you missed on the first read — "I missed the word only", "I overlooked the constraint" — never because your confidence wobbled.
Sitting it
Pearson VUE, online proctored or at a test centre. Accept the NDA before the exam begins; declining ends the session with no refund. Bring valid, unexpired government photo ID with a name matching your registration exactly. Cancelling within 24 hours forfeits the fee, as does not showing up. Retakes wait 14, then 30, then 90 days, capped at four attempts in a rolling 12 months with the fee payable each time — so sit when ready rather than early. Appeals must be filed within 14 days, and neither the standard-setting outcome nor item content is appealable. The credential lasts 12 months; renewing on time is free and non-proctored on the Partner Academy.
How to work the course
The lesson closes with how to use Alloy: take the diagnostic first, in one sitting (24 questions, about 20 minutes, about three per domain and reported as counts); rate your confidence honestly so Alloy can hand back what you were sure of and got wrong; prove material rather than tick it, since reading a lesson is the weakest evidence and a podcast counts only when you have genuinely listened to part of it; open Recommended next when you do not know what to study; and use labs where a real authored lab exists and scenarios for judgement calls. Twelve domain lessons follow, in a teaching order — fundamentals before API mechanics — with four for Applications and Integration and one or two for each other domain.
The exam-strategy lesson is worth a 10–20% score bump: it targets the costliest mistake, getting wrong a question you actually knew.
Next step
Create a free account, take the CCDV-F diagnostic, then open this lesson and its podcast. The second lesson — what a request costs, why it varies and how it reaches Claude — is free too.
Alloy is exam preparation built from the official exam guides — only what the exam asks for.