Claude Certified Developer ProfessionalCCDV-PAnthropicCheat SheetQuick Reference

Claude Developer Professional Cheat Sheet: Quick Reference [2026]

Preporato TeamNovember 16, 202615 min readCCDV-P

Claude Certified Developer - Professional asks what happens to a Claude system after it ships: which error means retry and which means fix the request, why a turn stopped, which setting wins when two files disagree, where the money went. This cheat sheet collects those rules in one place, grouped by the eight domains Anthropic lists, with the numbers and field names that decide production scenarios. Every rule comes from Anthropic's Claude Platform and Claude Code documentation, linked at the end.

Status on November 16, 2026

Developer - Professional is a preview entry in Anthropic's Partner Academy catalog, with eight weighted domains and no exam guide yet. This page maps the domains to documented Claude behavior; when Anthropic publishes the guide, we will revise it against the task statements. The exam guide tracks what Anthropic has announced.

Start Here

Test yourself before you read: the 20 free Developer - Professional practice questions cover all eight domains with full explanations. For timed practice, the Developer - Professional practice exams give you six Early Access forms of 70 questions each.

Exam quick facts

Exam Quick Facts

Duration
135 minutes
Cost
$175 USD
Questions
70 questions (60 scored, 10 unscored)
Passing Score
720 out of 1000 (scaled)
Valid For
12 months
Format: Pearson VUE test center or online proctored

These are the figures in Anthropic's catalog listing. Registration has not opened, and Anthropic has not given the exam a code; CCDV-P is the name Preporato uses because it fits the pattern of the live exams.

Three quick Developer - Professional questions

Question 1 of 3Production Integration, Reliability, and Knowledge Grounding (20%)

During a launch, an integration that ramped from near zero to heavy traffic in minutes gets 429 rate_limit_error responses, although its usage is below the organization's per-minute limits. What should the client read to tell this case apart?

Pick one answer

Full CCDV-P set: 6 timed exams, every answer explained, $19.99 one-time.

See the practice tests
Free questions

Try 15 CCDV-P practice questions free

They come from the CCDV-P practice tests, and each option shows its explanation once you answer.

  • 6 timed practice exams
  • Every answer explained
  • A score for each domain
  • $19.99 one-time

Domain weights at a glance

Developer - Professional domain weights

DomainWeightScored questions (approx)Core focus
1: Production Integration, Reliability, and Knowledge Grounding20%12Errors and retries, limits, context windows, workspaces, grounding
2: Advanced Agent Architecture and Orchestration17%10Subagents, compaction, context editing, tool search, MCP
3: Observability and Production Monitoring12%7Usage fields, request IDs, analytics API, Claude Code telemetry
4: Evaluation Engineering and Quality Assurance12%7Success criteria, graders, release gates, hooks as checks
5: Runtime Guardrails and Production Security11%7Injection defense, permissions, sandboxing, data residency
6: Advanced Debugging and Incident Response10%6Stop reasons, mid-stream errors, cache breaks, hook loops
7: Agent Fleet Operations for Software Delivery10%6claude -p, CI, GitHub Actions, worktrees, managed settings
8: Cost and Latency Optimization at Scale8%5Caching, batches, effort, model routing, Claude Code spend

The question counts are our arithmetic on 60 scored questions. The exam domains breakdown explains each domain with a scenario and a practice build.

Domain 1: Production Integration, Reliability, and Knowledge Grounding (20%)

Errors: retry or fix

Claude API errors and the first move

Status and typeWhat it meansFirst move
400 invalid_request_errorSomething in the request is wrong, including input alone larger than the context window (prompt is too long)Fix the request; retrying it unchanged fails again
401 authentication_error / 403 permission_errorBad key, or the key lacks access to the resourceCheck the key, its workspace and organization access
413 request_too_largeOver the byte limit: 128 MB for Messages and token counting, 256 MB for batches, 500 MB for FilesShrink the request or move large inputs to the Files API
429 rate_limit_errorRate limit, ramp limit (ramp_limit_exceeded) or monthly spend capHonor retry-after; a spend-cap 429 has none, so retrying will not help
500 api_errorUnexpected internal errorRetry with exponential backoff; contact support with the request ID if it persists
504 timeout_errorThe request timed out while processingStream long requests or use batches
529 overloaded_errorThe API is temporarily overloaded across usersRetry with exponential backoff
  • The official SDKs retry connection errors, rate limits and 5xx errors with exponential backoff twice by default, honoring retry-after. The count is configurable with max_retries.
  • Every response carries a request-id header. Log it: it is how Anthropic support finds a request.
  • A request that may run longer than 10 minutes belongs on streaming or the Message Batches API, because idle connections can be dropped.
  • Errors can also arrive mid-stream after a 200 response, so a streaming client has to handle error events as well as HTTP status codes.

