Course Overview
This course prepares developers to build Claude applications that are robust in production environments and to pass the Claude Certified Developer – Foundations (CCDV-F) exam. It covers practical techniques for predicting Claude’s behavior, diagnosing prompt failures, managing output control, building tool-use loops, handling streaming data safely, engineering context, constructing agents, and securing applications against prompt injection. The course includes quizzes, debugging assignments, and a final practice exam aligned with the CCDV-F blueprint.
Key Takeaways
- Understand tokens, context windows, sampling, and non-determinism to predict Claude’s behavior.
- Diagnose prompt failures using a systematic approach rather than trial and error.
- Control outputs through API structured outputs and manage associated costs.
- Build and manage tool-use loops with clear code ownership.
- Handle streaming data safely without corrupting state.
- Engineer context deliberately to optimize input and summary management.
- Design workflows or agents with appropriate exit conditions and human intervention points.
- Operate Claude Code’s permission modes, settings hierarchy, hooks, and subagents effectively.
- Configure MCP servers securely, avoiding credential leaks.
- Define completion criteria with evals and calibrate graders for defensible judgments.
- Handle failures properly, distinguishing retriable from terminal errors.
- Defend against prompt injection using capability limits, hooks, and containment strategies.
- Package builds as reusable accelerators and contribute them for maintenance.
- Choose platforms, pin versions, and map trust boundaries for regulated reviews.
Prerequisites
- Comfortable writing code in Python or TypeScript.
- Familiarity with REST APIs and JSON.
- An Anthropic API key for hands-on parts (a small amount of credit is sufficient).
- No prior experience with Claude or LLM APIs is assumed.
Target Learners
- Developers building production applications on Claude rather than prototypes.
- Engineers preparing for the Claude Certified Developer – Foundations exam.
- Teams who have shipped an LLM feature and encountered cost, latency, or silent failure issues.
- Anyone responsible for defending AI integrations in security or procurement reviews.
- Developers transitioning from prompt experimentation to agents with tools and real consequences.
- 1 Welcome - the course, the credential, and how to use both 5:44
- 2 How this course maps to the CCDV-F blueprint 5:41
- 1 What this module assumes, and what it hands you 5:46
- 2 Tokens - the unit of input, output, and cost 5:29
- 3 The context window is a fixed budget — and its two edge behaviours 5:24
- 4 Sampling and non-determinism - why your test can't assert on text 5:30
- 5 The Claude model family and its capability tiers 5:20
- 6 Reasoning mode is a separate lever from model choice 5:14
- 7 Zero-shot, one-shot, multi-shot - what an example costs 5:28
- 8 Reaching Claude - REST, the SDK, and the four request shapes 5:21
- 9 Section recap - five takeaways 5:22
- 10 Foundations — knowledge check
- 1 Worked in development, has to hold up in production 5:10
- 2 Diagnose the failure, then add the one technique that fixes it 5:26
- 3 The four techniques - system prompts, XML, few-shot, output constraints 5:26
- 4 The classification prompt, before and after 5:27
- 5 Structured outputs - control moves from the prompt into the API 5:35
- 6 Extended thinking - what it does and when it earns its cost 5:20
- 7 The carry-back rule - thinking blocks go back unchanged 5:19
- 8 The tool-use loop, and the step your code owns 5:19
- 9 Schema anatomy and the five design decisions 5:27
- 10 The description that sent Claude to the wrong tool 5:39
- 11 MCP - when someone else has already written your tools 5:48
- 12 What streaming changes, and the events your handler sees 5:27
- 13 Never act on a partial block — and what to do when the stream drops 5:29
- 14 The context window is not a free resource 5:19
- 15 Four strategies for staying in budget, and two levers that cut the bill 5:39
- 16 The three places a RAG path can break 5:25
- 17 Workflow or agent — make the call before you write a line 5:41
- 18 Three wiring paths - raw loop, Agent SDK, Managed Agents 5:38
- 19 Wiring the loop - four steps and the checklist 5:20
- 20 HITL insertion points, and the over-tooling trap 5:30
- 21 Regulated data decides your endpoint before you design anything 5:26
- 22 Memory scope - four patterns and what each costs 5:40
- 23 Skills - instructions that load only when the task calls for them 5:21
- 24 Images and PDFs - token cost and the ways to send one 5:33
- 25 The Batches API — and when a batch is not a batch 5:22
- 26 Section recap - eight takeaways, and the words we used 5:25
- 27 Production-Grade Prompting, Agents and Tool-use — knowledge check
- 28 Assignment 1 — Diagnose and rebuild a failing prompt
- 29 Assignment 2 — Make a streaming handler safe to commit
- 30 Assignment 3 — Finish wiring the agent loop
- 31 Assignment 4 — Cumulative debug task (Section 2)
- 1 What durable context buys you 5:20
- 2 The loop in your terminal - explore, plan, code 5:25
- 3 The six permission modes 5:28
- 4 Where configuration lives, and placing the gate by worst-case cost 5:23
- 5 CLAUDE.md and rules files that scope themselves 5:32
- 6 Hooks - guardrail, not convention 5:18
- 7 Subagents and what they don't load 5:32
- 8 Skills, and how one loads in each runtime 5:03
- 9 Entry points, plugins, and the packaging decision 5:25
- 10 What an MCP server is, and why it beats wiring 5:36
- 11 Configuration scopes, and keeping the key out of the repo 5:25
- 12 Why enterprise differs, and how each service authenticates 5:42
- 13 Authentication that works in staging and fails in production 5:22
- 14 Resources, prompts, and the other half of an MCP server 5:22
- 15 Four layers of guardrail, and matching the layer to the stakes 5:17
- 16 Section recap - seven takeaways 5:32
- 17 Claude Code, MCP and Integration — knowledge check
- 18 Assignment 5 — Debug a plugin definition that fails to load
- 19 Assignment 6 — End-to-end integration task (Section 3)
- 1 Development hides what production reveals 5:12
- 2 Write the design document, and what an eval actually is 5:23
- 3 Match the grader to the shape of the output 5:12
- 4 When a passing eval still misses the failure 5:04
- 5 Four test levels, each catching what the others miss 5:28
- 6 Retriable or terminal, and what the SDK already retries 5:47
- 7 Tool errors must go back to Claude 5:07
- 8 Capability tiers, and a default model plus overrides 5:11
- 9 Instrument before you optimise - caching, batching, tiers 5:05
- 10 Multi-agent orchestration as a deliberate trade 5:20
- 11 Prompt injection - the core threat 5:21
- 12 Least privilege, and where the boundary sits 5:19
- 13 What a security hook actually checks 5:24
- 14 Permission modes and sandboxing - the residual control 5:40
- 15 When Claude declines - refusal and fallbacks 5:36
- 16 The defence checklist 5:21
- 17 Section recap - production engineering and security 5:31
- 18 Production Engineering, Evals and Security — knowledge check
- 19 Assignment 7 — Finish an incomplete eval suite
- 20 Assignment 8 — Rebuild the failure and retry path
- 21 Assignment 9 — Find the three defects (Section 4)
- 1 What happens to a build after it works 5:17
- 2 What an accelerator does, and the three asset types 5:28
- 3 Match the contribution to the channel built for it 5:23
- 4 From business requirements to functional and infrastructure 5:29
- 5 The systems lifecycle and its gates 5:22
- 6 The customer's cloud usually decides the platform 5:38
- 7 Pin the version, and promote it through the eval 5:23
- 8 Latency, compliance, and true total cost 5:22
- 9 Map the components before you connect them 5:23
- 10 Scoping for a regulated review 5:10
- 11 The multi-component integration map 5:15
- 12 What to actually do on Monday 5:22
- 13 Sitting the CCDV-F 5:20
- 14 Section recap - accelerators and contribution 5:29
- 15 Accelerators and IP Contribution — knowledge check
- 16 Assignment 10 — Make an accelerator template reusable
- 17 Assignment 11 — Find all three defects (Section 5)
- 1 What you have now, and what to do with it 5:08
- 2 Final practice exam — CCDV-F (53 questions)
Access Files No pi required.
Free Course files 1 file package
- Udemy - Claude Certified Developer Foundations: Build & Pass CCDV-F
Discussions are closed
Comments are currently disabled for this course.
