Prep for the Claude Certified Developer – Foundations exam (CCDV-F): integrating Claude through the API, building agents and MCP servers, model selection and cost, prompt and context engineering, and security — run-verified against anthropic 0.120, the Agent SDK, Strands, and PydanticAI.
An orientation to the Claude Certified Developer – Foundations exam (CCDV-F): the eight weighted domains, how it differs from the Architect exam, the running application this series builds, and the run-everything verification convention behind every code sample.
The request and response shapes of the Claude Messages API — roles, system, sampling, the full stop_reason set, the usage object as it actually comes back, count_tokens, and multi-turn structure.
Server-sent events from the Messages API — the message_start / content_block / message_delta / message_stop lifecycle, how a tool call arrives as input_json_delta fragments you accumulate and parse at the stop, and the SDK helpers that do the bookkeeping.
Multi-format input — images as base64, URL, or file_id; PDFs as document blocks; the Files API for upload-once-reference-many; and what a picture or a page actually costs in tokens.
The Claude SDK exception taxonomy with real status codes, which errors are your bug versus the network's, what the SDK retries automatically, and building a client that degrades gracefully.
How Claude reads instructions across its interfaces, drawing content boundaries against untrusted input, schema and session hygiene, and the configuration that keeps a deployment reproducible — CLAUDE.md, settings.json, model pinning, and prompt versioning.
The architectural choice that precedes writing any agent — a workflow's code-controlled path versus an agent's model-controlled loop, the decision criteria between them, and where supervisor hierarchies and subagents fit — contrasted with runnable examples.
Constructing Claude agents — the custom loop you write yourself, the Tool Runner that loops over your tools, and the Agent SDK's full harness — plus self-hosted versus managed deployment and hooks for the deterministic actions you don't want the model deciding.
The agent frameworks worth knowing — LangGraph, Strands, and PydanticAI — each building the identical bookshop agent, their abstractions compared, and when a framework earns its dependency over the Agent SDK or a custom loop.
Implementing tools an agent uses well — the definition shape and why the description does the work, client-side versus server-side tools, the tool-result and error contract, approval patterns for sensitive actions, and the best practices for a tool set the model chooses correctly.
The Model Context Protocol — why a capability shared across apps wants a server, the three primitives (tools, resources, prompts), authoring one with FastMCP, the stdio and HTTP transports, and how a Claude application connects to it.
The four ways to extend Claude — built-in tools, custom tools, Skills, and MCP servers — what each is really for, the axes that separate them (reusability, effort, capability vs. knowledge), and a decision guide worked through real scenarios.
The LLM fundamentals a developer has to hold — tokens and the context window, next-token sampling and what temperature really does, whether temperature 0 is deterministic, and the extended-thinking modes (enabled vs. adaptive).
The model tiers and the quality-latency-cost triangle you're really deciding, why capabilities differ across models (a rejection), the breaking changes that bite on a model upgrade, and a selection strategy that starts cheap and escalates.
Tracking spend from the usage object, modeling cost from input and output rates, and prompt caching — the request shape, the minimum-token threshold that silently skips it, and a cache read that billed 15,602 tokens at a tenth of their price.
Prompt engineering for developers — instruction clarity over hedges, few-shot examples that fix format and generalize judgment, system-versus-user placement, output constraints, where instructions live across components, and iterative refinement.
Context engineering — window management, drift and bloat from accumulating tool output, and isolation via subagents — plus output handling: guaranteeing structure with the parse helper and tool use, defensive parsing, and healthy skepticism toward confident output.
AI application security — prompt injection and why you can't rely on the model to resist it, treating all external input as untrusted, jailbreaks, data leakage and PII, and enforcing authorization in code rather than in the prompt.
Layered guardrails and secure-by-design defaults, hooks as the deterministic enforcement point for destructive actions, and managing secrets and API keys across development and production — least privilege, no keys in code, and identity you verify.
Claude Code's components and modes — Rules, Skills, Commands, Agents, Memory, the CLAUDE.md and settings hierarchy, headless and streaming and auto modes — and the debugging discipline of isolating a failure between the integration layer and the model.
The whole blueprint in one system — a production bookshop assistant that exercises API integration, agents, tools and MCP, model selection, prompt and context engineering, security, and operations — followed by the exam's three sample questions worked with their rationale.