Context window rules

  • Input alone over the window: 400 "prompt is too long" on every model. Lowering max_tokens does not help.
  • Input plus max_tokens over the window: accepted on Claude 4.5 and newer models; generation that reaches the window stops with model_context_window_exceeded. Treat that response as truncated.
  • Count tokens before sending with the token counting endpoint when inputs vary in size.

Limits and workspaces

  • Rate limits are measured in requests, input tokens and output tokens per minute. The default input-token limits count only uncached input: cache_read_input_tokens do not count toward ITPM, while cache writes do.
  • Every organization has a Default Workspace that cannot be renamed, archived or deleted, and spend limits cannot be set on it. Give production its own workspace to cap it.
  • Workspace limits can keep a workspace below the organization's limits but cannot raise them. Organization-wide limits always apply.

Grounding and connectors

  • Citations and search result content blocks tie answers to passages a reviewer can check.
  • MCP connector toolsets merge per-tool configs over default_config over system defaults. default_config: {"enabled": false} plus named tools is the allowlist pattern, and a misspelled tool name only logs a backend warning.
  • Web fetch url_sources filters: under except, a tool added later counts as a source; under only, it does not. A URL seen only in excluded sources returns url_not_in_prior_context.

Domain 2: Advanced Agent Architecture and Orchestration (17%)

Context that outgrows the window

Context management options

FeatureWhat it doesRule to remember
Context editing (clear_tool_uses_20250919)Clears old tool results once context passes your thresholdPairs with heavy tool use; clear_thinking_20251015 manages old thinking blocks
Threshold compaction (compact_20260112)Summarizes the conversation server-side when a threshold is reachedCannot be sent with context_management on the same request
On-demand compaction (compact-2026-09-04 beta)You ask for a signed summary block when you decide to compactCheck support with the Models API: capabilities.compaction
Memory toolLets Claude write and read files that persist across sessionsDurable knowledge outside the context window
  • The SDK tool runner leaves context_management out of the compaction request and sends it again on later requests, so the two features coexist in one agent.

Subagents and forks

  • A subagent starts with a fresh context and returns its result; keep its return compact so the orchestrator's context does not fill with raw output.
  • A fork copies the conversation so far. From Claude Code v2.1.302, Claude can start one with subagent_type: "fork" without any configuration. Block forks alone with an Agent(fork) deny rule.
  • A subagent with no effort field runs at the session's effort only when it uses the main conversation's model. On another model, set effort in its definition.

Tools at scale

  • Tool search pays off at 10 or more tools or over 10,000 tokens of definitions. For a few small tools used on every request, standard tool calling fits better.
  • At least one tool must stay non-deferred, and a regex pattern over 200 characters comes back as invalid_tool_input in a 200 response.
  • In Claude Code, "alwaysLoad": true exempts one MCP server from deferral; ENABLE_TOOL_SEARCH=false loads every tool upfront.
  • Plugin MCP tools are named mcp__plugin_<plugin-name>_<server-name>__<tool-name>, and allow rules must use that full form.
  • With programmatic tool calling, each tool_use block's caller.tool_id names the code execution block that issued it.

Domain 3: Observability and Production Monitoring (12%)

  • Per request: log the usage object (input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens), the model, the request-id, and your own tenant and feature tags. Cost per request is then a sum you control.
  • Cache hit rate: cache reads divided by all input tokens. A sudden drop after a deploy usually means the cached prefix changed.
  • Organization reporting: the Usage and Cost Analytics API. Data typically refreshes within 4 hours and can take up to 24, and values can be revised until about 7 days after the end of the month, so query final totals only for months that ended at least a week ago.
  • Keyless usage: requests from the Claude Console or with a Workload Identity Federation token have api_key_id: null. Add an empty entry, api_key_ids[]=, to include them in a key filter.
  • Claude Code telemetry: CLAUDE_CODE_ENABLE_TELEMETRY=1 exports OpenTelemetry metrics such as claude_code.session.count, claude_code.token.usage and claude_code.cost.usage, and events such as claude_code.api_error and claude_code.tool_decision. Enforce it through managed settings.
  • /usage in Claude Code: "rate limited until" a time means plan-limit data cannot be fetched until then. Work continues, and the bars shown are the last ones loaded within 60 minutes.

