Claude CCDV-F Cheat Sheet

Applications and Integration

33.1% of exam
Applications Skill Weights Messages API Core Stop Reasons HTTP Error Codes Streaming Events Message Batches API API Feature Picker

Model Selection and Optimization

16.8% of exam
Model and Prompt Weights Model Tiers Prompt Caching Rate Limits Model Tier Picker

Agents and Workflows

14.7% of exam
Agent and Tool Weights Workflow Patterns Agent Loop Anatomy Claude Agent SDK Agent or Workflow

Prompt and Context Engineering

11.0% of exam
Prompt Design Context Management Output Handling System vs User Prompt

Tools and MCPs

10.6% of exam
Tool Definition MCP Essentials Tool Types Tool Approach Picker

Security and Safety

8.1% of exam
Security Skill Weights Security Controls Keys and Secrets Prompt Rule vs Hook

Claude Code

3.1% of exam
Claude Code Config Permission Modes CLAUDE.md hierarchy settings.json precedence

Eval, Testing, and Debugging

2.6% of exam
Debugging Method Eval and Regression Retry Rules Trace analysis

Quick Facts

Exam code CCDV-F
Credential Claude Certified Developer Foundations
Items 53 multiple-choice/multiple-response
Time 120 minutes
Pass 720 of 100-1,000
Fee $125 USD
Domains 8 weighted domains
Delivery Pearson VUE proctored
Validity 12 months
Retake waits 14, 30, 90 days
Attempts Four per rolling year
Blueprint v1.0, July 2026

Weight Order AP

Apps 33, Model 17, Agents 15
Prompt and context 11 Tools and MCP 10.6 Security 8.1 Code 3.1, Eval 2.6

Streaming vs Batch AP

Streaming

Tokens arrive live
Someone is waiting
Full price

Batch

Submit and poll
Nobody waiting
Half price
Now vs overnight

API Feature Picker AP

Bulk job, nobody waiting → Message Batches API ( 50% cost )
User watching output → Streaming ( SSE deltas )
Very large max_tokens → Streaming ( Avoids timeout )
Same large prefix repeats → Prompt caching ( 0.1x reads or less )
Response must be JSON → Structured outputs
Claude must call code → Custom tool ( input_schema )
Same file used repeatedly → Files API
Need cost estimate first → count_tokens
History outgrows window → Compaction ( Or clearing )

Applications Skill Weights AP

Claude Application Design 8.6% largest skill
Software Engineering Foundations 7.4%
Claude API Mechanics 6.8%
Configuration Management 4.1%
Understanding Requirements 3.4%
Systems Life Cycle 2.8%

Stream Event Order AP

Start -> Blocks -> Deltas -> Stop
message_start opens content_block_delta repeats message_delta has stop_reason Token counts are cumulative

Messages API Core AP

model Exact model ID
max_tokens Output ceiling, required
system Top-level standing instructions
messages user and assistant turns
tools Tool schema array
stream Incremental SSE output
Stateless Resend history every call
usage Token counts returned
request-id Header for support tracing

Stop Reasons AP

end_turn Finished naturally
max_tokens Truncated at your ceiling
tool_use Tool call pending
stop_sequence Custom sequence hit
pause_turn Resumable long turn
refusal Declined; read stop_details

HTTP Error Codes AP

400 invalid_request_error
401 authentication_error
402 billing_error
403 permission_error
404 not_found_error
409 conflict_error
413 request_too_large
429 rate_limit_error retry
500 api_error retry
504 timeout_error retry
529 overloaded_error retry

Streaming Events AP

message_start Empty message shell
content_block_start Block opens
content_block_delta Incremental chunk
content_block_stop Block closes
message_delta stop_reason and usage
message_stop Stream ends
ping Keepalive, safely ignored
text_delta Text fragment
input_json_delta Partial tool arguments
thinking_delta Reasoning fragment
signature_delta Precedes thinking block stop

Message Batches API AP

