Cheat sheet

Claude CCDV-F Cheat Sheet

Practice Questions

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

Apps 33, Model 17, Agents 15

Prompt and context 11Tools and MCP 10.6Security 8.1Code 3.1, Eval 2.6

Streaming vs Batch

Streaming

  • Tokens arrive live
  • Someone is waiting
  • Full price

Batch

  • Submit and poll
  • Nobody waiting
  • Half price

Now vs overnight

API Feature Picker

  1. Bulk job, nobody waitingMessage Batches API(50% cost)
  2. User watching outputStreaming(SSE deltas)
  3. Very large max_tokensStreaming(Avoids timeout)
  4. Same large prefix repeatsPrompt caching(0.1x reads)
  5. Response must be JSONStructured outputs
  6. Claude must call codeCustom tool(input_schema)
  7. Same file used repeatedlyFiles API
  8. Need cost estimate firstcount_tokens
  9. History outgrows windowCompaction(Or clearing)

Applications Skill Weights

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

Start -> Blocks -> Deltas -> Stop

message_start openscontent_block_delta repeatsmessage_delta has stop_reasonToken counts are cumulative

Messages API Core

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

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

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_errorretry
500
api_errorretry
504
timeout_error
529
overloaded_errorretry

Streaming Events

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

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

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

Tools -> System -> Messages

Stable content firstVolatile content lastFour breakpoints maximumAny change invalidates

Prompt Caching vs Batches

Prompt caching

  • Repeated prefix
  • Realtime latency
  • 0.1x cache reads

Batches

  • Unique requests
  • Async, 24 hours
  • 50% price

Reuse prefix vs wait

Model Tier Picker

  1. Hardest reasoning workOpus(Capability first)
  2. Balanced production defaultSonnet
  3. High volume, simple taskHaiku(Cheapest)
  4. Latency is the constraintHaiku
  5. Cost too highCache, then lower effort
  6. Quality slippedRaise effort first
  7. Behavior changed on deployPin the model ID
  8. Two options look equalRun an eval

Model and Prompt Weights

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

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
Higher throughput, premium price
Real metric
Cost per completed task

Prompt Caching

Prefix order
tools, system, messages
Breakpoints
Four maximum per request
Default TTL
5 minutes
Extended TTL
1 hour option
Write cost
1.25x base input
Read cost
0.1x base input
cache_read_input_tokens
Proves a cache hit
Invalidator
Any prefix byte change
Placement
Stable first, volatile last

Rate Limits

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
Scope
Per organization, per model

Token and Cost Levers

count_tokens
Size prompt before sending
Prompt caching
First free saving
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

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

  1. One call would workSingle LLM call(Start here)
  2. Fixed ordered subtasksPrompt chaining
  3. Distinct input categoriesRouting
  4. Independent parallel subtasksSectioning
  5. Need higher confidenceVoting
  6. Subtasks unknown upfrontOrchestrator-workers
  7. Clear grading criteriaEvaluator-optimizer
  8. Steps cannot be scriptedAutonomous agent
  9. Context filling upSubagent isolation

Agent and Tool Weights

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

Workflow

  • Predefined code paths
  • Predictable
  • Easy to test

Agent

  • Claude directs steps
  • Open-ended
  • Harder to predict

You route vs Claude routes

Workflow Patterns

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

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

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

System

  • Role and standing rules
  • Output format
  • Stable across turns

User

  • Task and data
  • Changes every turn
  • Carries untrusted input

Durable frame vs task

Prompt Design

System prompt
Role and standing rules
User turn
Task and its data
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

Clearing

  • Drops tool results
  • Leaves a placeholder
  • Cheap and predictable

Compaction

  • Summarizes history
  • Keeps a trace
  • Costs a pass

Delete vs summarize

Context Management

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

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

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

Use -> Run -> Result -> Reply

stop_reason is tool_useExecute your handlertool_result in user turnSame tool_use_id

Tool Use vs MCP

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

  1. Search web or run codeServer tool(No handler)
  2. Reach your own systemCustom tool
  3. Reuse across many appsMCP server
  4. Adding procedure, not capabilitySkill(No server)
  5. Need file editingAnthropic-schema tool
  6. Arguments must validatestrict: true
  7. Handler threw an errortool_result is_error
  8. Several calls at onceOne user message

Tool Definition

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

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

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

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

Isolate, restrict, enforce with hooks

Untrusted in own blockMinimum tool scopeHook blocks the actionPolite prompt rules fail

Prompt Rule vs Hook

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

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

Prompt injection
Untrusted text read as instruction
Isolation
Untrusted content, own block
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

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

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, five hops deep
settings.json
Behavior, permissions, hooks

Permission Modes

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

Retry 429, 500s, 529; never 4xx

Exponential backoffHonor retry-afterSDKs retry twice400 401 403 404 permanent

Debugging Method

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

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

Cache reads cost 0.1x Cache writes cost 1.25x

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

Explore More Anthropic Claude Certifications

Continue into nearby exams from the same family. Each card keeps practice questions, study guides, flashcards, videos, and articles in one place.