Claude Certified Developer Foundations: Complete Course

Learn how the hands-on labs work in this course, how to open and run the Jupyter notebook, complete the coding tasks, and follow along with the lesson videos - no local setup or API key required.

Send one request to Claude from Python, read the response object, and see why max_tokens is a ceiling you must check with stop_reason.

See that the API remembers nothing between requests, keep the conversation in a list your code sends every turn, and watch the input tokens grow.

Put a small web server between a chat page and Claude: the browser posts to your server, the server adds the system prompt and history, and only it calls Claude.

Give Claude a role and scope in the system prompt, then enforce a rule that must always hold with a gate in code that runs before any request leaves.

Build a six-case test set with expected verdicts, score a prompt in code, find the gap it reveals, and compare two prompts by their scores.

Turn business needs like latency, cost, privacy, and availability into concrete technical constraints for your Claude application.

Follow a Claude system from requirements to monitoring and learn how prompt changes and model upgrades fit into its lifecycle.

Work with content blocks, image input, thinking output, and mixed response types in the Messages API.

Send a shipping-label picture as an image content block next to the question, and see what a picture costs in tokens.

Make Claude applications feel responsive with streaming, async processing, and WebSockets, and learn when streaming actually helps.

Replace create with messages.stream, print the text as it arrives, and read stop_reason and usage from the final message.

Integrate Claude through direct API, SDKs, or third-party providers while keeping workloads isolated and application context clean.

Define one tool, see Claude stop with tool_use, run the function in your code, send the tool_result back, and get the final answer.

Make Claude fill a JSON schema so the output always parses, and see why a schema-valid value can still be wrong. Exam lane and current product both covered.

Structure production prompts with clear instruction placement, output constraints, and strict separation of data from instructions.

Improve prompts systematically from observed failures using representative, boundary, and negative examples without overfitting.

Control what the model sees with pruning, compaction, persistent facts, and subagent isolation to prevent context drift and bloat.

Validate and parse model output defensively so confident but wrong responses never reach your business logic.

Allow null for unknown values, validate the fields in code, and when validation fails send the exact error back to Claude for a bounded retry.

Run the checked extraction over a folder of emails, keep a status per record, save the batch as JSON, and route the unclear ones to a person.

Trace the full path from a tool request to a real backend operation and learn why requesting an action is not executing it.

Write the loop that sends the conversation with tools, reads stop_reason, runs every tool_use block, returns the results, and repeats until end_turn.

Design tool names, descriptions, schemas, and error responses that make Claude's tool selection predictable.

Return not-found as data and real failures as structured errors with a flag, a category, a retryable flag, and separate customer and developer messages.

Choose the right extension mechanism for each need by weighing portability, maintenance, and security boundaries.

Understand how MCP clients and servers communicate and how tools, resources, and prompts are exposed over stdio and sockets.

Turn existing services into reusable MCP infrastructure with versioned interfaces and solid error handling.

Expose the tools through an MCP server, register it with Claude Code, and watch Claude Code discover and call them, including a structured refusal.

Learn when a predictable workflow beats an autonomous agent and how to weigh control, flexibility, cost, and reliability.

Understand the runtime loop that makes an application agentic, from tool request to harness dispatch to completion.

Build agents with the Claude Agent SDK using instructions, tools, hooks, and deterministic actions.

Run a Claude Code agent from Python with query(), allowed tools and a PreToolUse hook that denies a delete.

Coordinate specialized subagents with manager and supervisor patterns while avoiding unnecessary agent proliferation.

Split the work between a coordinator and two subagents with their own tools, pass context explicitly, and see what each agent really receives.

Help multi-step agents keep the right state using summaries, durable memory, and subagent isolation.

Compare what Strands, LangGraph, and PydanticAI provide and when a simple custom loop is the better choice.

Choose between self-hosted and managed agent execution based on control, scaling, observability, and operational ownership.

One loop with a verification gate, a hook that checks every tool call before it runs, case facts kept in code, and a handoff to a person.

Compare Opus, Sonnet, and Haiku and learn why the largest model is not always the right choice.

Match reasoning depth to task difficulty using fast mode, extended and adaptive thinking, and effort levels.

Apply practical model-selection reasoning, including routing difficult work to stronger models instead of using one model for everything.

Treat model upgrades like dependency changes with version pinning, regression testing, and rollback plans.

Track input and output tokens, set budgets, and estimate costs to design cost-aware Claude applications.

Cut cost and latency with prompt caching and learn when the Message Batches API beats realtime requests.

Mark a 1,900-token policy with cache_control and watch usage switch from cache write to cache read.

Use Claude within normal engineering discipline: version control, pull requests, code review, and incremental refactoring.

Manage prompt versions, model pinning, CLAUDE.md, settings.json, and plugins for reproducible environments.

Configure a repository for Claude Code with the CLAUDE.md hierarchy, rules, and settings.json.

Learn when to use Skills, slash commands, agents, or Agent Memory to extend Claude Code.

Set up a project for Claude Code: conventions in CLAUDE.md, a path-scoped rule, and a skill with a description and allowed tools, then see them used.

Manage sessions and choose between headless, streaming, and auto modes for each workflow.

Run Claude Code as a CI reviewer in print mode with JSON output and a schema, read the verdict in a script, and let the exit code decide.

Diagnose whether a failure comes from your integration, input, tools, parsing, or the model before you try to fix it.

Read agent traces step by step to find the earliest incorrect step and reproduce the real failure.

Respond to each failure class with the right strategy, from retry and correction to fallback and human intervention.

Make requests fail on purpose: a wrong key, a removed parameter, a 50 ms timeout; learn which errors to retry and which to fix.

Detect silent quality degradation in production and feed real failures back into your evaluation datasets.

Defend against direct and indirect prompt injection and learn why stronger prompt wording is not a security boundary.

An order note tries to force a 500 refund; the prompt labels tool data as data and the code gate limits the money.

Protect PII and sensitive data by handling untrusted input safely and minimizing what the model sees.

Keep access decisions in your application, not in the model, with proper authentication, authorization, and approvals.

Handle API keys and credentials safely across environments and keep them out of source control, prompts, and logs.

Replace emails, card and phone numbers with placeholders before the request; keep the key in the environment and out of git.

Build defense in depth with least privilege, tool restrictions, and hooks that deterministically block destructive actions.

A PreToolUse hook in .claude/settings.json exits with 2 and stops rm and .env access in a headless run.