Course · Plus
Claude certification prep
Study both of Anthropic's technical certifications in one place: the Developer Foundations exam (CCDV-F) and the Architect Foundations exam (CCAR-F). Every exam domain gets a chapter with the concepts, real config and code, exam traps and scenario practice questions.
Open the courseChapters, a study plan and timed practice exams.Chapters
1. Agents and workflows 40 min
When to build a fixed workflow and when to let an agent drive, how the tool-use loop works, and how supervisors, subagents and harnesses fit together.
- Choose between a coded workflow and an autonomous agent for a given requirement
- Trace the tool-use agent loop, including every way it can stop
- Design a supervisor with subagents and decide what each subagent must be told
- Pick a harness: the Client SDK loop, the Claude Agent SDK, Managed Agents or the CLI
- Keep loops safe with turn caps, budgets, permissions and hooks
2. Applications and integration 75 min
The biggest domain: turning requirements into a Claude integration, Messages API mechanics, streaming, batches, vision, third-party platforms, engineering basics, Claude surfaces and the configuration you should version.
- Map requirements such as latency, volume, cost and data sensitivity to the right API features
- Build correct Messages API requests with system prompts, content blocks, images and tools
- Choose between real-time streaming and the Message Batches API
- Explain how access through Amazon Bedrock, Google Cloud and Microsoft Foundry differs from the Claude API
- Pick the right Claude surface and version CLAUDE.md, settings.json, model IDs and prompts
3. Claude Code 35 min
CLAUDE.md and rules, skills and slash commands, subagents, settings.json, permission modes and headless runs: the Claude Code features the developer exam names.
- Place instructions in the right CLAUDE.md, rule or skill file
- Read a settings.json and predict which value wins
- Create a skill or custom command and a subagent
- Run Claude Code headless with structured output for scripts and CI
4. Evaluation, testing and debugging 25 min
Classify failures, recover from them, read traces and tell an integration bug from a model behaviour problem.
- Sort a failure into transport, request, stop-reason, tool or model-behaviour categories
- Pick the right recovery for each category
- Use traces to isolate whether the integration or the model is at fault
- Build a small evaluation set to catch regressions
5. Model selection and optimization 45 min
Tokens, context and sampling; thinking and effort; choosing between model tiers; surviving breaking changes; and controlling cost with token budgets, usage tracking and prompt caching.
- Explain tokens, context windows, sampling and why outputs vary between runs
- Configure thinking and effort, and know their cost effects
- Choose a model tier for a workload and plan a model migration
- Estimate cost from usage and design prompt caching with breakpoints
6. Prompt and context engineering 40 min
Write clear prompts, place instructions and data in the right spot, constrain and validate output, and keep the context window lean with pruning, compaction and subagents.
- Write prompts that are clear, give the reason behind constraints and use examples well
- Decide what goes in the system prompt, the user turn and tool results
- Get reliably structured output and parse it defensively
- Manage long contexts with pruning, compaction, context editing and isolation
7. Security and safety 35 min
Defend against jailbreaks and prompt injection, handle PII and secrets, apply least privilege, and use hooks and permissions to stop destructive actions.
- Tell direct jailbreaks from indirect prompt injection and pick defences for each
- Layer guardrails: screening, hardened prompts, restricted tools, output checks
- Protect PII, secrets and API keys, and scope authentication and authorisation
- Block destructive agent actions with hooks and deny rules
8. Tools and MCP 45 min
Define and dispatch tools, report tool errors, use client and server tools, author MCP servers, pick a transport, and decide between built-in tools, custom tools, skills and MCP.
- Write tool definitions with descriptions Claude can choose between
- Handle tool_choice, parallel calls, approvals and errors
- Explain MCP hosts, clients, servers, primitives and transports
- Build a small MCP server and connect it to Claude Code
- Choose between built-in tools, custom tools, Skills and MCP
9. Agentic architecture and orchestration 50 min
The largest architect domain: designing the agentic loop, coordinator and subagent systems, task decomposition, hooks for policy enforcement, and session management.
- Design an agentic loop with clear stop conditions and limits
- Split work between a coordinator and subagents, and decide what each one is told
- Decompose tasks into parallel and sequential parts
- Use hooks and permissions to enforce business rules deterministically
- Manage sessions: resume, fork and start fresh at the right times
10. Claude Code configuration and workflows 45 min
Design team-wide Claude Code setups: the CLAUDE.md hierarchy, path-scoped rules, skills and slash commands, plan mode versus direct execution, and Claude Code in CI/CD.
- Place team, personal and organisation instructions at the right level of the CLAUDE.md hierarchy
- Use path-scoped rules and skills to keep context lean
- Choose plan mode or direct execution for a task
- Integrate Claude Code into CI/CD with predictable, parseable output
11. Prompt engineering and structured output 45 min
Write explicit review criteria, use few-shot examples for judgement calls, get schema-valid output through tool use or structured outputs, build validation-retry loops, and know when batch processing fits.
- Turn vague review instructions into explicit criteria that cut false positives
- Use few-shot examples to teach judgement on ambiguous cases
- Produce schema-valid JSON with tool use or structured outputs and validate the meaning too
- Design validation-retry loops and decide when batches are appropriate
12. Tool design and MCP integration 40 min
Design tools a model can choose between, return structured errors it can act on, scope tools per agent, and configure MCP servers at the right level.
- Write tool names and descriptions that separate similar tools
- Return structured, actionable errors from tools
- Scope a small, relevant tool set to each agent
- Configure MCP servers at project or user scope and keep secrets out of the repo
13. Context management and reliability 40 min
Keep long sessions accurate, design escalation, propagate errors through multi-agent systems, decide what humans review, and preserve source attribution.
- Protect critical facts in long sessions from summarisation loss
- Design escalation triggers that are explicit and testable
- Propagate errors in multi-agent systems without hiding or over-reacting to them
- Target human review where it matters and keep source attribution intact