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
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
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?
Ramp limits can return 429s during a sharp rise in traffic even below the steady-state limits. The error type is rate_limit_error, the same as for a rate limit, so on the Messages API the field that tells them apart is error.details.error_code with the value ramp_limit_exceeded. A confuses it with the tier spend-cap 429, the one that has no retry-after header. C and D describe signals that do not identify ramp limiting.
A research feature uses the web search server tool. Some responses end with stop_reason: "pause_turn", and the last block is a server_tool_use with no result. The client treats these as failures and retries the original request from scratch. What should it do?
pause_turn means the server-side sampling loop reached its iteration limit, 10 iterations per request by default, while running server tools. Sending the response back as it is lets Claude finish; retrying from scratch throws the finished work away. A describes max_tokens. B is wrong because server tools run on Anthropic's side, and a client tool waiting on you stops with tool_use. C invents a streaming rule.
A platform team's managed settings deny Bash(aws *). A project's .claude/settings.json allows Bash(aws s3 ls) so Claude can list buckets, but every aws s3 ls call is still blocked. Why?
Permission rules are evaluated in order, deny, then ask, then allow, and the first match in that order decides, whatever the specificity. A broad deny such as Bash(aws *) blocks every matching call, including one that a narrower allow rule names. B and C invent restrictions. D is wrong because list keys such as permissions.allow merge across files; the order of evaluation is what blocks the call.
Full CCDV-P set: 6 timed exams, every answer explained, $19.99 one-time.
See the practice testsTry 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
| Domain | Weight | Scored questions (approx) | Core focus |
|---|---|---|---|
| 1: Production Integration, Reliability, and Knowledge Grounding | 20% | 12 | Errors and retries, limits, context windows, workspaces, grounding |
| 2: Advanced Agent Architecture and Orchestration | 17% | 10 | Subagents, compaction, context editing, tool search, MCP |
| 3: Observability and Production Monitoring | 12% | 7 | Usage fields, request IDs, analytics API, Claude Code telemetry |
| 4: Evaluation Engineering and Quality Assurance | 12% | 7 | Success criteria, graders, release gates, hooks as checks |
| 5: Runtime Guardrails and Production Security | 11% | 7 | Injection defense, permissions, sandboxing, data residency |
| 6: Advanced Debugging and Incident Response | 10% | 6 | Stop reasons, mid-stream errors, cache breaks, hook loops |
| 7: Agent Fleet Operations for Software Delivery | 10% | 6 | claude -p, CI, GitHub Actions, worktrees, managed settings |
| 8: Cost and Latency Optimization at Scale | 8% | 5 | Caching, 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 type | What it means | First move |
|---|---|---|
| 400 invalid_request_error | Something 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_error | Bad key, or the key lacks access to the resource | Check the key, its workspace and organization access |
| 413 request_too_large | Over the byte limit: 128 MB for Messages and token counting, 256 MB for batches, 500 MB for Files | Shrink the request or move large inputs to the Files API |
| 429 rate_limit_error | Rate limit, ramp limit (ramp_limit_exceeded) or monthly spend cap | Honor retry-after; a spend-cap 429 has none, so retrying will not help |
| 500 api_error | Unexpected internal error | Retry with exponential backoff; contact support with the request ID if it persists |
| 504 timeout_error | The request timed out while processing | Stream long requests or use batches |
| 529 overloaded_error | The API is temporarily overloaded across users | Retry 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 withmax_retries. - Every response carries a
request-idheader. 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_tokensdoes not help. - Input plus
max_tokensover the window: accepted on Claude 4.5 and newer models; generation that reaches the window stops withmodel_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_tokensdo 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
configsoverdefault_configover 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_sourcesfilters: underexcept, a tool added later counts as a source; underonly, it does not. A URL seen only in excluded sources returnsurl_not_in_prior_context.
Domain 2: Advanced Agent Architecture and Orchestration (17%)
Context that outgrows the window
Context management options
| Feature | What it does | Rule to remember |
|---|---|---|
| Context editing (clear_tool_uses_20250919) | Clears old tool results once context passes your threshold | Pairs with heavy tool use; clear_thinking_20251015 manages old thinking blocks |
| Threshold compaction (compact_20260112) | Summarizes the conversation server-side when a threshold is reached | Cannot 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 compact | Check support with the Models API: capabilities.compaction |
| Memory tool | Lets Claude write and read files that persist across sessions | Durable knowledge outside the context window |
- The SDK tool runner leaves
context_managementout 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 anAgent(fork)deny rule. - A subagent with no
effortfield 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_inputin a 200 response. - In Claude Code,
"alwaysLoad": trueexempts one MCP server from deferral;ENABLE_TOOL_SEARCH=falseloads 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_useblock'scaller.tool_idnames the code execution block that issued it.
Domain 3: Observability and Production Monitoring (12%)
- Per request: log the
usageobject (input_tokens,output_tokens,cache_creation_input_tokens,cache_read_input_tokens), the model, therequest-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=1exports OpenTelemetry metrics such asclaude_code.session.count,claude_code.token.usageandclaude_code.cost.usage, and events such asclaude_code.api_errorandclaude_code.tool_decision. Enforce it through managed settings. /usagein 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 type | What it does | Rule to remember |
|---|---|---|
| Command hook | Runs a script; exit code 2 blocks on events that support it | The recommended type for production gates |
| Prompt hook | A model judges a condition and returns ok true or false | On PreToolUse and PostToolUse, ok false ends the turn unless continueOnBlock is true |
| Agent hook | A subagent with tools verifies a condition | Experimental; ok false behaves like a prompt hook with continueOnBlock true, and it has no continueOnBlock field |
- On
UserPromptSubmit, a prompt hook'sok: falseends the turn and shows the reason as a warning line. - On
Stop,ok: falsefeeds the reason back as Claude's next instruction, unless the response also setsimpossible: 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
refusalstop reason arrives as an HTTP 200 withstop_detailsnaming the category; handle it as an outcome in its own right.
Claude Code permissions
Claude Code permission modes
| Mode | Runs without asking | Fits |
|---|---|---|
| default (Manual) | Reads only | Sensitive work, reviewing every action |
| acceptEdits | Reads, file edits, common filesystem commands | Iterating on code you review |
| plan | Reads, plus classifier-approved commands when auto mode is available | Exploring before changing |
| auto | Everything, with background classifier checks | Long tasks with less prompting |
| dontAsk | Reads in working directories and pre-approved tools; anything else is denied | Locked-down CI |
| bypassPermissions | Everything | Isolated 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 aspermissions.allowmerge across files. - Auto mode falls back to prompting after 3 consecutive or 20 total classifier blocks; neither number is configurable.
sandbox.excludedCommandsuses Bash rule syntax:"docker"matches only a baredocker,"docker *"matches it with arguments.
Data residency
- Workspace geo governs where data is stored at rest and endpoint processing;
inference_geodecides 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_reason | When it occurs | What to do |
|---|---|---|
| end_turn | Claude finished naturally | Use the response; an empty end_turn after tool results usually means text was added after the tool results |
| max_tokens | The response reached your max_tokens | Raise max_tokens or continue the response |
| stop_sequence | One of your stop_sequences fired | Read stop_sequence to see which |
| tool_use | Claude is calling a client tool | Run it and return the result |
| pause_turn | A server-tool loop hit its iteration limit (10 by default) | Send the assistant content back as it is |
| refusal | Claude declined | Read stop_details; retry on a fallback model if appropriate |
| model_context_window_exceeded | The response filled the context window | Treat it as truncated |
- Clean error dashboards, broken answers: check
stop_reasonfirst. 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 isbetween_tools, which takes no other field and is accepted only at efforthighor 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_CAPraises the cap, and hooks should checkstop_hook_active. - SessionEnd hooks share a 1.5-second budget by default; a longer per-hook
timeoutraises it, up to 60 seconds.
Domain 7: Agent Fleet Operations for Software Delivery (10%)
claude -p flags for unattended runs
| Flag or variable | What it does |
|---|---|
| --bare | Skips locally discovered hooks, plugins, MCP servers and CLAUDE.md; recommended for scripted runs |
| --permission-mode dontAsk | Denies anything not pre-approved instead of waiting on a prompt |
| --allowedTools | Pre-approves tools with permission-rule syntax, such as Bash(npm test) |
| --max-budget-usd | Stops the run at an estimated spend cap; it also stops background subagents instead of waiting |
| --output-format json | Returns the result with total_cost_usd and structured_output for the pipeline |
| CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS | Changes 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:
modeis gone (detected automatically),direct_promptbecameprompt, CLI options move intoclaude_args, andcustom_instructionsbecomes--append-system-prompt. The default trigger is@claudeas a whole word, from a commenter with write access.use_bedrock,use_vertexanduse_foundryauthenticate with OIDC instead of stored keys. - Worktrees: Claude Code skips repository-local filter drivers when it creates worktrees (run
git lfs pullthere) and checks out withGIT_NO_REPLACE_OBJECTS=1. A worktree without its own.claude/skillsreads the main checkout's. - Organization control:
maxEffortLevelin 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
| Lever | Price effect | Rule to remember |
|---|---|---|
| Prompt caching | 5-minute writes 1.25x base input, 1-hour writes 2x, reads a small fraction | Up to 4 breakpoints; each read refreshes the entry at no extra cost |
| Automatic caching | Same prices, top-level cache_control | The breakpoint moves to the last cacheable block each request; an explicit breakpoint there with a different TTL returns 400 |
| Message Batches API | 50% lower cost | Most 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 effort | Lower price per token, fewer thinking tokens | Run an eval before moving traffic to a smaller model |
| Tool search | Fewer definition tokens per request | Worth 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
modeloverrides 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_tokensfor "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_turnas 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 completedNext 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:
- Claude API errors and rate limits
- Context windows and handling stop reasons
- Workspaces and data residency
- MCP connector and web fetch tool
- Context editing, compaction and compaction on demand
- Tool search tool and programmatic tool calling
- Usage and Cost Analytics API
- Define success and build evaluations
- Prompt caching, batch processing and thinking
- Claude Code: hooks, permissions, permission modes, settings, headless runs, GitHub Actions, worktrees, monitoring usage, costs, MCP and security