Discount 50% of standard prices
Typical run Most finish within 1 hour
Hard window Expires after 24 hours
Batch cap 100,000 requests or 256MB
custom_id Matches result to request
Ordering Results return in any order
Retention Results available 29 days
processing_status in_progress then ended
Result types succeeded errored canceled expired
max_tokens Must be at least 1

Request Size Limits AP

Messages API 32 MB
Token Counting API 32 MB
Batch API 256 MB
Files API 500 MB
Over the limit 413 request_too_large

Cache Prefix Order MO

Tools -> System -> Messages
Stable content first Volatile content last Four breakpoints maximum Any change invalidates

Prompt Caching vs Batches MO

Prompt caching

Repeated prefix
Realtime latency
Reads 0.1x or less

Batches

Unique requests
Async, 24 hours
50% price
Reuse prefix vs wait

Model Tier Picker MO

Hardest reasoning work → Opus ( Capability first )
Balanced production default → Sonnet
High volume, simple task → Haiku ( Cheapest )
Latency is the constraint → Haiku
Cost too high → Cache, then lower effort
Quality slipped → Raise effort first
Behavior changed on deploy → Pin the model ID
Two options look equal → Run an eval

Model and Prompt Weights MO

Technical Fundamentals 6.1%
LLM Fundamentals 5.2%
Prompt Engineering 4.6%
Context Engineering 3.8%
Cost and Token Management 2.8%
Model Selection Tradeoffs 2.7%
Output Handling 2.6%

Model Tiers MO

Opus Complex agentic, enterprise tier
Sonnet Balanced speed and intelligence
Haiku Fastest and cheapest tier
Pinned model ID Upgrades become deliberate
effort low medium high xhigh max
Adaptive thinking Model decides reasoning depth
Fast mode Faster Opus output, premium price
Real metric Cost per completed task

Prompt Caching MO

Prefix order tools, system, messages
Breakpoints Four maximum per request
Default TTL 5 minutes
Extended TTL 1 hour option
Write cost 1.25x 5-minute, 2x 1-hour
Read cost 0.1x; 0.05x Opus/Sonnet 5.5
Fable 5.1 reads 0.025x base input
cache_read_input_tokens Proves a cache hit
Invalidator Any prefix byte change
Placement Stable first, volatile last

Rate Limits MO

RPM Requests per minute
ITPM Input tokens per minute
OTPM Output tokens per minute
Algorithm Token bucket, continuously replenished
Cache reads Usually excluded from ITPM
max_tokens Does not affect OTPM
retry-after Seconds to wait, when sent
Scope Per organization, per model

Token and Cost Levers MO

count_tokens Size prompt before sending
Prompt caching First saving to try
Batch API Half price, asynchronous
Lower effort Fewer reasoning tokens
Smaller model Only if quality holds
Prune tool output Shrinks resent history
Streaming Avoids idle-connection timeouts
Context window Shared by every part

Agent SDK vs Claude Code AG

Agent SDK

Library you embed
Python or TypeScript
Programmatic agent

Claude Code

Terminal and IDE
Interactive session
Human in loop
Embed vs operate

Agent or Workflow AG

One call would work → Single LLM call ( Start here )
Fixed ordered subtasks → Prompt chaining
Distinct input categories → Routing
Independent parallel subtasks → Sectioning
Need higher confidence → Voting
Subtasks unknown upfront → Orchestrator-workers
Clear grading criteria → Evaluator-optimizer
Steps cannot be scripted → Autonomous agent
Context filling up → Subagent isolation

Agent and Tool Weights AG

Agent Construction 5.3%
Agent Patterns 4.9%
Agent Architecture 4.5%
Tool Implementation 4.4%
Agentic Customization 4.1%
MCP Server Development 2.1%

Workflow vs Agent AG

Workflow

Predefined code paths
Predictable
Easy to test

Agent

Claude directs steps
Open-ended
Harder to predict
You route vs Claude routes

Workflow Patterns AG

Single call Default starting point
Prompt chaining Fixed ordered subtasks
Routing Classify, then specialize
Parallel sectioning Independent subtasks merged
Parallel voting Same task repeated
Orchestrator-workers Runtime subtask decomposition
Evaluator-optimizer Draft and critique loop
Subagent Isolated context window