Domain 4: Evaluation Engineering and Quality Assurance (12%)

  • Success criteria are specific, measurable, achievable and relevant. Test sets mirror the real task distribution, edge cases included, and many automatically graded cases beat a few hand-graded ones.
  • Grading methods, fastest first: code-based (exact match, string checks), LLM-based, then human review for what automation cannot judge.
  • LLM graders: detailed rubrics, an empirical output such as a label or a 1 to 5 score, and a grader with thinking on so it reasons before scoring. Anthropic suggests a different model as the grader than the one that produced the output.
  • Release gates: run the eval set on every prompt, model or tool change in CI and fail the merge on a regression.

Claude Code hooks as automated checks

Hook typeWhat it doesRule to remember
Command hookRuns a script; exit code 2 blocks on events that support itThe recommended type for production gates
Prompt hookA model judges a condition and returns ok true or falseOn PreToolUse and PostToolUse, ok false ends the turn unless continueOnBlock is true
Agent hookA subagent with tools verifies a conditionExperimental; ok false behaves like a prompt hook with continueOnBlock true, and it has no continueOnBlock field
  • On UserPromptSubmit, a prompt hook's ok: false ends the turn and shows the reason as a warning line.
  • On Stop, ok: false feeds the reason back as Claude's next instruction, unless the response also sets impossible: true.

Domain 5: Runtime Guardrails and Production Security (11%)

Layered defenses for tool-using agents

  • Untrusted content (email, web pages, retrieved documents) goes into tool results as data, never into the system prompt.
  • Least-privilege tools: an agent that reads outside content gets no tool for irreversible actions, and money-moving steps need approval enforced in code.
  • Strict tool use keeps tool inputs valid against their schema.
  • A refusal stop reason arrives as an HTTP 200 with stop_details naming the category; handle it as an outcome in its own right.

Claude Code permissions

Claude Code permission modes

ModeRuns without askingFits
default (Manual)Reads onlySensitive work, reviewing every action
acceptEditsReads, file edits, common filesystem commandsIterating on code you review
planReads, plus classifier-approved commands when auto mode is availableExploring before changing
autoEverything, with background classifier checksLong tasks with less prompting
dontAskReads in working directories and pre-approved tools; anything else is deniedLocked-down CI
bypassPermissionsEverythingIsolated containers and VMs only
  • Rules evaluate deny, then ask, then allow. An allow rule cannot carve an exception out of a deny rule.
  • Settings precedence, highest first: managed, command line (--settings), project local, shared project, user. List keys such as permissions.allow merge across files.
  • Auto mode falls back to prompting after 3 consecutive or 20 total classifier blocks; neither number is configurable.
  • sandbox.excludedCommands uses Bash rule syntax: "docker" matches only a bare docker, "docker *" matches it with arguments.

Data residency

  • Workspace geo governs where data is stored at rest and endpoint processing; inference_geo decides where inference runs.
  • inference_geo: "us" costs 1.1x on Claude 4.6 and later models. On Claude Models on Google Cloud (Anthropic managed), every workspace allows all geos with global as the default, so US-only inference is set per request.
  • With Remote Control, execution and files stay on the local machine; traffic goes through the Anthropic API over TLS, and the transcript is stored on Anthropic servers while connected.

Domain 6: Advanced Debugging and Incident Response (10%)

Stop reasons and what to do

stop_reasonWhen it occursWhat to do
end_turnClaude finished naturallyUse the response; an empty end_turn after tool results usually means text was added after the tool results
max_tokensThe response reached your max_tokensRaise max_tokens or continue the response
stop_sequenceOne of your stop_sequences firedRead stop_sequence to see which
tool_useClaude is calling a client toolRun it and return the result
pause_turnA server-tool loop hit its iteration limit (10 by default)Send the assistant content back as it is
refusalClaude declinedRead stop_details; retry on a fallback model if appropriate
model_context_window_exceededThe response filled the context windowTreat it as truncated
  • Clean error dashboards, broken answers: check stop_reason first. A cut-off answer with no failed request is a budget problem that a retry policy cannot fix.
  • Cost spike after a deploy: a cache hit needs an identical prefix, and a change in tool definitions invalidates every cache level.
  • Thinking configuration 400s: Claude Sonnet 5.5 rejects thinking: {type: "disabled"}; its lowest setting is between_tools, which takes no other field and is accepted only at effort high or below.
  • Stop hook loops: after 8 consecutive Stop hook continuations with no tool call between them, Claude Code overrides the next block and ends the turn. CLAUDE_CODE_STOP_HOOK_BLOCK_CAP raises the cap, and hooks should check stop_hook_active.
  • SessionEnd hooks share a 1.5-second budget by default; a longer per-hook timeout raises it, up to 60 seconds.

