CCDV-F readiness: can Ben sit it tomorrow with no prep?
Verdict: coin flip, leaning pass. Roughly 55% to pass tomorrow cold. About 10 hours of targeted prep gets him to about 85%+.
The reason is structural, not a skill gap. The CCA-F exam guide's explicit out-of-scope list (streaming/SSE, vision, prompt caching beyond "it exists", token counting, rate limits/pricing, MCP hosting, auth/key details) reads almost line-for-line like the CCDV-F in-scope list. CCA-F rewarded architecture judgment; CCDV-F adds a raw-API layer that daily Claude Code use never touches. The vault already shows this exact gap: "D3 API specifics" (Message Batches "no clue", tool_choice, prefill) was his recurring CCA-F weak area from the first quiz on 2026-06-10 through practice exam 2 and the 2026-07-30 diagnostic (D4 at 60%, his lowest domain) — full log in [[cert-progress]].
1. Exam facts (quoted from the guide)
| Item | Guide text |
|---|---|
| Exam code | CCDV-F |
| Number of items | 53 |
| Item format | "Multiple-choice and multiple-response items; each item states how many responses to select" |
| Time limit | 120 minutes |
| Passing score | "Scaled score of 720 on a scale of 100–1,000" |
| Exam fee | $125 USD |
| Validity | "12 months from the date the credential is awarded" |
| Result reporting | "Pass/fail with scaled score (100–1,000), plus percent-correct by domain on the score report" |
| Retakes | 14 days after 1st fail, 30 after 2nd, 90 after 3rd; max 4 attempts per rolling 12 months; fee per attempt |
| Scheduling | Cancel/reschedule up to 24 hours before; inside 24h forfeits the fee |
Note on "tomorrow": the 24-hour reschedule rule means a booking for tomorrow is effectively locked once made.
Domains and weights (exact)
| # | Domain | Weight | ~Items of 53 |
|---|---|---|---|
| 1 | Agents and Workflows | 14.7% | ~8 |
| 2 | Applications and Integration | 33.1% | ~18 |
| 3 | Claude Code | 3.1% | ~2 |
| 4 | Eval, Testing, and Debugging | 2.6% | ~1 |
| 5 | Model Selection and Optimization | 16.8% | ~9 |
| 6 | Prompt and Context Engineering | 11.0% | ~6 |
| 7 | Security and Safety | 8.1% | ~4 |
| 8 | Tools and MCPs | 10.6% | ~6 |
Sub-skills (exact weights): D1 = Agent Architecture 4.5% · Agent Construction with Claude 5.3% · Agent Patterns and Frameworks 4.9%. D2 = Understanding Requirements 3.4% · Systems Life Cycle 2.8% · Claude API Mechanics 6.8% · Software Engineering Foundations 7.4% · Claude Application Design 8.6% · Configuration Management 4.1%. D3 = Claude Code Operation 3.1%. D4 = Debugging and Error Handling 2.6%. D5 = LLM Fundamentals 5.2% · Technical Fundamentals 6.1% · Model Selection and Tradeoffs 2.7% · Cost and Token Management 2.8%. D6 = Context Engineering 3.8% · Prompt Engineering 4.6% · Output Handling 2.6%. D7 = AI Application Security 3.2% · Guardrails and Safe Deployment 2.3% · Claude Hooks 1.0% · Identity, Secrets, and Key Management 1.6%. D8 = Tool Implementation 4.4% · MCP Server Development 2.1% · Agentic Customization 4.1%.
Shape vs CCA-F: CCA-F was 60 Q, with Claude Code Config at 20% of the exam. Here Claude Code, his strongest ground, is 3.1% (~2 items). The single biggest domain (D2, a third of the exam) is application/API/software engineering.
2. Domain-by-domain: overlap and readiness
CCA-F reference domains: D1 Agentic Architecture 27% · D2 Tool Design & MCP 18% · D3 Claude Code Config 20% · D4 Prompt Eng & Structured Output 20% · D5 Context Mgmt & Reliability 15%.
| # | Domain (weight) | Overlap w/ CCA-F | Readiness | Why |
|---|---|---|---|---|
| 1 | Agents and Workflows (14.7%) | High | Green (est. 80%) | Workflow-vs-agent, supervisor hierarchies, subagents = CCA-F D1 core. Gaps: Agent SDK specifics, "managed agent deployment models (self-hosted vs. Anthropic-hosted)" (Managed Agents: thinking only, never set up), and named frameworks "Strands, LangGraph, PydanticAI" he has not used. |
| 2 | Applications and Integration (33.1%) | Low-Med | Yellow (est. 70%) | Requirements + life cycle + config mgmt are SA home turf (green). API Mechanics 6.8% is red: messages, streaming, vision, thinking, caching, Bedrock/Vertex invocation, batch: all CCA-F out-of-scope or his logged weak area. SW Eng Foundations 7.4% (async, refactoring, code review) is yellow for an advisor-mode architect. |
| 3 | Claude Code (3.1%) | High | Green (est. 90%) | Daily operator; CLAUDE.md hierarchy, settings.json, skills, headless, auto-mode. Only ~2 items, so worth little. |
| 4 | Eval, Testing, and Debugging (2.6%) | Med | Yellow (est. 65%) | Despite the name, it's only "Debugging and Error Handling": error-type identification and recovery choice. Needs API error classes (400/401/403/404/413/429/500/529 overloaded), retry/backoff, integration-layer vs model-output isolation. Note evals proper are not a weighted sub-skill despite appearing in Section 2. |
| 5 | Model Selection and Optimization (16.8%) | Low | Red (est. 60%) | Biggest risk. CCA-F explicitly excluded pricing, caching mechanics, and tokenization. Here: sampling/non-determinism, "fast mode, extended thinking, adaptive thinking, effort levels", SDKs + websockets, Opus/Sonnet/Haiku tradeoffs, "breaking behavior changes across model releases", token usage tracking, "prompt caching, cache check-pointing". He uses these via Claude Code but never sets the parameters. |
| 6 | Prompt and Context Engineering (11.0%) | High | Green (est. 85%) | CCA-F D4 + D5 combined; context pruning, compaction, subagent isolation are what his harness does. One caveat: Output Handling (structured outputs, defensive parsing) maps to his CCA-F weakest area (tool_choice/prefill misses, D4 diagnostic 60%). |
| 7 | Security and Safety (8.1%) | Med | Green (est. 80%) | Prompt injection and untrusted-input handling are a standing operating rule for him; hooks overlap CCA-F (watch the recurring hook-scoping miss: a Write hook does not catch Bash writes); 1Password-wrapper discipline covers secrets. Content policy / IAM / least privilege are SA-native. |
| 8 | Tools and MCPs (10.6%) | Med-High | Yellow (est. 75%) | Tool descriptions + built-in vs custom vs Skills vs MCP tradeoffs = CCA-F D2 strength. MCP Server Development 2.1% is red: authoring and deploying a server, resources/tools/prompts primitives, stdio vs remote transports. CCA-F excluded MCP hosting; he installs and uses servers, has not authored one. Client-side vs server-side tools is also new. |
Weighted cold estimate: ~73% raw. The 720 scaled cut's raw equivalent is not published; if it sits near 70-72% raw (the CCA-F working assumption), he is on the line. CCA-F practice data (83% cold, then 70%) shows run-to-run variance of 10+ points, so the outcome is genuinely uncertain.
Hands-on API details a heavy Claude Code user would NOT naturally know
Every one of these is in scope on CCDV-F and was out of scope or a logged miss on CCA-F:
- SDK specifics: client construction,
messages.createvsmessages.stream, SDK auto-retry behavior, Python/TypeScript async clients, Bedrock and Vertex client variants and how model IDs differ there. - Request parameters:
max_tokens,system(top-level, not a message role),temperature/top_p/top_k,stop_sequences,thinkingconfig and budget, effort,metadata. - Streaming events:
message_start→content_block_start→content_block_delta(text_delta, input_json_delta, thinking_delta) →content_block_stop→message_delta(stop_reason, usage) →message_stop, pluspinganderror. CCA-F prep deliberately dropped this drill on 2026-07-02. - Message Batches: 50% cost, up to a 24-hour window, async results,
custom_idmatching, no interactive tool loop. Logged as "no clue" on 2026-06-10. - Prompt caching mechanics:
cache_controlbreakpoints (max 4), prefix order tools → system → messages, minimum cacheable length, 5-minute default TTL vs 1-hour option, cache write premium vs cheap reads,cache_creation_input_tokens/cache_read_input_tokensinusage. - Token counting: the count-tokens endpoint,
usagefields for cost modeling, context-window limits. tool_choice:auto/any/tool(forced by name) /none; parallel tool use; forced tool + schema as the reliable structured-output path. Missed twice on CCA-F (Q7 practice exam 2, Q03 diagnostic).- Stop reasons:
end_turn,max_tokens,stop_sequence,tool_use,pause_turn,refusal. - Errors and rate limits: 429 vs 529 (overloaded),
retry-after, exponential backoff, request-size limits, RPM/ITPM/OTPM style limits. - MCP server authoring: server SDK (e.g. FastMCP-style decorators), the three primitives (tools, resources, prompts), stdio vs Streamable HTTP, remote auth, capability-change notifications.
- Evaluation: test-set design, LLM-as-judge vs code-graded checks, regression on prompt/model version change. Lightly weighted here but fair game in scenario stems.
- Vision/files: image content blocks (base64 vs URL), PDF/document input.
Verify exact names and numbers against current docs.claude.com during prep. This list is from working knowledge, not re-checked today.
3. Are the sample questions representative?
The guide does not warn that the samples are easier. It says: "These illustrative items show the style and cognitive level of the exam. They are not drawn from the live item bank."
Skeptical read: they look easier than the real thing. All three samples (batch for overnight cost, untrusted-input isolation for injection, MCP server for reuse) are single-concept items with three obviously wrong distractors ("raise the temperature", "switch to the smallest model regardless of quality"). They test judgment, which is his strength, and none test a parameter name, event order, or error code. Evidence that real exams run harder than their samples: CCA-F practice exam 2 hinged on fine distinctions (layered "most-complete" answers, hook scoping), and on SnowPro GenAI he said "the test was much harder and different than what I studied for" (2026-09-28). Do not calibrate on the samples.
4. Verdict and minimal prep plan
Cold pass probability tomorrow: ~55%. Strong on judgment-style items (D1, D3, D6, D7, most of D8, the design parts of D2 = roughly 55-60% of the exam). Exposed on the parameter-level API surface (D2 API Mechanics + D5 + MCP authoring + debugging = roughly 30% of the exam), exactly where his CCA-F misses clustered.
Prep plan to ~85%+ (about 10 hours), ROI order:
| # | Topic | Hours | Method |
|---|---|---|---|
| 1 | Claude API mechanics: Messages API params, streaming event sequence, vision/PDF input, extended/adaptive thinking config, Bedrock/Vertex invocation, Message Batches | 2.5 | Write one ~60-line Python script that streams, sends an image, calls a tool, and submits a 3-item batch. Running it teaches more than reading. |
| 2 | Prompt caching + cost/token management | 1.5 | Docs page + add cache_control to the script and read usage before/after; count-tokens endpoint. |
| 3 | Model selection + LLM fundamentals: current lineup and tradeoffs, effort, fast mode, adaptive thinking, sampling params, breaking changes across releases, snapshot vs alias pinning | 1.0 | Models overview + migration notes. |
| 4 | Errors, rate limits, stop reasons, retry strategy | 0.75 | Errors + rate-limits docs; one flashcard sheet. |
| 5 | MCP server authoring: primitives, transports, deploy, auth | 1.0 | Build a 2-tool + 1-resource stdio server and connect it to Claude Code. |
| 6 | Agent SDK + Managed Agents + framework one-pagers (Strands, LangGraph, PydanticAI) | 1.0 | Agent SDK overview; one paragraph per framework on when to use it. |
| 7 | tool_choice, parallel tools, client- vs server-side tools, structured outputs |
0.5 | Refresher; this was his CCA-F repeat miss. |
| 8 | Eval + debugging patterns (integration vs model fault isolation) | 0.5 | Docs "define success / build evals" pages. |
| 9 | 50-question mixed /cert-study quiz, API-weighted, then re-drill misses |
1.0 | Same cram-day protocol that worked for CCA-F and SnowPro — quiz built as [[2026-10-20-ccdv-f-quiz-1]], fact sheet as [[2026-10-20-ccdv-f-study-sheet]], ranked links as [[2026-10-20-ccdv-f-study-resources]]. |
Total: ~9.75 hours. If time-boxed to the minimum, items 1-4 + 9 (6.75h) cover most of the risk (D2 API Mechanics + D5 ≈ 24% of the exam). Keep the CCA-F test-craft rule: on BEST / most-robust stems, choose the layered, most-complete option.
Recommendation: do not book for tomorrow. Book 3-5 days out after the 10-hour pass. A first-attempt fail costs $125 plus a 14-day wait, and the gap is narrow and well-mapped, so a short prep pass is cheap insurance.