⚡ Claude Certified Developer (CCDV-F) — Cram Jam

Last-minute dense recall sheet · read fast, stash in memory. Not a substitute for the full guide.
$125 · 53 items · 120 min · pass 720/1000 (scale 100–1,000)
12-mo valid · 8 weighted domains · closed book, proctored
Source: official CCDV-F Exam Guide
Full guide

Exam Facts — Official CCDV-F Exam Guide

  • $125 price; must review Exam Guide, Cert Terms & Conditions, and Exam Policy before your session.
  • 53 items (MC / multi-response, each states how many to select) · 120 min · scaled 100–1,000, pass 720 · valid 12 mo from award date.
  • Delivery: proctored, online and/or test center, per program policy.
  • Score report: pass/fail + percent-correct by domain.
  • These figures are quoted from the official guide but the program is young — re-check the current PDF before booking.

Official Blueprint — 8 Domains

DomainWt
1 Agents and Workflows14.7%
2 Applications and Integration33.1%
3 Claude Code3.1%
4 Eval, Testing, Debugging2.6%
5 Model Selection and Optimization16.8%
6 Prompt and Context Engineering11.0%
7 Security and Safety8.1%
8 Tools and MCPs10.6%

Domain 2 alone is a third of the exam. Domains 3+4 (Claude Code, Eval/Debugging) are ~6% combined despite the credential explicitly validating eval design and trace-based debugging — don't skip them because the weight looks small.

Messages API Skeleton

POST /v1/messages
{model, max_tokens,
 system, messages:[
  {role:"user", content}]}

  • system = top-level field, not a message role.
  • Only roles: user, assistant. No "system" message.
  • API is stateless — resend full history every call.
  • max_tokens required; temperature/top_p/top_k optional.

Content Block Types

BlockWhere
textreq + resp
image / documentrequest
tool_useresponse
tool_resultrequest
thinking / redacted_thinkingresponse

content is always an array, never a bare string in responses.

stop_reason Values

ValueMeaning
end_turnfinished normally
max_tokenstruncated, hit ceiling
stop_sequencehit a stop string
tool_usemust send tool_result back
pause_turnlong/agentic turn paused
refusaldeclined for policy

Tool Use Cycle (in order)

  1. Send request + tools array
  2. Get stop_reason:"tool_use" + tool_use block(s)
  3. You run the function
  4. Resend full history + tool_result block(s), keyed by tool_use_id
  5. Repeat until end_turn

Trap: forgetting to resend tools on the follow-up call (stateless API).

Tool Definition Shape

{name, description,
 input_schema:{type:"object",
  properties:{...}, required:[...]}}

tool_choiceEffect
automodel decides (default)
anymust call some tool
tool + nameforce this one — best for structured output
nonedisable tools this call

Streaming Event Sequence

message_start → content_block_start → content_block_delta ×N → content_block_stop → (repeat per block) → message_delta → message_stop

  • Deltas typed: text_delta, input_json_delta (partial JSON — concat before parsing!), thinking_delta, signature_delta.
  • ping = keepalive, ignore. Mid-stream failure → error event.

Prompt Caching

  • Mark with "cache_control":{"type":"ephemeral"} on a block in system/messages/tools.
  • Prefix must be byte-for-byte identical to hit — put varying data after the cached block.
  • Write = premium cost; read hit = large discount.
  • Check usage.cache_creation_input_tokens / cache_read_input_tokens to verify hits.
  • Min cacheable length + TTL vary by model — verify current docs.

Extended Thinking

  • Enable: "thinking":{"type":"enabled","budget_tokens":N}, N < max_tokens.
  • Response gets a thinking block (with signature) before the answer.
  • Must pass thinking block back unmodified on later turns (tool use / multi-turn).
  • redacted_thinking = encrypted reasoning, still round-trip it.
  • Sampling params constrained while thinking is on — verify current limits.

