Launch Deal · 50% off 1st month ·
← CCDV-F study guide

CCDV-F exam topics

The CCDV-F exam (Claude Certified Developer (Foundations)) covers 8 domains and 25 topics. This page lists all of them with the weight of each domain, so you can see what the exam tests and where most of the marks are.

Domains and weights

DomainWeightTopics
Domain 1: Agents & workflows14.7%3
Domain 2: Applications & integration33.1%6
Domain 3: Claude Code3.1%1
Domain 4: Eval, testing & debugging2.6%1
Domain 5: Model selection & optimisation16.8%4
Domain 6: Prompt & context engineering11%3
Domain 7: Security & safety8.1%4
Domain 8: Tools & MCPs10.6%3

Domain 1: Agents & workflows · 14.7%

  • Agent Architecture

    Every agentic system starts from one decision: who owns the control flow. The Three Tiers: Augmented LLM, Workflow, Agent; The dividing line: whoever decides the next step names the tier. A hand-coded three-step chain is a workflow; a model choosing its own tool sequence is an agent.

  • Agent Construction with Claude

    An agent is a model calling tools in a loop. The harness is the code that runs the loop. A turn is one round trip. A hook is harness code that runs at a fixed point.

  • Agent Patterns and Frameworks

    An agent remembers nothing between sessions unless the design adds a mechanism. Anthropic’s memory tool (memory20250818) gives create/read/update/delete over files in /memories. Your application executes each operation client-side. Safeguards live in your handler (reject path traversal, track file sizes, cap view returns).

Domain 2: Applications & integration · 33.1%

  • Understanding Requirements

    Requirements sit on three layers: Business, Functional, Infrastructure / non-functional; The Derivation Chain: Business → functional → infrastructure. Skip a layer, or run backwards, and a requirement has nothing to trace to.

  • Systems Life Cycle

    Canonical phases and what they own: Planning and requirements; Design; Development; Testing — designing the regression eval set (derived from requirements, not reverse-engineered from incidents); Implementation and deployment — the cutover plan that swaps pilot for production (happens once); Operations and maintenance — standing cost-per-task dashboard, error triage, prompt fixes, plan for moving off a deprecated model (recurs for the life of the system); Retirement — switching off and disposing of logs; data disposition is part of this phase.

  • Claude API Mechanics

    The Messages API is how an application talks to Claude. A request needs exactly three parameters: model, maxtokens, messages. Everything else is optional. The API is stateless: the application resends the transcript every turn.

  • Software Engineering Foundations

    Serial loop wastes the rate limit. Unbounded fan-out trips the token-bucket limiter and turns the run into a 429 storm. Correct shape: worker pool or semaphore sized against documented RPM/ITPM/OTPM headroom. Transient failures retried with jittered exponential backoff honouring retry-after.

  • Claude Application Design

    Four design decisions: where instructions live, where untrusted content goes, what contract the output honours, and how sessions are scoped.

  • Configuration Management

    Configuration is anything that changes behaviour without being code. Managed exactly like code: version control, review, deployment pipeline.

Domain 3: Claude Code · 3.1%

  • Claude Code Operation

    Claude Code reads configuration from files on disk and flags on the command line. Components: rules, skills, commands, agents, agent memory. Scopes: managed, user, project, local.

Domain 4: Eval, testing & debugging · 2.6%

  • Debugging and Error Handling

    A Claude application can fail in two places: Integration layer, Model output; The fixes for the two layers do not overlap. Isolate the layer before you theorise. Log: request id, HTTP status, error.type, stopreason, usage, raw content.

Domain 5: Model selection & optimisation · 16.8%

  • LLM Fundamentals

    Claude sits on an autoregressive language model: it writes text one token at a time. Three consequences: Generation is serial — response time scales with output tokens; input length affects time-to-first-token; No lookahead, no revision — once a token is emitted it is part of the record; state the output contract up front; Early wrong turns compound — each token conditions the next.

  • Technical Fundamentals

    A Claude application talks to the API over HTTP with JSON. Official SDKs wrap the wire in seven languages (Python, TypeScript, C, Go, Java, PHP, Ruby) plus the ant CLI.

  • Model Selection and Trade-offs

    Haiku → Sonnet → Opus → Frontier. Quality, latency and cost are not independent. Moving up buys capability and spends money and time. Haiku, Sonnet, Opus, Frontier.

  • Cost and Token Management

    Every response carries a usage object: inputtokens, cachecreationinputtokens, cachereadinputtokens, outputtokens. Output is priced several times input. Identify which axis dominates before choosing a lever.

Domain 6: Prompt & context engineering · 11%

  • Context Engineering

    Context engineering is “the set of strategies for curating and maintaining the optimal set of tokens during LLM inference.” Prompt engineering asks what the instructions say; context engineering asks what is in the window at all.

  • Prompt Engineering

    Four choices: where an instruction sits, how clearly it is worded, what output shape it asks for, and how incoming material is marked off. Test one change at a time.

  • Output Handling

    Structured output is a reply in a fixed shape (usually JSON matching a schema). Well-formed = parses and matches the shape. Correct = values are right.

Domain 7: Security & safety · 8.1%

  • AI Application Security

    Prompt injection is text that tries to give Claude instructions it should not follow. One context, no channel separation — nothing structural separates commands from data.

  • Guardrails and Safe Deployment

    A guardrail is a check with an enforcement point. A behaviour shaper is different: the model reads something and decides. Ask three questions: What does it inspect? Where does the code run? What happens when it fires?

  • Claude Hooks

    A hook is your own code, wired to a named point in the agent’s lifecycle. It gives deterministic control: certain actions always happen rather than relying on the LLM to choose.

  • Identity, Secrets, and Key Management

    Three jobs: managing secrets/credentials/API keys; identity validation and authentication; authorised access monitoring.

Domain 8: Tools & MCPs · 10.6%

  • Tool Implementation

    A tool is an action Claude can ask for. A tool you define has three parts: name, description, inputschema. When the model decides whether to call a tool, it reads only those three surfaces. If it chose badly, the information it needed was missing from one of them.

  • MCP Server Development

    MCP is a standard protocol for connecting an application to an outside system. An MCP server wraps the system and offers capabilities. Tools a server offers are ordinary tools — everything in 8.1 applies.

  • Agentic Customisation

    Four mechanisms: built-in tools, custom tools, Skills, MCP servers. This sub-skill is choosing between them.

CCDV-F exam facts

Questions53
Time limit120 minutes
Question formatMultiple-choice and multiple-response
Passing score720 on a scale of 1,000
Exam fee$125 USD
Certification valid for12 months

Study these topics

Skillmarked is independent and not affiliated with Anthropic. The topic list follows the public exam outline; check the official exam page for the current version before you book.