Agent Loop Anatomy AG

Request Model plus tool definitions
stop_reason Loop continuation signal
tool_use Execute, then return result
tool_result Sent in user turn
end_turn Loop terminates
Hook Deterministic enforced checkpoint
Iteration cap Stops runaway loops

Claude Agent SDK AG

Languages Python and TypeScript
Built-in tools Read, write, edit, bash
Agent loop Supplied, not hand-written
Subagents Focused sub-tasks
Hooks Agent lifecycle code points
Permissions Auto-run versus approval
Sessions Resume or fork context
MCP External tool connection
Hosting Runs in your process

System vs User Prompt PR

System

Role and standing rules
Output format
Stable across turns

User

The task itself
Changes every turn
Third-party data via tool_result
Durable frame vs task

Prompt Design PR

System prompt Role and standing rules
User turn Task; third-party data via tool_result
XML-style tags Mark section boundaries
Few-shot Three to five examples
Long documents Place near the top
Output constraints State the format explicitly
Zero-shot Instruction, no examples
Iteration Refine against real failures

Clearing vs Compaction PR

Clearing

Drops tool results
Leaves a placeholder
Cheap and predictable

Compaction

Summarizes history
Keeps a trace
Costs a pass
Delete vs summarize

Context Management PR

Context window System, tools, history, output
Clearing Drops old tool results
Compaction Summarizes earlier history
Context drift Instructions lost downstream
Tool output pruning Cuts accumulated bloat
Subagent isolation Separate context budget
Thinking blocks Return them unchanged

Structured Output vs Strict PR

Structured outputs

Shapes the response
Schema you supply
What Claude says

Strict tool use

Shapes tool arguments
Per tool definition
How Claude calls
Response vs arguments

Output Handling PR

Structured outputs Response matches your schema
Strict tool use Arguments match your schema
Defensive parsing Validate before consuming
Field checks Presence, type, range
Confident tone Not evidence of correctness
Non-determinism Judge across several runs
Fallback path Handle parse failure

Tool Round Trip TO

Use -> Run -> Result -> Reply
stop_reason is tool_use Execute your handler tool_result in user turn Same tool_use_id

Tool Use vs MCP TO

Tool use

Schema in your app
Serves one application
You execute calls

MCP server

Separate running server
Serves many applications
Standard protocol
In-app vs shared server

Tool Approach Picker TO

Search web or run code → Server tool ( No handler )
Reach your own system → Custom tool
Reuse across many apps → MCP server
Adding procedure, not capability → Skill ( No server )
Need file editing → Anthropic-schema tool
Arguments must validate → strict: true
Handler threw an error → tool_result is_error
Several calls at once → One user message

Tool Definition TO

name Unique tool identifier
description Primary selection signal
input_schema JSON Schema parameters
strict Guarantees schema-valid arguments
tool_use Claude's call block
tool_result Your returned output
tool_use_id Pairs call with result
is_error Flags a handler failure

Skill vs MCP Server TO

Skill

Instructions on demand
Uses existing tools
No server to run

MCP server

New callable functions
Backed by a system
Process to deploy
Procedure vs capability

MCP Essentials TO

Tools Executable server actions
Resources Contextual data sources
Prompts Reusable interaction templates
Elicitation Server asks the user
Protocol JSON-RPC 2.0 messages
stdio Local process transport
Streamable HTTP Remote server transport
Host Application running the clients
Client One per connected server

Tool Types TO

Custom tool You define and execute
Server tool Anthropic runs it
Anthropic-schema tool Bash, text editor, memory
Skill Procedure loaded on demand
MCP server Reusable across applications
Default choice Least code you maintain

Injection Defense SE

Isolate, restrict, enforce with hooks
Untrusted content in tool_result Minimum tool scope Hook blocks the action Polite prompt rules fail

Prompt Rule vs Hook SE

Prompt rule

Advisory guidance
Model may deviate
No enforcement

Hook