Token / Cost Levers

  • Prompt caching (repeated prefix) · Batch API (~50% off, async) · shorter prompts / retrieval instead of stuffing context.
  • Cheaper model tier (Haiku) for high-volume simple tasks.
  • Extended thinking off when not needed — costs extra output tokens.
  • POST /v1/messages/count_tokens to check cost before sending.

Rate Limits & Retry

HeaderMeaning
anthropic-ratelimit-requests-*req/min budget
anthropic-ratelimit-tokens-*token/min budget
retry-afteron 429/529, seconds to wait

Retry 429/529 + backoff/jitter. Never retry 400 unchanged — it'll fail identically.

Error Types

Statuserror.type
400invalid_request_error
401authentication_error
403permission_error
404not_found_error
413request_too_large
429rate_limit_error
500api_error
529overloaded_error

Batch API

  • POST /v1/messages/batches — array of {custom_id, params}, each params = a normal Messages request.
  • Poll GET /v1/messages/batches/{id} for status.
  • Results = JSONL, one line per custom_id.
  • Use for: high volume, latency-tolerant, cost-sensitive, no user waiting.

Files, Vision & Citations

  • Upload once (POST /v1/files) → reference by file_id in image/document blocks — avoids re-sending base64 every call.
  • Small one-off images: inline base64 in an image block is fine.
  • document block + "citations":{"enabled":true} → response text carries citation metadata back to the source passage.

SDK Setup — Python / TypeScript

pip install anthropic
client = Anthropic()
client.messages.create(...)

npm install @anthropic-ai/sdk
const client = new Anthropic();
await client.messages.create({...});

Both read the API key from ANTHROPIC_API_KEY by default. Both offer a .stream() helper.

Model Families

FamilyFit
Opushardest reasoning/agentic, $$$
Sonnetdefault balanced production choice
Haikuhigh-volume, cheap, fast, simple tasks

Pin a dated model ID in production; don't rely on a rolling alias.

MCP Primitives & Transports

PrimitiveInvoked by
Toolsthe model
Resourcesthe app/user (read-only data)
Promptsthe user (explicit template)

stdio = local subprocess, simplest. Streamable HTTP = remote server.

Agent SDK vs Raw API vs Claude Code

  • Raw API/SDK — you own the loop, full control.
  • Claude Agent SDK — embed Claude Code's agent loop (tools+context+MCP) inside your own app.
  • Claude Code — ready-made terminal/IDE agent, not a library.

Evaluation & Testing

  • Treat prompts/tool schemas like code: keep a labeled eval set, re-run on every prompt/model/schema change, diff outputs before shipping.
  • Log usage, stop_reason, model ID, latency per call for regression detection.

Security & Secrets

  • Never ship an API key in client-side code — proxy through your backend.
  • Never trust tool_use.input as pre-sanitized; validate before executing (esp. filesystem/shell/DB tools).
  • Mind PII in anything logged or cached — it persists as long as that policy says.

Keyword → Answer

  • "resend full history" → stateless API
  • "truncated output" → stop_reason: max_tokens
  • "model wants to call a function" → stop_reason: tool_use
  • "reliable JSON shape" → forced single-tool extraction
  • "reuse this document/prefix" → prompt caching or Files API
  • "huge volume, no rush" → Batch API
  • "user-triggered template" → MCP Prompt
  • "read-only context data" → MCP Resource
  • "partial JSON fragment" → input_json_delta, concat first
  • "don't retry this" → 400 invalid_request_error

Top Traps

system role in messages doesn't exist (it's top-level) · content is always an array · forgetting to resend tools on the tool_result call · parsing partial input_json_delta as JSON · stripping thinking blocks before a later turn · caching a block with a varying value inside it · retrying 400 errors · assuming Domain 2 (33.1%) is like the other seven domains — it isn't
Figures on this sheet come from Anthropic's official CCDV-F Exam Guide — but the program is young and the guide is subject to change. Re-check the current Exam Guide PDF before booking.
Cram Jam · Claude Certified Developer – Foundations (CCDV-F) · pairs with the full study guide · verify parameters/limits against docs.claude.com · not affiliated with Anthropic.