Domain 7: Agent Fleet Operations for Software Delivery (10%)

claude -p flags for unattended runs

Flag or variableWhat it does
--bareSkips locally discovered hooks, plugins, MCP servers and CLAUDE.md; recommended for scripted runs
--permission-mode dontAskDenies anything not pre-approved instead of waiting on a prompt
--allowedToolsPre-approves tools with permission-rule syntax, such as Bash(npm test)
--max-budget-usdStops the run at an estimated spend cap; it also stops background subagents instead of waiting
--output-format jsonReturns the result with total_cost_usd and structured_output for the pipeline
CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MSChanges the 10-minute cap on waiting for background work after the final turn
  • Piped stdin is capped at 10 MB. For larger inputs, write a file and name its path in the prompt.
  • A run that hangs until the CI timeout is usually waiting on a permission prompt nobody can answer. Set the mode and the allowed tools explicitly.
  • GitHub Actions v1: mode is gone (detected automatically), direct_prompt became prompt, CLI options move into claude_args, and custom_instructions becomes --append-system-prompt. The default trigger is @claude as a whole word, from a commenter with write access. use_bedrock, use_vertex and use_foundry authenticate with OIDC instead of stored keys.
  • Worktrees: Claude Code skips repository-local filter drivers when it creates worktrees (run git lfs pull there) and checks out with GIT_NO_REPLACE_OBJECTS=1. A worktree without its own .claude/skills reads the main checkout's.
  • Organization control: maxEffortLevel in managed settings caps effort from every source, and when several scopes set a cap, the lowest applies.

Domain 8: Cost and Latency Optimization at Scale (8%)

Cost levers and their rules

LeverPrice effectRule to remember
Prompt caching5-minute writes 1.25x base input, 1-hour writes 2x, reads a small fractionUp to 4 breakpoints; each read refreshes the entry at no extra cost
Automatic cachingSame prices, top-level cache_controlThe breakpoint moves to the last cacheable block each request; an explicit breakpoint there with a different TTL returns 400
Message Batches API50% lower costMost batches finish within an hour; results kept 29 days; expired requests are not billed; use the 1-hour cache TTL for shared prefixes
Model routing and effortLower price per token, fewer thinking tokensRun an eval before moving traffic to a smaller model
Tool searchFewer definition tokens per requestWorth it at 10+ tools or over 10,000 tokens of definitions
  • Thinking blocks from earlier assistant turns are cached with the conversation and count as input tokens when read from the cache. Long agent loops have to budget for them.
  • Claude Code spend on API billing is driven most by long sessions that are never cleared and Opus left as the default for every task. Clear between unrelated tasks and match the model to the job.
  • Under a Fable parent with subscription, Console or gateway sign-in, the built-in Explore subagent runs on the opus alias. A user or project subagent named Explore with its own model overrides it.

Trap answers to watch for

  • Retrying a 400. An invalid request fails the same way every time. Retries belong to 429, 500 and 529.
  • Lowering max_tokens for "prompt is too long". The input alone is over the window; trim or split it.
  • A bigger model for a context problem. A larger window moves the cliff. Compact summaries from subagents, context editing and compaction fix it.
  • An allow rule to unblock a denied command. Deny wins regardless of specificity.
  • User settings to escape a managed cap. Managed settings sit at the top, and effort caps apply at the lowest value across scopes.
  • Asking the model to grade itself. A separate grader, with a rubric and thinking on, is the guidance.
  • Treating pause_turn as an error. Send the content back and the turn continues.
  • "The prompt says don't" as a security control. Enforcement comes from tools, permissions and code-level approvals.

Final-week checklist

Developer - Professional Final-Week Checklist

0/17 completed

Next steps

Use this page as the last read before a practice session. Work through the 20 free practice questions, check the domains behind any miss in the exam domains breakdown, and schedule the rest with the 6-week study plan. For timed practice, take a full form from the Developer - Professional practice exams.

Ready to practice?

Six Early Access practice exams, 70 questions each in 135 minutes, written to the weights Anthropic lists, with an explanation on every answer option. When Anthropic publishes the exam guide, we revise them to match. See the Developer - Professional practice exams.

Frequently asked questions

Sources:

CCDV-P
6 Practice Exams
Detailed Explanations
Performance Analytics
Get Full Access - $19.99See what's included →

CCDV-P · 6 practice exams

$19.99one-time

Get full access