Runs every time
Can block the call
Deterministic control
Guidance vs enforcement

Security Skill Weights SE

AI Application Security 3.2%
Claude Code Operation 3.1%
Debugging and Error Handling 2.6%
Guardrails and Safe Deployment 2.3%
Identity, Secrets, Keys 1.6%
Claude Hooks 1.0% smallest skill

Security Controls SE

Prompt injection Untrusted text read as instruction
Isolation Third-party content in tool_result
Least privilege Minimum tool scope
Hooks Enforced, not advisory
PII Redact before the request
Retrieval scoping Only this user's data
Output filtering Screen before display
Guardrail layering Defense in depth

Keys and Secrets SE

Storage Secrets manager, server side
Client code Never ship a key
Repository Never commit a key
Rotation Replace on a schedule
Expiration Set a key lifetime
Suspected leak Disable the key immediately
Call origin From your own backend

Claude Code Config CL

Managed policy Org-wide, cannot be excluded
User memory ~/.claude/CLAUDE.md
Project memory ./CLAUDE.md, checked in
Local memory CLAUDE.local.md, gitignored
Load behavior Concatenated, never overriding
Read order Broadest scope first
Imports @path, four hops deep
settings.json Behavior, permissions, hooks

Permission Modes CL

default Prompts on first use
acceptEdits Auto-accepts file edits
plan Explores without editing
auto Classifier-checked auto-approval
bypassPermissions Skips permission prompts
Rule order deny, then ask, allow
PreToolUse hook Blocks before the call

Retry Rules EV

Retry 429 and 5xx; not 400-404
Exponential backoff Honor retry-after when sent SDKs retry twice Spend-cap 429 keeps failing

Debugging Method EV

Step one Classify the error type
Integration fault Handler or arguments wrong
Model fault Wrong output, correct data
Trace Read the tool sequence
request-id Ties failure to request
Recovery Retry, fallback, or fail
Reproduce Sample runs, not one

Eval and Regression EV

Eval set Cases with expected behavior
Quality gate Run before shipping changes
Model swap Behavior change, needs eval
Prompt edit Same risk, no compiler
Exact-match test Will flake
Versioned artifacts Prompts, schemas, model ID
Comparison New config versus current
Monitoring Watch quality in production

Common Traps

Workflow vs agent

Workflow follows your code ≠ Agent chooses its steps

Batch vs parallel calls

Batches cut price 50% ≠ Parallel calls pay full price

Custom tool vs MCP

Tool lives in one app ≠ MCP server serves many

Prompt rule vs hook

Prompt rules only advise ≠ Hooks actually block

Result matching

Match batches by custom_id ≠ Never match by position

Cache read vs write

Reads 0.1x, 0.05x, or 0.025x ≠ Writes 1.25x; 1-hour TTL 2x

Thinking block handling

Return them unchanged ≠ Editing them causes 400

Skill vs MCP server

Skill adds procedure ≠ MCP adds capability

tool_result placement

Goes in a user message ≠ Not the assistant turn

Domain score vs pass

Total scaled score decides ≠ Domain percentages are informational

Structured output vs strict

Structured shapes the response ≠ Strict shapes tool arguments

Bank size vs exam

Real exam has 53 items ≠ Practice banks are larger

Last Minute

1. 53 items, 120 minutes, 720/1000
2. Applications 33.1% is one third
3. Model selection 16.8%, agents 14.7%
4. Cache order: tools, system, messages
5. Batches = 50% cost, 24 hours
6. Match batch results by custom_id
7. Messages API is stateless; resend history
8. tool_result rides in user message
9. Same tool_use_id pairs call, result
10. Failed handler = tool_result is_error
11. Retry 429 and 5xx; not 400-404
12. MCP = tools, resources, prompts
13. stdio is local; streamable HTTP remote
14. Hooks enforce; prompt rules only advise
15. Third-party content goes in tool_result
16. System = rules; user = task
17. CLAUDE.md files concatenate, never override
18. Pin the model ID in production
19. Eval before every prompt change
20. Retake waits: 14, 30, 90 days