Claude Certified Developer Foundations (CCDV-F) Exam Guide

In this lecture, you'll learn the fundamental differences between Claude-powered workflows and AI agents, including how each system controls task execution and makes decisions. Through practical examples, you'll explore four common workflow patterns, understand how agents choose actions dynamically, and learn when to select a predictable workflow instead of an autonomous agent.

Topics Covered:

• Understanding what an AI workflow is and how developers define the execution steps in advance

• Exploring how Claude performs tasks within predefined workflows without independently changing the execution path

• Understanding four common workflow patterns: Chaining, Parallelization, Routing, and Orchestrator-Workers

• Exploring chaining workflows where the output of one step becomes the input to the next

• Understanding parallel workflows where independent tasks execute simultaneously before their results are combined

• Exploring routing workflows that classify requests and direct them to appropriate handlers

• Understanding orchestrator-worker workflows where an orchestrator determines subtasks, delegates work, and collects results

• Understanding what an AI agent is and how Claude dynamically decides its next actions based on a goal, available tools, and observations

• Identifying the fundamental difference between workflows and agents: who controls the next execution step

• Comparing workflows and agents based on predictability, execution cost, debugging complexity, and task suitability

• Recognizing why agent execution costs can vary depending on the number of decisions and tool calls

• Understanding why workflows are generally suitable for repeated, predictable tasks while agents support open-ended problems

• Applying the flowchart test to determine whether a task requires a workflow or an agent

• Understanding the exam recommendation to prefer workflows when both approaches can accomplish the task effectively

By the End of This Lecture, You Will Be Able To:

• Explain the fundamental differences between AI workflows and autonomous agents

• Identify whether execution steps are controlled by developers or dynamically selected by Claude

• Describe the four workflow patterns: Chaining, Parallelization, Routing, and Orchestrator-Workers

• Recognize appropriate business scenarios for each workflow pattern

• Explain how agents dynamically select actions based on intermediate results

• Distinguish between predictable workflow execution and flexible agent-based execution

• Evaluate workflows and agents based on implementation complexity, predictability, cost, and debugging requirements

• Understand why both workflows and agents can use external tools

• Recognize why tool usage or model capability alone does not determine whether a system is an agent

• Apply the flowchart test to identify the appropriate architecture

• Determine when an open-ended task requires dynamic agent decision-making

• Explain why predictable workflows are generally preferred when both approaches are suitable

• Answer certification exam questions involving workflow architecture, agent autonomy, and execution control

This lecture is part of Domain 1: Agents and Workflows and provides foundational knowledge of workflow patterns, agent behavior, execution control, and architectural decision-making for Claude-based agentic systems.

In this lecture, you'll learn how Claude agents operate through a continuous loop of reasoning, tool execution, observation, and repetition. Through practical explanations, you'll explore how agents select their next actions, how application code controls tool execution, why stopping conditions are essential, and how to choose between different agent execution patterns.

Topics Covered:

• Understanding the fundamental concept of an AI agent as a repeating execution loop rather than a single operation

• Exploring the four stages of the agent loop: Think, Call Tool, Observe, and Repeat

• Understanding how Claude determines its next action based on the goal, available tools, and conversation history

• Recognizing why agents make decisions dynamically as new information becomes available

• Understanding the tool execution process and the distinction between Claude requesting an action and application code executing it

• Exploring the request-execute gap where developers can implement approvals, validation, and safety checks

• Understanding how tool results are returned to Claude and incorporated into the conversation history

• Recognizing how message history grows across agent iterations and influences subsequent decisions

• Understanding the stopping problem and the risks of uncontrolled agent execution

• Exploring three stopping conditions: Goal Completion, Maximum Iteration Limit, and Unrecoverable Error

• Recognizing why production agents require iteration limits to control execution and costs

• Comparing three execution patterns: Single Call, Tool-Use Loop, and Sub-Agent Dispatch

• Identifying when to use a single tool call, a dynamic agent loop, or multiple coordinated sub-agents

By the End of This Lecture, You Will Be Able To:

• Explain how an AI agent operates through a continuous execution loop

• Describe the Think, Call Tool, Observe, and Repeat cycle

• Identify the information Claude uses to determine its next action

• Understand how agent decisions evolve as tool results become available

• Differentiate between Claude requesting tool execution and application code performing the action

• Explain the importance of the request-execute gap for implementing safety checks and human approvals

• Recognize how conversation history expands during agent execution

• Identify the risks associated with unlimited agent iterations

• Define appropriate stopping conditions for agent-based systems

• Understand why maximum iteration limits are essential in production environments

• Differentiate between single-call execution, tool-use loops, and sub-agent dispatch

• Select an appropriate execution pattern based on task complexity and the availability of predefined steps

• Apply agent loop concepts to certification exam questions involving tool execution, runtime control, and stopping conditions

This lecture is part of Domain 1: Agents and Workflows and provides foundational knowledge of agent execution loops, tool calling, request-execute boundaries, stopping conditions, and execution patterns for Claude-based agentic systems.

In this lecture, you'll learn how context windows and external memory work in Claude-based AI agents, and how to manage growing conversation histories during agent execution. Through practical examples, you'll explore context bloat, goal drift, tool output pruning, conversation compaction, and persistent agent memory to improve reliability and control token usage.

Topics Covered:

• Understanding the context window as a fixed-size working space shared by system instructions, conversation history, and tool outputs

• Exploring how repeated agent execution loops increase conversation history and consume available context

• Recognizing how context limitations can gradually affect agent response quality and reliability

• Understanding context bloat and how excessive or irrelevant information reduces the space available for important details

• Exploring goal drift and how agents may gradually lose focus on their original objectives during long-running tasks

• Differentiating between context bloat and goal drift and understanding why they require different solutions

• Applying tool output pruning to remove unnecessary information before passing results back to Claude

• Using filtering techniques to extract only relevant fields from large tool responses, such as JSON data

• Understanding conversation compaction and how older interactions can be summarized while recent messages remain intact

• Recognizing the trade-offs of compaction, including reduced context usage and potential information loss

• Differentiating between temporary context and persistent external agent memory

• Understanding how agent memory can be stored in files or databases outside the model

• Exploring memory write and retrieval operations for preserving important decisions, preferences, and results across sessions

• Recognizing why retrieving only relevant memories prevents unnecessary context growth

By the End of This Lecture, You Will Be Able To:

• Explain how the context window supports Claude's reasoning during agent execution

• Identify how system prompts, conversation history, and tool outputs compete for limited context space

• Recognize the symptoms and causes of context bloat and goal drift

• Differentiate between reducing context volume and re-anchoring an agent to its original goal

• Apply tool output pruning to reduce unnecessary token consumption

• Filter large tool responses to retain only task-relevant information

• Explain how conversation compaction reduces context usage

• Recognize the limitations and potential information loss associated with summarization

• Distinguish between temporary conversation context and persistent external memory

• Explain how files and databases can support memory across agent sessions

• Identify what information should be preserved in agent memory

• Understand how agents write important information to memory and retrieve relevant information when needed

• Avoid excessive memory retrieval that recreates context bloat

• Apply context and memory management techniques to improve the efficiency, reliability, and scalability of Claude-based agents

This lecture is part of Domain 1: Agents and Workflows and provides foundational knowledge of context window management, context bloat, goal drift, tool output pruning, conversation compaction, and persistent memory in Claude-based agentic systems.

In this lecture, you'll learn how manager agents, worker agents, and sub-agents collaborate to handle complex tasks in Claude-based agentic systems. Through practical examples, you'll explore how the manager pattern distributes responsibilities, how sub-agents maintain independent context, and when multi-agent coordination improves performance compared with using a single agent.

Topics Covered:

• Understanding the manager-worker architecture and how one agent coordinates work performed by specialized sub-agents

• Exploring the manager pattern through a wedding planning example involving independent responsibilities

• Understanding what a sub-agent is and how it operates with its own fresh context and focused task

• Recognizing how sub-agents use the Think, Call Tool, Observe, and Repeat execution loop

• Understanding how sub-agents return relevant results to the manager instead of sharing their entire execution histories

• Exploring three major benefits of sub-agents: Context Isolation, Failure Containment, and Parallel Execution

• Understanding how context isolation prevents large documents and intermediate tool outputs from overwhelming the manager's context window

• Recognizing how failure containment helps prevent problems in one sub-agent from affecting unrelated tasks

• Exploring how independent sub-agents can execute tasks in parallel to reduce overall processing time

• Understanding how Claude can coordinate and determine parallel execution opportunities at runtime

• Comparing single-agent and manager-worker architectures based on context usage, execution speed, token cost, and complexity

• Recognizing why multi-agent systems may consume more tokens due to manager coordination and individual sub-agent execution

• Identifying situations where independent subtasks, context limitations, or parallel processing justify using sub-agents

• Understanding why simple, sequential, or cost-sensitive tasks may be better handled by a single agent

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and structure of the manager-worker architecture

• Differentiate between manager agents, worker agents, and sub-agents

• Describe how managers delegate tasks and collect results from specialized agents

• Explain how each sub-agent maintains its own independent context window

• Recognize the benefits of context isolation in complex agentic workflows

• Understand how failure containment improves reliability in multi-agent systems

• Identify opportunities for parallel execution of independent subtasks

• Compare single-agent and multi-agent approaches based on task requirements

• Evaluate the additional token costs and coordination overhead of using sub-agents

• Recognize when complex tasks should be divided among specialized agents

• Identify situations where a single agent is more efficient than a manager-worker system

• Apply the principle of splitting work only when subtasks are genuinely separable

• Select appropriate agent architectures for certification exam scenarios involving task delegation, context management, and parallel execution

This lecture is part of Domain 1: Agents and Workflows and provides foundational knowledge of manager-worker architectures, sub-agent delegation, context isolation, failure containment, parallel execution, and multi-agent design decisions for Claude-based agentic systems.

Reduce repetitive learning outcomesClarify manager and worker roles

In this lecture, you'll learn how to build Claude-based AI agents using the Claude Agent SDK, custom agent loops, and managed agent infrastructure. Through practical examples, you'll explore how to choose the right development approach, understand where agent execution takes place, and implement deterministic safety controls using hooks.

Topics Covered:

• Understanding the three essential decisions when building AI agents: development approach, execution environment, and safety controls

• Exploring the Claude Agent SDK and its relationship to Claude Code

• Understanding how the Claude Agent SDK packages Claude Code capabilities into Python and TypeScript libraries

• Identifying built-in tools such as Read, Write, Edit, Bash, Glob, Grep, Web Search, and Web Fetch

• Understanding how the Agent SDK manages agent execution loops and context handling

• Building a custom agent harness using the Messages API and a tool-execution loop

• Exploring the request-execute boundary where application code controls whether requested tools are executed

• Comparing the Claude Agent SDK and custom harnesses based on development effort, flexibility, built-in tools, and control

• Recognizing when custom retries, approval mechanisms, or logging requirements justify building a custom harness

• Understanding the differences between locally executed Agent SDK applications and Managed Agents

• Exploring managed agent execution environments, including cloud-hosted and self-hosted sandboxes

• Understanding stateful agent sessions, event logs, and associated data retention and compliance considerations

• Exploring deterministic safety hooks that enforce rules before or after agent actions

• Identifying important hook events, including PreToolUse, PostToolUse, Stop, SessionStart, SessionEnd, and UserPromptSubmit

• Understanding how PreToolUse hooks can block destructive operations before tools execute

• Recognizing why executable safety controls provide stronger enforcement than relying only on prompt instructions

By the End of This Lecture, You Will Be Able To:

• Explain the main architectural decisions involved in building Claude-based AI agents

• Describe the purpose and capabilities of the Claude Agent SDK

• Understand how the Agent SDK differs from a generic agent framework

• Identify the built-in tools available through Claude's agent development ecosystem

• Explain how to implement a custom agent execution loop using the Messages API

• Understand how tool requests, execution decisions, and tool results interact within an agent harness

• Compare the benefits and limitations of the Agent SDK and custom agent implementations

• Determine when specialized requirements justify developing a custom harness

• Differentiate between Agent SDK execution and Managed Agents infrastructure

• Recognize the role of hosted and self-hosted sandboxes in agent deployment

• Understand important state management, data retention, and compliance considerations

• Explain how hooks provide deterministic control over agent behavior

• Identify appropriate hook events for validation, monitoring, and safety enforcement

• Apply PreToolUse hooks to prevent unauthorized or destructive tool operations

• Select suitable development, deployment, and safety approaches for Claude-based agentic applications

This lecture is part of Domain 1: Agents and Workflows and provides foundational knowledge of the Claude Agent SDK, custom agent harnesses, Managed Agents, execution environments, and deterministic safety hooks for building reliable Claude-based agentic systems.

In this lecture, you'll learn how agentic frameworks simplify the development of Claude-based AI agents and workflows by providing reusable execution patterns, state management, and tool integration capabilities. Through practical comparisons, you'll explore Strands Agents, LangGraph, and PydanticAI, understand how they differ from the Claude Agent SDK, Managed Agents, and custom harnesses, and learn how to select the right approach for your application.

Topics Covered:

• Understanding why agentic frameworks exist and how they reduce repetitive development work

• Exploring how frameworks provide reusable components for agent execution loops, retries, and state management

• Understanding Strands Agents and its model-driven approach to agent development

• Exploring how Strands Agents allows models to dynamically select actions and tools, with support for AWS Bedrock

• Understanding LangGraph and its graph-driven architecture for building structured agent workflows

• Exploring LangGraph capabilities such as branching execution, checkpoints, pause and resume, and human approval

• Understanding PydanticAI and its type-driven approach to agent development

• Exploring structured outputs, dependency injection, data validation, and strict data contracts in PydanticAI

• Recognizing how agentic frameworks support the Model Context Protocol (MCP) for connecting external tools

• Understanding how agentic frameworks can support both predefined workflows and dynamically executing agents

• Comparing agentic frameworks, the Claude Agent SDK, Managed Agents, and custom harnesses

• Evaluating development effort, execution environments, flexibility, and control across different implementation approaches

• Understanding how Managed Agents differs by providing managed execution infrastructure

• Recognizing the trade-off between faster development using established frameworks and greater control through custom implementations

• Selecting an appropriate framework based on model autonomy, workflow control, and data validation requirements

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and benefits of agentic frameworks

• Understand how frameworks simplify common agent development tasks

• Describe the model-driven architecture of Strands Agents

• Explain how LangGraph supports graph-based workflows and controlled execution

• Identify the benefits of PydanticAI for structured outputs and data validation

• Differentiate between model-driven, graph-driven, and type-driven agent development approaches

• Recognize how MCP supports external tool integration across agentic frameworks

• Compare frameworks with the Claude Agent SDK, Managed Agents, and custom harnesses

• Understand where agent execution takes place for different development approaches

• Evaluate the trade-offs between development speed, flexibility, infrastructure, and control

• Select Strands Agents for model-driven agent execution scenarios

• Identify when LangGraph is appropriate for structured workflows requiring checkpoints and human approval

• Recognize when PydanticAI is suitable for applications requiring strict data validation

• Determine when the Claude Agent SDK or a custom implementation may be more appropriate than a framework

• Apply framework selection principles to certification exam scenarios involving agent architecture and implementation choices

This lecture is part of Domain 1: Agents and Workflows and provides foundational knowledge of agentic frameworks, Strands Agents, LangGraph, PydanticAI, MCP integration, and the selection of suitable development approaches for Claude-based agentic systems.

Condense the overlapping learning outcomesOrganize the topics into clear categories

In this hands-on lab, you'll learn how to set up a Python development environment for building Claude-based AI agents using the Claude Agent SDK and Anthropic API. Through a practical file organization project called Sortly, you'll explore the project structure, configure dependencies, set up API credentials, and verify that your environment is ready for the upcoming agent and workflow demonstrations.

Topics Covered:

• Introducing the Sortly project and its objective of organizing files using Claude-based agents and workflows

• Exploring a practical scenario involving a developer with an unorganized downloads folder containing bills, receipts, financial statements, and other documents

• Understanding the project folder structure, including workspace_seed, workspace, demos, and shared helper utilities

• Exploring how sample files are stored separately from the working directory to support repeatable experiments

• Understanding how Markdown lab instructions and Python demonstration files are organized

• Introducing uv as a fast Python package and environment management tool

• Creating a Python virtual environment using Python 3.12

• Activating the virtual environment and verifying the selected Python version

• Installing the required dependencies, including anthropic and claude-agent-sdk

• Understanding how the .env file stores the Anthropic API key for authentication

• Exploring the check_setup.py script for validating the development environment

• Verifying Python compatibility, sample file availability, model configuration, and API credentials

• Testing the environment through a live Anthropic API request

• Confirming successful setup before proceeding to agent and workflow implementation

By the End of This Lecture, You Will Be Able To:

• Explain the objective of the Sortly file organization project

• Understand the overall structure of the hands-on lab repository

• Identify the purpose of sample files, working directories, demonstration scripts, and helper utilities

• Install and use uv for Python environment and dependency management

• Create and activate a Python 3.12 virtual environment

• Install the Anthropic SDK and Claude Agent SDK

• Configure Anthropic API credentials for agent development

• Navigate the project structure and locate the setup verification script

• Verify that the required Python version and dependencies are available

• Check whether the sample workspace files are accessible

• Execute a test request to confirm connectivity with the Anthropic API

• Troubleshoot basic environment setup and dependency configuration issues

• Prepare a working development environment for subsequent Claude agent and workflow labs

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with Python environment setup, project organization, dependency installation, Anthropic API configuration, and Claude Agent SDK preparation for the agent and workflow concepts covered in Domain 1: Agents and Workflows.

Condense the learning outcomesSeparate setup steps from outcomes

In this hands-on lab, you'll learn how to compare traditional workflows with Claude-powered processing using a practical file organization project. Through three Python demonstrations, you'll explore rule-based file classification, Claude-assisted file categorization, and the key considerations for choosing between workflow-based and agent-based architectures.

Topics Covered:

• Understanding the differences between predefined workflows and AI-assisted processing

• Exploring the Sortly project for organizing files into Finance, Work, Personal, and Miscellaneous folders

• Understanding how the workspace_seed and workspace directories support repeatable experiments

• Resetting the working directory before each demonstration to ensure consistent starting conditions

• Implementing a rigid, rule-based pipeline that classifies files using predefined filename patterns

• Running a local Python workflow without requiring Anthropic API calls

• Understanding the limitations of rule-based classification when filenames do not match predefined conditions

• Implementing a model-assisted pipeline using Claude to classify files based on their names and contents

• Using system instructions to guide Claude's file categorization decisions

• Processing files individually through a loop and sending classification requests to the Anthropic API

• Comparing the results of rule-based classification and Claude-powered classification

• Exploring a Python demonstration that presents six criteria for choosing between workflows and agents

• Evaluating practical scenarios where predictable workflows are more suitable than agent-based implementations

• Understanding why predefined steps, fixed execution order, and predictable inputs favor workflow architectures

By the End of This Lecture, You Will Be Able To:

• Explain the differences between rigid workflows and Claude-assisted processing

• Understand how predefined rules control file classification in a traditional workflow

• Reset a sample workspace to perform repeatable file organization experiments

• Execute a rule-based Python pipeline without using an AI model

• Identify the limitations of filename-based classification

• Use Claude through the Anthropic API to classify files based on their content

• Configure system instructions for consistent AI-assisted file categorization

• Process multiple files sequentially using a model-assisted workflow

• Compare traditional rule-based and Claude-powered classification approaches

• Recognize that using an AI model within a pipeline does not automatically make it an autonomous agent

• Evaluate practical scenarios using workflow-versus-agent selection criteria

• Identify when fixed, predictable tasks are better suited to predefined workflows

• Apply architectural decision-making principles to file organization and other automation use cases

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with rule-based pipelines, Claude-powered file classification, repeatable workflow execution, and workflow-versus-agent architecture decisions covered in Domain 1: Agents and Workflows.

Add prerequisites and setup requirementsClarify the three Python demonstrations

In this hands-on lab, you'll learn how to build and execute Claude-based AI agents using two approaches: implementing an agent loop manually and using the Claude Agent SDK. Through practical demonstrations with the Sortly file organization project, you'll explore how agents dynamically select tools, execute actions, manage stopping conditions, and how to choose between self-hosted and managed agent deployment.

Topics Covered:

• Understanding how AI agents dynamically select and execute actions to accomplish a defined goal

• Exploring two approaches to agent development: Custom Agent Loops and the Claude Agent SDK

• Building a manual agent execution loop using the Anthropic API

• Understanding how agents repeatedly request tools, execute actions, observe results, and determine subsequent steps

• Configuring a maximum iteration limit to prevent uncontrolled agent execution

• Exploring how the stop_reason value helps determine when an agent should continue or terminate

• Using the Sortly project to organize files through agent-driven decision-making

• Resetting the workspace before demonstrations to ensure consistent starting conditions

• Observing tool execution sequences involving file listing, reading, and moving operations

• Implementing similar file organization functionality using the Claude Agent SDK without manually writing the execution loop

• Understanding how the Claude Agent SDK manages agent execution and tool interactions

• Troubleshooting an SDK execution issue involving a JSON decoding error and relocating the project workspace

• Recreating the Python environment and installing dependencies after moving the project

• Comparing self-hosted Agent SDK execution with Anthropic-managed agent infrastructure

• Exploring differences in execution responsibility, infrastructure management, scheduling, and deployment

• Evaluating deployment scenarios involving scheduled tasks, long-running operations, and unattended agent execution

By the End of This Lecture, You Will Be Able To:

• Explain how an AI agent loop operates during tool-based task execution

• Implement a basic agent loop manually using the Anthropic API

• Understand how agents select tools and execute actions based on intermediate results

• Configure iteration limits and recognize agent stopping conditions

• Interpret stop_reason values during agent execution

• Execute the Sortly file organization task using a custom agent loop

• Build an equivalent agent using the Claude Agent SDK

• Differentiate between manually managing an agent loop and using SDK-managed execution

• Understand how the Claude Agent SDK simplifies agent development

• Identify and troubleshoot common environment and execution issues

• Reconfigure a Python development environment after relocating a project

• Compare self-hosted agents with Anthropic-managed agent deployments

• Recognize the infrastructure and operational responsibilities associated with different deployment approaches

• Evaluate deployment requirements involving scheduling, long-running tasks, and automated execution

• Select an appropriate agent development and deployment approach based on application requirements

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with custom agent loops, Claude Agent SDK execution, tool calling, stopping conditions, troubleshooting, and deployment architecture concepts covered in Domain 1: Agents and Workflows.

Reduce the repeated learning outcomesGroup topics into clearer categories

In this hands-on lab, you'll learn how to implement task delegation using manager agents and sub-agents in Claude-based agentic systems. Through two practical demonstrations using the Sortly file organization project, you'll compare a single agent handling an entire task with a manager delegating work to specialized sub-agents, and explore how delegation affects context usage and token consumption.

Topics Covered:

• Understanding task delegation and the role of manager agents and sub-agents in agentic systems

• Exploring the differences between a flat, single-agent architecture and a manager-sub-agent architecture

• Running the P3 Manager Flat demonstration, where one agent handles the complete file organization task

• Understanding how a single agent manages file processing, tool execution, and file movement operations

• Observing how conversation context and input token usage increase as a single agent processes more files

• Measuring input token consumption in the flat agent demonstration

• Configuring the Python environment and installing missing dependencies using uv

• Running the P3 Manager Sub-Agent demonstration to explore delegated task execution

• Understanding how a manager agent creates a high-level plan and delegates execution to a sub-agent

• Exploring how sub-agents handle assigned tasks without requiring the manager to process every intermediate detail

• Comparing manager context usage between flat and delegated agent architectures

• Analyzing token consumption across manager and sub-agent execution

• Understanding why sub-agent delegation reduces the amount of task-specific context maintained by the manager

• Recognizing that sub-agents introduce additional overhead through their own system prompts and execution contexts

• Understanding why delegation does not automatically guarantee lower total token costs

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of task delegation in Claude-based agentic systems

• Differentiate between flat agent architectures and manager-sub-agent architectures

• Describe the responsibilities of manager agents and delegated sub-agents

• Execute a single-agent file organization workflow using Python

• Observe how a single agent's context grows during multi-step task execution

• Measure and interpret input token consumption during agent execution

• Configure missing Python dependencies required for agent demonstrations

• Execute a manager-sub-agent implementation using the Sortly project

• Understand how managers delegate tasks and receive results from sub-agents

• Compare context usage between centralized and delegated agent execution

• Recognize how delegation helps prevent the manager's context from growing with every task detail

• Identify the additional token overhead introduced by sub-agent execution

• Explain why reduced manager context usage does not necessarily mean reduced total token consumption

• Evaluate when task delegation is beneficial for managing larger or more complex agent workloads

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with manager-sub-agent architectures, task delegation, context isolation, token usage analysis, and agent execution patterns covered in Domain 1: Agents and Workflows.

Condense the overlapping learning outcomesSeparate concepts from hands-on actions

In this hands-on lab, you'll learn how to implement hooks and guardrails to enforce safety rules in Claude-based AI agents. Through three practical demonstrations using the Sortly file organization project, you'll explore why prompt instructions alone cannot guarantee safe behavior, how code-level hooks prevent unauthorized file deletion, and how to implement similar safety controls using the Claude Agent SDK.

Topics Covered:

• Understanding the importance of hooks and guardrails in Claude-based agentic systems

• Exploring the differences between prompt-based safety instructions and code-enforced safety rules

• Understanding why system prompt instructions alone cannot guarantee that an agent will avoid destructive actions

• Running the first demonstration using the Anthropic Messages API with a prompt-only restriction against deleting files

• Providing an agent with a file deletion tool while instructing it not to delete any files

• Observing how an agent may attempt or perform a destructive action despite explicit instructions

• Exploring a practical example involving two similar resume files with different contents

• Understanding why irreversible operations require stronger safeguards than natural-language instructions

• Running the second demonstration using a custom Python hook to enforce file operation restrictions

• Exploring the guard function and how it validates tool requests before execution

• Understanding how hooks inspect tool names and apply rules to operations such as delete_file and move_file

• Observing how a hook blocks unauthorized deletion requests while allowing permitted file operations

• Understanding how blocked tool calls provide feedback that an agent can use to continue safely

• Running the third demonstration using the Claude Agent SDK and its hook-based permission controls

• Exploring how Claude Agent SDK hooks intercept potentially destructive operations before execution

• Comparing prompt-only restrictions, custom Python hooks, and Claude Agent SDK safety enforcement

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of hooks and guardrails in AI agent development

• Differentiate between safety instructions and deterministic code-level enforcement

• Recognize why prompt-based restrictions are insufficient for guaranteeing the prevention of destructive actions

• Execute a Claude agent demonstration using the Anthropic Messages API

• Identify situations where an agent may attempt prohibited tool operations

• Understand the risks associated with providing powerful tools without execution-level safeguards

• Implement a custom Python guard function to validate tool requests

• Use hooks to block unauthorized file deletion before execution

• Understand how blocked tool requests are communicated back to an agent

• Apply safety checks while allowing legitimate file organization operations to continue

• Configure hook-based safety controls using the Claude Agent SDK

• Recognize the role of hooks within the agent tool execution and permission process

• Compare the behavior of prompt-only restrictions and enforced guardrails

• Identify scenarios where deterministic safeguards are necessary for reliable agent execution

• Apply hooks and guardrails to improve the safety and reliability of Claude-based agentic applications

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with prompt-based safety instructions, custom Python guardrails, tool execution controls, and Claude Agent SDK hooks covered in Domain 1: Agents and Workflows.

Trim repetitive learning outcomesAdd prerequisites and setup details

In this hands-on lab, you'll learn how to implement persistent memory, manage growing conversation context, and use agentic frameworks in Claude-based AI applications. Through four practical demonstrations using the Sortly file organization project, you'll explore stateless API calls, memory-based result reuse, context pruning, and framework-based agent execution.

Topics Covered:

• Understanding the difference between stateless Claude API calls, persistent memory, and conversation context

• Exploring how independent API calls operate without automatically remembering previous results

• Running the first demonstration to classify files on Monday and repeat the same task on Tuesday without memory

• Observing how repeated classification of 14 files produces additional model calls and token consumption

• Understanding why previous API responses must be explicitly stored to support future reuse

• Implementing persistent memory using a local JSON file to save classification results

• Running the second demonstration to retrieve previously stored classifications instead of making repeated API requests

• Comparing model calls and input token consumption with and without persistent memory

• Understanding how application-managed memory differs from Claude's temporary context window

• Exploring how conversation history grows during a single agent execution

• Running the third demonstration to observe increasing context size and token usage across multiple turns

• Implementing context pruning to shorten or remove unnecessary older tool outputs

• Comparing context size before and after pruning and understanding the potential token savings

• Exploring the fourth demonstration, which ports file classification functionality into a framework-based implementation

• Understanding how agentic frameworks organize execution loops, state management, and processing steps

• Recognizing why frameworks simplify agent development without eliminating the underlying model calls or execution loop

• Comparing framework-based implementations with manually controlled agent loops

By the End of This Lecture, You Will Be Able To:

• Explain why individual Claude API calls are stateless unless previous information is explicitly supplied

• Differentiate between persistent external memory and temporary conversation context

• Execute repeated file classification tasks without persistent memory

• Measure model calls and input token usage across repeated executions

• Store Claude-generated classification results in a JSON-based memory file

• Retrieve previously stored results to avoid unnecessary repeated API requests

• Explain how application-managed memory can reduce model calls and processing costs

• Recognize how conversation history increases the amount of context sent during agent execution

• Identify situations where growing context may lead to unnecessary token consumption

• Implement context pruning to reduce older or irrelevant conversation content

• Compare context usage before and after applying pruning techniques

• Understand the difference between managing memory across executions and managing context within a single execution

• Explain how agentic frameworks structure and simplify agent execution

• Recognize that frameworks organize existing agent mechanisms rather than replace the underlying model

• Evaluate when to use framework-based agent development versus manually implementing an execution loop

• Apply memory management, context optimization, and framework selection principles to Claude-based agentic applications

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with stateless API execution, persistent JSON memory, model-call optimization, context pruning, token usage analysis, and framework-based agent implementation covered in Domain 1: Agents and Workflows.

Reduce repetition between sectionsAdd a concise lab workflow

In this lecture, you'll learn how to translate business needs into clear, actionable requirements for building Claude-based applications. Through practical examples, you'll explore the differences between functional and infrastructure requirements, identify important technical constraints, and understand how these requirements guide solution architecture decisions.

Topics Covered:

• Understanding why business needs must be translated into clear technical requirements before development begins

• Recognizing the difference between a business wish and an actionable software specification

• Exploring a customer support scenario where a business wants Claude to answer customer questions

• Understanding the developer's responsibility in identifying missing requirements

• Differentiating between functional requirements and infrastructure requirements

• Exploring functional requirements such as order lookup, answering frequently asked questions, and human escalation

• Understanding why error handling and human escalation are important functional capabilities

• Applying the "The system shall" test to identify functional requirements

• Understanding five essential infrastructure considerations: Scale, Latency, Cost, Security, and Location

• Exploring how user concurrency and response-time requirements affect application design

• Understanding how budget, data protection, and data residency influence technical decisions

• Recognizing how infrastructure constraints affect model selection, batch versus real-time processing, and hosting approaches

• Learning how to convert a vague business requirement into a specification containing features and constraints

• Understanding solution architecture as the overall system design that satisfies business and technical requirements

• Recognizing common certification exam scenarios involving missing functional or infrastructure requirements

By the End of This Lecture, You Will Be Able To:

• Explain why a business request alone is not sufficient to begin application development

• Translate high-level business needs into clear, buildable requirements

• Differentiate between functional requirements and infrastructure requirements

• Identify customer-facing features and expected system behaviors

• Recognize human escalation and fallback behavior as functional requirements

• Apply the "The system shall" test to evaluate functional requirements

• Identify essential infrastructure constraints related to scale, latency, cost, security, and location

• Ask appropriate questions to clarify incomplete business requirements

• Understand how infrastructure requirements influence model selection and application deployment

• Recognize why applications that work in demonstrations may fail under real production conditions

• Create a basic solution specification that combines functional capabilities with technical constraints

• Explain how requirements influence the overall solution architecture

• Identify missing requirements in scenario-based certification exam questions

• Apply a structured requirements-gathering approach when designing Claude-powered applications

This lecture is part of Domain 2: Applications and Integration of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of business requirements analysis, functional and infrastructure requirements, solution specifications, and architecture planning for Claude-based applications.

In this lecture, you'll learn the essential technical foundations behind Claude API integrations, including REST APIs, JSON data structures, and synchronous versus asynchronous execution. Through beginner-friendly examples, you'll explore how applications communicate with Claude, how requests and responses are structured, and why asynchronous processing matters when building scalable AI applications.

Topics Covered:

• Understanding what an API is and how it connects application code with Claude

• Exploring the restaurant waiter analogy to understand API requests and responses

• Understanding how APIs allow developers to use Claude without managing the underlying model infrastructure

• Introducing REST APIs and their role in application communication

• Exploring the three main components of an API request: HTTP Method, Endpoint, and Request Body

• Understanding the POST method and the /v1/messages endpoint used by the Claude Messages API

• Recognizing how API responses return structured information that applications can process

• Understanding JSON as a standard format for exchanging structured data

• Exploring JSON key-value pairs using simple examples such as role and content

• Understanding how JSON structures represent information in API requests and responses

• Differentiating between synchronous and asynchronous API execution

• Exploring how synchronous requests wait for Claude to respond before continuing

• Understanding how asynchronous requests allow applications to perform other work while waiting for responses

• Comparing synchronous and asynchronous execution for single requests and high-volume workloads

• Recognizing how asynchronous processing supports responsive applications and efficient handling of multiple requests

• Introducing the relationship between asynchronous processing and large-scale request handling through the Batch API

By the End of This Lecture, You Will Be Able To:

• Explain what an API is and how it enables communication between applications and Claude

• Describe the request-response process used in API integrations

• Understand the fundamental concepts of REST-based communication

• Identify the HTTP method, endpoint, and request body in a Claude API request

• Recognize the purpose of the /v1/messages endpoint

• Explain how structured API responses allow applications to process Claude-generated results

• Understand the basic syntax and structure of JSON

• Identify keys and values in JSON objects

• Recognize how JSON is used to exchange data between applications and APIs

• Differentiate between synchronous and asynchronous API calls

• Explain when synchronous execution is appropriate for simple, immediate requests

• Understand how asynchronous programming allows applications to handle other tasks while awaiting responses

• Recognize the benefits of asynchronous execution for high-volume API workloads

• Identify how asynchronous processing relates to batch request handling

• Apply REST, JSON, and asynchronous execution concepts when designing Claude-powered applications

This lecture is part of Domain 2: Applications and Integration of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of REST APIs, JSON data structures, API request-response communication, synchronous execution, and asynchronous processing for Claude-based applications.

In this lecture, you'll learn how the Claude Messages API works, including message structure, conversation roles, tool calling, and streaming responses. Through beginner-friendly examples, you'll explore how applications communicate with Claude, how external tools are executed, and when streaming improves the user experience.

Topics Covered:

• Understanding the Claude Messages API and its role in building Claude-powered applications

• Exploring the structure of Messages API requests and responses

• Understanding how the API uses REST, JSON, and the /v1/messages endpoint

• Introducing the three conversation roles: System, User, and Assistant

• Understanding how system instructions define Claude's behavior throughout a conversation

• Exploring how user messages represent requests and assistant messages represent Claude's responses

• Understanding why conversation history must be supplied again in subsequent API requests

• Recognizing the stateless nature of the Claude Messages API

• Introducing tool calling and how external tools extend Claude's capabilities

• Understanding the tool execution cycle: Claude Requests, Application Executes, Result Returns, and Claude Responds

• Exploring a practical order-status lookup example using an external tool

• Understanding the request-execute boundary and how application code controls tool execution

• Introducing streaming and how Claude responses can be delivered incrementally

• Comparing streaming and non-streaming API responses

• Understanding why streaming improves perceived responsiveness without changing the underlying answer

• Identifying when streaming is appropriate for interactive applications and when non-streaming is preferable for automated processing

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and fundamental structure of the Claude Messages API

• Understand how applications send message requests and receive structured responses

• Identify the roles of System, User, and Assistant in Claude conversations

• Explain how system instructions guide Claude's behavior

• Understand why conversation history must be managed by the application

• Recognize the stateless nature of individual Claude API calls

• Describe how Claude requests external tool execution

• Explain why application code, rather than Claude itself, executes client-side tools

• Understand how tool results are returned to Claude for generating final responses

• Recognize the importance of maintaining control over tool execution

• Differentiate between streaming and non-streaming API responses

• Explain how streaming improves the experience of users waiting for generated responses

• Identify when streaming is suitable for chat interfaces and other interactive applications

• Recognize why streaming is generally unnecessary when applications require complete responses

• Apply Messages API, tool calling, and streaming concepts to Claude application integration scenarios

This lecture is part of Domain 2: Applications and Integration of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of the Claude Messages API, conversation roles, stateless communication, tool execution, and streaming responses for Claude-based applications.

In this lecture, you'll learn how to extend the Claude Messages API with advanced capabilities, including vision, extended thinking, prompt caching, cloud provider integrations, and batch processing. Through practical examples, you'll explore how these features work, understand their performance and cost implications, and learn how to select the appropriate API access pattern for different application requirements.

Topics Covered:

• Understanding advanced Claude API capabilities and how they extend the existing Messages API

• Exploring Claude's vision capabilities for processing images, receipts, invoices, screenshots, diagrams, and documents

• Understanding how image inputs allow Claude to analyze visual information without requiring manual transcription

• Introducing extended thinking and how additional reasoning can support complex problem-solving tasks

• Recognizing the trade-offs between reasoning capabilities, token consumption, and response time

• Understanding prompt caching and how repeated prompt content can be reused across API requests

• Exploring how prompt caching can reduce input token costs when working with large documents or repeated system instructions

• Comparing three Claude API access options: Anthropic API, Amazon Bedrock, and Google Cloud Vertex AI

• Understanding how existing cloud infrastructure, billing, security, and compliance requirements influence provider selection

• Recognizing that feature availability may differ between Anthropic's direct API and cloud provider integrations

• Introducing the Message Batches API for processing large volumes of non-urgent requests asynchronously

• Understanding how batch processing trades immediate response delivery for lower processing costs

• Exploring a practical scenario involving the processing of thousands of documents through batch requests

• Comparing three API access patterns: Real-Time, Streaming, and Batch

• Understanding when synchronous responses are appropriate for immediate application requirements

• Recognizing when streaming improves the experience of users watching responses appear

• Identifying when batch processing is appropriate for high-volume, cost-sensitive workloads

• Applying urgency, cost, and user experience requirements to API integration decisions

By the End of This Lecture, You Will Be Able To:

• Explain how advanced capabilities extend the Claude Messages API

• Describe how Claude processes image inputs through its vision capabilities

• Identify suitable use cases for vision-enabled applications

• Understand the purpose of extended thinking for complex reasoning tasks

• Evaluate the trade-offs associated with additional reasoning and token usage

• Explain how prompt caching improves efficiency when reusing large prompts

• Recognize scenarios where prompt caching can reduce repeated input processing costs

• Differentiate between accessing Claude through Anthropic, Amazon Bedrock, and Google Cloud Vertex AI

• Understand how cloud infrastructure and enterprise requirements influence API provider selection

• Recognize potential differences in feature availability across API providers

• Explain the purpose of the Message Batches API

• Identify suitable workloads for asynchronous batch processing

• Understand the cost and latency trade-offs of batch processing

• Differentiate between real-time, streaming, and batch API access patterns

• Select streaming for interactive applications where users benefit from incremental responses

• Select real-time API calls when applications require immediate, complete responses

• Select batch processing for large-scale, non-urgent workloads where cost optimization is important

• Apply API capability and access-pattern selection principles to certification exam scenarios

This lecture is part of Domain 2: Applications and Integration of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of Claude vision, extended thinking, prompt caching, cloud provider integrations, batch processing, and API access patterns for Claude-based applications.

Reduce repetition between sectionsOrganize topics by API capability

In this lecture, you'll learn how the Software Development Life Cycle (SDLC) applies to Claude-based applications and why deploying an AI system is only the beginning of its journey. Through practical examples, you'll explore the five stages of the SDLC, understand Waterfall and Agile development approaches, and discover why model updates, continuous testing, monitoring, and maintenance are essential for reliable AI applications.

Topics Covered:

• Understanding the Software Development Life Cycle (SDLC) and why software requires continuous improvement after deployment

• Exploring why software development does not end when an application is released

• Understanding the five SDLC stages: Plan, Build, Test, Deploy, and Operate

• Exploring the planning stage and how business requirements guide application development

• Understanding the build stage and how developers implement the required functionality

• Exploring the testing stage and how applications are validated against expected requirements

• Understanding the deployment stage and how applications are released to real users

• Exploring the operate and maintain stage and its importance throughout an application's lifetime

• Comparing Waterfall and Agile development approaches

• Understanding how Waterfall follows a sequential development process while Agile uses shorter, repeated development cycles

• Recognizing how Claude-based applications differ from traditional software because model updates can affect application behavior

• Understanding why model version pinning and regression testing are important for maintaining consistent AI application behavior

• Exploring essential maintenance activities, including quality monitoring, error handling, prompt updates, and cost management

• Recognizing why production monitoring and maintenance require long-term planning and resources

• Understanding how operational feedback creates new requirements and feeds into the next development cycle

• Identifying common certification exam scenarios involving incomplete SDLC practices and inadequate post-deployment maintenance

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and importance of the Software Development Life Cycle

• Describe the five stages of the SDLC: Plan, Build, Test, Deploy, and Operate

• Understand how business requirements influence planning and testing activities

• Differentiate between Waterfall and Agile development methodologies

• Explain why software development is an ongoing process rather than a one-time activity

• Recognize the unique lifecycle challenges associated with Claude-based applications

• Understand how model updates can influence application outputs without changes to application code

• Explain the importance of model version pinning and continuous testing

• Identify essential operational responsibilities after deploying an AI application

• Monitor application quality and recognize changes in AI-generated responses

• Understand the importance of handling production errors and updating prompts

• Recognize why cost monitoring is necessary as application usage increases

• Explain how production feedback can be converted into new development requirements

• Apply continuous improvement principles throughout an AI application's lifecycle

• Identify appropriate SDLC practices in certification exam scenarios involving Claude application development and maintenance

This lecture is part of Domain 2: Applications and Integration of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of the Software Development Life Cycle, Waterfall and Agile methodologies, model versioning, continuous testing, production monitoring, and long-term maintenance of Claude-based applications.

In this lecture, you'll learn how version control, code review, and refactoring help maintain reliable and manageable Claude-based applications throughout the Software Development Life Cycle (SDLC). Through practical examples, you'll explore how Git tracks changes, why prompts and configuration files should be version-controlled, and how code reviews and refactoring improve software quality and maintainability.

Topics Covered:

• Understanding version control and why it is essential for managing software changes

• Exploring Git as a version control system for tracking code history and recovering previous versions

• Understanding how version control enables developers to roll back unwanted changes

• Exploring how Git supports collaboration when multiple developers work on the same project

• Recognizing why Claude application prompts and configuration files should be treated as code

• Understanding the importance of version-controlling application code, CLAUDE.md, and prompt files

• Exploring how prompt version history helps identify and reverse changes that negatively affect AI-generated responses

• Understanding code review as a quality checkpoint before changes reach production

• Exploring three major benefits of code review: Bug Detection, Knowledge Sharing, and Code Quality

• Recognizing how code review fits into the Build and Test stages of the SDLC

• Understanding refactoring as improving code structure without intentionally changing its functionality

• Differentiating between small refactoring tasks and large-scale code restructuring

• Exploring small refactoring examples such as renaming variables and splitting long functions

• Understanding why large refactoring operations require additional testing and code review

• Recognizing how Claude Code can assist developers in cleaning up and modernizing existing codebases

• Understanding how version control, code review, and refactoring support long-term software maintenance

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and benefits of version control in software development

• Understand how Git tracks changes and maintains a history of code versions

• Recognize how version control supports rollback and recovery from unwanted changes

• Explain how Git enables collaboration among development teams

• Identify which Claude application files should be maintained under version control

• Understand why prompts and configuration files must be tracked alongside application code

• Recognize how prompt changes can affect application behavior and output quality

• Explain the purpose of code review and its role in maintaining software quality

• Identify how code reviews help detect bugs and improve knowledge sharing

• Understand how code review supports the Build and Test stages of the SDLC

• Define refactoring and explain how it improves code maintainability without changing intended behavior

• Differentiate between small, low-risk refactoring and large, higher-risk restructuring

• Recognize when additional testing and review are necessary during major code changes

• Identify practical scenarios where Claude Code can support code cleanup and modernization

• Apply version control, code review, and refactoring principles to maintain reliable Claude-based applications

• Answer certification exam questions involving Git, prompt versioning, code review, refactoring, and software maintenance

This lecture is part of Domain 2: Applications and Integration of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of Git version control, prompt and configuration management, code review, refactoring, and software engineering practices for maintaining Claude-based applications.

Reduce repetition across learning outcomesUse consistent outcome verbs throughout

In this lecture, you'll learn how to design Claude-based applications by understanding the different interfaces available for interacting with Claude and the importance of maintaining clear content boundaries. Through practical examples, you'll explore how instructions behave across interfaces, how to separate trusted instructions from untrusted data, and how to select the appropriate Claude interface for different application requirements.

Topics Covered:

• Understanding the different interfaces available for accessing Claude

• Exploring five Claude interfaces: API, SDK, Claude Code, Claude Desktop, and Claude.ai

• Understanding how different interfaces provide access to the same underlying Claude models

• Comparing programmatic interfaces with developer-focused and end-user applications

• Exploring how instructions are handled differently across Claude interfaces

• Understanding the role of system prompts in API-based applications

• Recognizing why identical instructions may produce different behavior when used in different interfaces

• Understanding content boundaries and their role in separating trusted instructions from untrusted information

• Differentiating between developer-controlled instructions and external content such as web pages and uploaded documents

• Understanding why external documents should be treated as data rather than executable instructions

• Exploring a prompt injection example involving an uploaded document containing malicious instructions

• Recognizing how improperly handled untrusted content can influence or redirect an application's behavior

• Understanding how clear content boundaries support safer Claude application design

• Selecting the Claude API or SDK for building programmable applications and customer-facing products

• Identifying Claude Code as an appropriate interface for software development and codebase modernization

• Understanding when Claude Desktop or Claude.ai is suitable for everyday user interactions

• Recognizing common certification exam scenarios involving interface selection and content boundary security

By the End of This Lecture, You Will Be Able To:

• Identify the major interfaces available for interacting with Claude

• Explain the differences between the Claude API, SDK, Claude Code, Claude Desktop, and Claude.ai

• Understand how interface selection affects application development and user interaction

• Recognize why instructions may behave differently across Claude interfaces

• Explain the purpose of system prompts in API-based applications

• Identify appropriate locations for application instructions

• Define content boundaries and explain their importance in secure application design

• Differentiate between trusted developer instructions and untrusted external content

• Recognize potential prompt injection attempts hidden inside uploaded documents or web content

• Explain why untrusted content must be processed as data rather than followed as instructions

• Understand how maintaining trust boundaries reduces the risk of unauthorized application behavior

• Select the Claude API or SDK for programmable application integrations

• Identify when Claude Code is appropriate for terminal-based software development tasks

• Recognize when Claude Desktop or Claude.ai is suitable for interactive, everyday use

• Apply interface selection and content boundary principles to Claude application design scenarios

• Answer certification exam questions involving Claude interfaces, instruction handling, trusted content, and prompt injection risks

This lecture is part of Domain 2: Applications and Integration of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of Claude interfaces, system instructions, content boundaries, trusted and untrusted data, prompt injection awareness, and interface selection for secure Claude-based application design.

In this lecture, you'll learn how schemas, session hygiene, and plugin management help you design reliable and predictable Claude-based applications. Through practical examples, you'll explore how to define structured outputs, maintain clean conversation sessions, and manage plugins as versioned dependencies to support consistent application behavior.

Topics Covered:

• Understanding what a schema is and how it defines a fixed structure for data

• Exploring how schemas specify the expected format of Claude-generated responses

• Comparing structured outputs with free-text responses in application integrations

• Understanding how predictable output structures simplify downstream data processing

• Exploring practical schema examples involving customer names, order amounts, and dates

• Identifying common schema design problems, including unclear field names and unnecessary fields

• Understanding three principles of effective schema design: Minimal Fields, Clear Names, and Stable Structure

• Recognizing why stable schemas are important for downstream application compatibility

• Understanding how schemas support output validation and reliable application behavior

• Introducing session hygiene and its role in maintaining clean conversation context

• Exploring why unrelated tasks should be separated into different conversation sessions

• Understanding how stale conversation history can influence responses and cause context drift

• Recognizing when to start a new session to prevent unrelated information from affecting subsequent tasks

• Understanding plugins as modular components that extend Claude's capabilities

• Exploring why plugins should be managed as versioned dependencies

• Recognizing how plugin updates can affect application behavior

• Understanding the importance of tracking plugin names and versions for troubleshooting and configuration management

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of schemas in Claude-based applications

• Define structured output requirements using clearly identified fields

• Differentiate between free-text responses and schema-based outputs

• Recognize the benefits of predictable data structures for application integration

• Identify unclear or unnecessary fields in poorly designed schemas

• Apply best practices for creating small, clear, and stable schemas

• Understand how schemas support output validation and downstream processing

• Explain the importance of session hygiene in AI-powered applications

• Recognize how unrelated conversation history can introduce irrelevant context

• Identify when a new conversation session should be created

• Apply session management practices to reduce context contamination and goal drift

• Explain how plugins extend application capabilities

• Understand why plugins should be tracked and managed like software dependencies

• Recognize the importance of plugin versioning for consistent application behavior

• Identify how plugin updates may introduce unexpected changes

• Apply schema design, session hygiene, and plugin management principles to Claude application design scenarios

This lecture is part of Domain 2: Applications and Integration of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of structured output schemas, session hygiene, context management, plugin versioning, and dependency management for reliable Claude-based applications.

Reduce repetitive learning objectivesAdd a concise lecture title

In this lecture, you'll learn how configuration management helps maintain consistent and predictable behavior in Claude-based applications throughout their lifecycle. Through practical examples, you'll explore the roles of CLAUDE.md and settings.json, understand why model version pinning matters, and learn how to track prompts, plugins, and configuration changes using version control.

Topics Covered:

• Understanding configuration management and how it differs from application code

• Exploring three important configuration components: Instructions, Settings, and Versions

• Recognizing how configuration changes can affect application behavior without modifying source code

• Understanding the purpose of CLAUDE.md as a project-level instruction file for Claude Code

• Exploring how CLAUDE.md provides standing instructions, coding conventions, and project-specific guidance

• Understanding why CLAUDE.md provides behavioral guidance rather than guaranteed enforcement

• Introducing settings.json as a structured configuration file for managing Claude Code behavior and permissions

• Differentiating between instructions in CLAUDE.md and machine-readable controls in settings.json

• Understanding how permissions and hooks support stronger enforcement of operational restrictions

• Exploring how Git version control helps track and manage configuration file changes

• Understanding model version pinning and why using an automatically updated model can introduce unexpected behavior changes

• Recognizing how pinning a tested model version supports consistent application performance

• Exploring the importance of testing before deliberately upgrading to a newer Claude model

• Understanding prompt versioning and how previous prompt versions can be restored when output quality declines

• Exploring plugin dependency management and the importance of tracking plugin versions

• Understanding how model pinning, prompt versioning, plugin tracking, and configuration management work together to prevent unexpected application changes

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of configuration management in Claude-based applications

• Differentiate between application code and configuration settings

• Identify important configuration components that influence application behavior

• Explain the purpose and structure of the CLAUDE.md file

• Use CLAUDE.md to define project-specific instructions and coding conventions

• Recognize why written instructions alone cannot guarantee enforcement of security restrictions

• Explain how settings.json controls configurable behavior and tool permissions

• Differentiate between behavioral guidance and machine-enforced configuration controls

• Understand why configuration files should be maintained under Git version control

• Explain the importance of pinning Claude model versions in production applications

• Recognize the risks associated with automatically changing model versions

• Understand how deliberate model upgrades and testing help maintain application reliability

• Track prompt versions and restore earlier versions when necessary

• Recognize why plugin versions should be recorded and managed as dependencies

• Apply configuration management practices to improve application predictability and maintainability

• Identify appropriate configuration and versioning strategies in certification exam scenarios

This lecture is part of Domain 2: Applications and Integration of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of configuration management, CLAUDE.md, settings.json, model version pinning, prompt versioning, plugin dependency tracking, and reliable application maintenance.

Add a concise lecture titleReduce repetition between sections

In this hands-on lab, you'll learn how to set up the Civics project, a practical Claude-powered application designed to process citizen complaints for a municipal ward office. Through a real-world scenario, you'll explore the project structure, sample complaint data, environment configuration, dependency management, and Anthropic API connectivity before beginning the hands-on demonstrations for Domain 2.

Topics Covered:

• Introducing the Civics project and its role in demonstrating Claude application development and integration concepts

• Exploring a practical scenario involving Asha Kulkarni, a ward clerk at a Pune Municipal Corporation ward office

• Understanding how citizens submit complaints through text messages, photographs, and other input formats

• Exploring the project's objective of reading complaints, classifying requests, drafting acknowledgements, and routing complaints to appropriate departments

• Understanding how the Civics project supports seven hands-on demonstrations covering Domain 2 concepts

• Exploring the project folder structure, including lab documentation, Python demonstration scripts, sample data, and core utilities

• Understanding the structure of sample complaint records stored in JSON format

• Identifying complaint fields such as complaint ID, ward, received date, communication channel, citizen information, text, and photo references

• Exploring the sample photographs and complaint files used throughout the project

• Understanding the purpose of the data_seed directory and how it preserves the original sample complaint data

• Using reset_data.py to create a fresh working dataset before running demonstrations

• Understanding the difference between the original seed data and the working data directory

• Reusing an existing Python virtual environment for the Civics project

• Configuring the Anthropic API key through the .env file

• Exploring dependency management using pyproject.toml and uv sync

• Running the setup verification script to check credentials, model configuration, complaint availability, and API connectivity

• Executing a sample Anthropic API request and observing the response and token usage

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and objectives of the Civics application

• Understand how Claude can support municipal complaint processing and departmental routing

• Identify the types of citizen complaints and input formats supported by the project

• Navigate the Civics project directory structure

• Locate the hands-on lab documentation and demonstration scripts

• Understand the structure of JSON-based complaint records

• Identify the purpose of sample complaint files, photographs, and helper utilities

• Explain the difference between seed data and working data

• Execute reset_data.py to prepare a fresh dataset for experiments

• Reuse an existing Python environment for application development

• Configure the Anthropic API key for the project

• Manage project dependencies using uv and pyproject.toml

• Run the setup verification script to validate the development environment

• Confirm that complaint data and API credentials are accessible

• Execute a test request to verify communication with the Anthropic API

• Interpret basic API responses and token usage information

• Prepare the Civics project for subsequent hands-on labs covering Claude application development and integration

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with project setup, JSON-based complaint data, environment configuration, dependency management, dataset initialization, and Anthropic API connectivity for the application development and integration concepts covered in Domain 2: Applications and Integration.

Remove repeated learning outcomesAdd a clear lab workflowClarify setup prerequisites

In this hands-on lab, you'll learn how clear business and technical requirements influence the architecture of Claude-based applications. Through two practical demonstrations using the Civics municipal complaint management project, you'll compare vague requirements with detailed specifications and explore how functional and infrastructure requirements guide application design decisions.

Topics Covered:

• Understanding why requirements gathering is essential before designing Claude-based applications

• Exploring how business requirements influence application architecture and implementation decisions

• Introducing two demonstrations: p1-requirements-vague.py and p1-requirements-spec.py

• Understanding the limitations of vague requirements such as "Build me something that handles complaints"

• Identifying how incomplete requirements create unanswered questions and architectural uncertainty

• Recognizing why vague instructions force developers and AI systems to make assumptions

• Exploring how detailed specifications reduce ambiguity and establish clear expectations

• Understanding functional requirements and how they define the capabilities of the Civics application

• Defining complaint classification into eight departments

• Exploring complaint prioritization using priority levels P1 through P4

• Understanding infrastructure requirements such as workload volume, operating hours, response times, and processing costs

• Evaluating a practical workload involving approximately 400 citizen complaints per day

• Understanding how application requirements influence real-time processing, streaming, caching, and batch processing decisions

• Recognizing why non-urgent end-of-day reporting can be suitable for batch processing

• Comparing the architectural implications of vague and detailed application specifications

• Understanding why requirements clarification is more efficient than correcting architectural mistakes later

By the End of This Lecture, You Will Be Able To:

• Explain how requirements influence the architecture of Claude-based applications

• Differentiate between vague business requests and detailed technical specifications

• Identify missing information in incomplete application requirements

• Understand how unclear requirements lead to assumptions and inconsistent design decisions

• Define functional requirements for a municipal complaint management application

• Identify infrastructure requirements related to scale, performance, cost, and processing schedules

• Explain how complaint classification and priority assignment become application requirements

• Recognize how workload characteristics influence architecture selection

• Understand when real-time processing is appropriate for citizen-facing interactions

• Identify scenarios where streaming can improve the user experience

• Explain why batch processing is suitable for non-urgent reporting workloads

• Recognize the role of caching in application performance and cost optimization

• Compare architectural decisions derived from vague and detailed specifications

• Apply structured requirements analysis to avoid unnecessary architectural complexity

• Understand why requirements should be clarified before implementation begins

• Apply functional and infrastructure requirement concepts to Claude application design scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with requirements analysis, functional and infrastructure specifications, architectural decision-making, and workload-based design choices covered in Domain 2: Applications and Integration.

In this hands-on lab, you'll learn how to process text and image inputs, implement streaming responses, and configure different Claude API clients. Through four practical demonstrations using the Civics municipal complaint management project, you'll explore how vision improves complaint analysis, how streaming enhances the user experience, and how Claude can be accessed through Anthropic, Amazon Bedrock, and Google Cloud Vertex AI.

Topics Covered:

• Understanding multi-format input processing in Claude-based applications

• Exploring four demonstrations involving text-only input, vision, streaming, and cloud provider clients

• Running a text-only complaint processing demonstration using the Anthropic Messages API

• Understanding the limitations of analyzing citizen complaints without attached photographs

• Exploring a pothole complaint scenario where text alone cannot provide complete visual information

• Using Claude's vision capabilities to process complaint text and accompanying images

• Comparing text-only and image-enabled requests based on available information and input token consumption

• Understanding how image inputs increase token usage and influence API processing costs

• Evaluating when additional visual information justifies the cost of image processing

• Introducing streaming responses using client.messages.stream()

• Comparing standard API requests using client.messages.create() with streaming responses

• Understanding how streaming displays Claude-generated responses incrementally instead of waiting for the complete answer

• Exploring how streaming improves the experience of citizens waiting for complaint acknowledgements

• Recognizing when real-time streaming is appropriate and when asynchronous batch processing may be preferable

• Comparing Claude API access through Anthropic, Amazon Bedrock, and Google Cloud Vertex AI

• Understanding how API client initialization and authentication requirements differ across cloud providers

• Exploring the use of different vendor clients without making additional API requests

By the End of This Lecture, You Will Be Able To:

• Explain how Claude processes text and image inputs in a single application

• Execute text-only complaint processing using the Anthropic API

• Identify the limitations of complaint classification when visual evidence is unavailable

• Use Claude's vision capabilities to analyze photographs submitted with citizen complaints

• Compare the information available in text-only and multimodal API requests

• Understand how image processing affects input token consumption and API costs

• Determine when visual information provides sufficient value to justify additional processing costs

• Differentiate between standard and streaming Claude API responses

• Implement streaming responses using client.messages.stream()

• Explain how streaming improves perceived responsiveness in interactive applications

• Identify when streaming is appropriate for citizen-facing complaint acknowledgement systems

• Recognize when non-urgent workloads are better suited to batch processing

• Differentiate between Anthropic, Amazon Bedrock, and Google Cloud Vertex AI access options

• Understand the authentication and client configuration requirements of different Claude API providers

• Select appropriate input formats, response delivery methods, and API clients based on application requirements

• Apply multimodal processing, streaming, and cloud provider integration concepts to Claude application development scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with text and image processing, Claude vision, streaming responses, token usage analysis, and multi-provider API client configuration covered in Domain 2: Applications and Integration.

Add a concise hands-on lab summarySeparate theory from practical activities

In this hands-on lab, you'll learn how to choose between real-time API requests and asynchronous batch processing in Claude-based applications. Through three practical demonstrations using the Civics municipal complaint management project, you'll compare synchronous request processing with the Message Batches API and explore how response urgency, processing time, and cost influence application architecture decisions.

Topics Covered:

• Understanding the differences between real-time processing and asynchronous batch processing

• Exploring how response urgency and workload size influence API processing decisions

• Introducing three demonstrations: Real-Time Loop, Batch Submission, and Batch Result Retrieval

• Processing citizen complaints sequentially using client.messages.create()

• Understanding how synchronous API requests wait for individual responses before continuing

• Measuring the processing time and token consumption of 12 real-time complaint classification requests

• Evaluating the implications of scaling sequential processing to approximately 400 complaints per day

• Introducing the Claude Message Batches API for processing multiple non-urgent requests asynchronously

• Submitting multiple complaint classification requests using client.messages.batches.create()

• Understanding how batch processing returns a unique batch ID for tracking submitted requests

• Exploring how batch IDs can be stored and reused across separate program executions

• Monitoring batch processing status using client.messages.batches.retrieve()

• Understanding why batch submission and result retrieval are implemented as separate operations

• Observing asynchronous processing statuses, including In Progress and Succeeded

• Retrieving completed batch results and examining complaint classification outputs

• Comparing real-time and batch processing based on turnaround time, token usage, and API costs

• Understanding why batch processing offers reduced pricing in exchange for delayed results

• Identifying when real-time API calls, streaming responses, or asynchronous batch processing are appropriate

By the End of This Lecture, You Will Be Able To:

• Explain the fundamental differences between synchronous and asynchronous API processing

• Execute real-time Claude API requests using client.messages.create()

• Process multiple citizen complaints sequentially and analyze the results

• Measure wall-clock processing time and input and output token consumption

• Understand how request volume influences processing time and operational costs

• Explain the purpose and advantages of the Claude Message Batches API

• Submit multiple API requests together using client.messages.batches.create()

• Retrieve and store batch IDs for tracking asynchronous jobs

• Monitor batch execution status using client.messages.batches.retrieve()

• Understand why batch jobs may continue processing after the submitting program exits

• Retrieve and interpret completed batch processing results

• Recognize the cost advantages and turnaround-time trade-offs of asynchronous batch processing

• Differentiate between real-time responses, streaming responses, and batch processing

• Select real-time processing when users require immediate responses

• Identify batch processing as a suitable option for high-volume, non-urgent workloads

• Apply processing mode selection principles to Claude application architecture and certification exam scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with synchronous API calls, asynchronous batch submission, batch ID tracking, status polling, result retrieval, and cost-aware processing decisions covered in Domain 2: Applications and Integration.

Reduce repeated learning objectivesMake the topic list more scannable

In this hands-on lab, you'll learn how to optimize Claude-based applications using prompt caching, model selection, and thinking effort configuration. Through three practical demonstrations using the Civics municipal complaint management project, you'll compare API processing costs with and without caching, explore how different Claude models handle tasks of varying complexity, and understand how reasoning effort affects token consumption, response quality, and overall efficiency.

Topics Covered:

• Understanding the importance of cost and performance optimization in Claude-based applications

• Exploring three demonstrations: No Caching, Prompt Caching, and Thinking Effort Configuration

• Running complaint classification requests without prompt caching enabled

• Understanding how repeated system instructions increase input token consumption

• Analyzing token usage when processing 12 citizen complaints without caching

• Recognizing how repeated prompt content contributes to unnecessary API processing costs

• Implementing prompt caching to reuse common system instructions across multiple requests

• Understanding cache creation and cache reads using the cache_control configuration

• Exploring how ephemeral caching reduces the cost of repeatedly processing identical prompt content

• Comparing cache write costs, cache read costs, and normal input token costs

• Evaluating the potential cost savings of prompt caching for large-scale complaint processing

• Understanding Claude model selection based on task complexity, response quality, speed, and cost

• Comparing Claude Haiku, Sonnet, and Opus for different workload requirements

• Exploring how thinking effort can be configured independently of model selection

• Understanding how thinking configuration affects reasoning behavior and token consumption

• Comparing model outputs for simple and complex citizen complaints

• Analyzing differences in department classification, priority assignment, and output token usage

• Understanding why increased reasoning effort does not automatically guarantee a different or better result

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of prompt caching in Claude-based applications

• Identify repeated prompt content that can benefit from caching

• Execute complaint classification requests without prompt caching

• Measure input and output token consumption across multiple API requests

• Implement prompt caching using the cache_control configuration

• Differentiate between cache creation, cache reads, and regular input processing

• Understand the cost implications of cache writes and subsequent cache reads

• Compare API costs and token usage with and without caching

• Recognize when prompt caching is beneficial for high-volume applications

• Explain how task complexity influences Claude model selection

• Differentiate between typical use cases for Haiku, Sonnet, and Opus

• Configure thinking effort for different processing requirements

• Understand how model selection and thinking configuration act as separate optimization decisions

• Compare model responses for simple and complex complaint classification tasks

• Evaluate response quality, processing cost, and token consumption when selecting models

• Recognize why more expensive models or higher thinking effort may not always be necessary

• Apply prompt caching, model selection, and thinking effort optimization techniques to Claude-based application scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with prompt caching, cache cost analysis, Claude model selection, thinking effort configuration, token usage optimization, and performance-aware application design covered in Domain 2: Applications and Integration.

In this hands-on lab, you'll learn how to design reliable and secure Claude-based applications using structured output schemas, content boundaries, and proper session management. Through four practical demonstrations using the Civics municipal complaint management project, you'll explore why natural-language output parsing can fail, how schemas improve data consistency, how to protect sensitive citizen information, and how to prevent conversation history from leaking between users.

Topics Covered:

• Understanding the importance of application design when integrating Claude with databases and other systems

• Exploring four demonstrations: Prose Parsing, Schema-Based Tool Outputs, Content Boundaries, and Session Hygiene

• Running a prose parsing demonstration where Claude generates complaint classification results in natural language

• Understanding why inconsistent response formats can cause parsing failures and incorrect data extraction

• Exploring how variations in department names, priority labels, and response formatting affect downstream applications

• Implementing structured outputs using a defined triage_tool and its input schema

• Understanding how tool schemas establish expected fields and data formats for complaint classification

• Comparing free-text parsing with schema-based responses for reliable data processing

• Recognizing the importance of validating department names and priority values before accepting classification results

• Understanding content boundaries and the separation between trusted system instructions and untrusted citizen complaints

• Exploring how malicious instructions embedded in complaint text can attempt to override application behavior

• Identifying personally identifiable information (PII), including citizen names, phone numbers, and residential details

• Applying checks to prevent sensitive citizen information from being unnecessarily exposed or stored

• Understanding session hygiene and why conversation histories must remain isolated between different citizens

• Exploring a scenario where Sunita's complaint history is accidentally included in Ramesh's API request

• Recognizing how reusing conversation histories across users can cause privacy leaks without generating technical errors

• Implementing separate conversation sessions while preserving relevant follow-up history for each citizen

• Understanding how application interfaces such as the Claude API, Claude Code, Claude.ai, and Claude Desktop differ in their instruction handling and context

By the End of This Lecture, You Will Be Able To:

• Explain why structured application design is essential for reliable Claude integrations

• Identify the limitations of parsing unstructured natural-language responses

• Recognize how inconsistent response formatting can affect database operations

• Define structured output requirements using tool schemas

• Understand how triage_tool supports predictable complaint classification outputs

• Compare prose parsing with schema-based data extraction

• Validate structured responses before sending information to downstream systems

• Differentiate between trusted application instructions and untrusted citizen-submitted content

• Recognize potential prompt injection attempts embedded in complaint descriptions

• Identify sensitive personal information that requires protection

• Apply content boundary checks to reduce the risk of unauthorized instructions and information exposure

• Explain the importance of session isolation in multi-user applications

• Recognize how shared conversation histories can unintentionally expose one citizen's information to another

• Maintain relevant conversation history for follow-up questions within the same user session

• Create separate conversation histories for different citizens

• Understand how application interfaces and their surrounding context influence instruction handling

• Apply schema validation, content protection, and session management principles to secure Claude-based applications

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with structured output schemas, tool-based classification, content boundaries, PII protection, prompt injection awareness, session isolation, and interface considerations covered in Domain 2: Applications and Integration.

Reduce the learning outcomesRemove repeated topics and outcomes

In this hands-on lab, you'll learn how to transform Claude-based Python scripts into web services, process multiple API requests concurrently, and handle unexpected responses safely. Through three practical demonstrations using the Civics municipal complaint management project, you'll explore HTTP endpoints, asynchronous concurrency, and defensive response parsing to build more reliable Claude-powered applications.

Topics Covered:

• Understanding the difference between running a Python script and exposing application functionality through a web service

• Exploring three demonstrations: HTTP Web Service, Asynchronous Concurrency, and Defensive Parsing

• Building a simple HTTP server using Python's http.server module

• Understanding how web services allow other users and applications to access the Civics complaint management system

• Creating and testing HTTP endpoints such as /health and /complaint

• Handling POST requests to submit citizen complaints for Claude-based processing

• Understanding common HTTP status codes, including 200, 400, 404, and 502

• Exploring how an application responds to valid requests, missing fields, unavailable endpoints, and backend failures

• Understanding how to start and stop a local HTTP server safely

• Exploring the limitations of processing multiple Claude API requests sequentially

• Implementing asynchronous concurrency to process multiple complaints simultaneously

• Comparing sequential processing of 12 complaints with concurrent processing of four requests at a time

• Measuring execution time and understanding how concurrency improves throughput for API-bound workloads

• Understanding why asynchronous processing makes better use of time spent waiting for Claude API responses

• Introducing defensive parsing and the importance of validating external API responses

• Exploring common response-handling failures involving unexpected content blocks, empty responses, and missing tool calls

• Comparing naive response parsing with defensive parsing techniques

• Understanding how retries and error feedback can help recover from unexpected model responses

• Recognizing the importance of returning actionable errors instead of allowing applications to crash unexpectedly

By the End of This Lecture, You Will Be Able To:

• Explain the benefits of exposing Claude-based functionality through an HTTP web service

• Build a basic Python HTTP server for handling citizen complaint requests

• Understand how /health and /complaint endpoints support application integration

• Differentiate between successful HTTP responses, invalid requests, missing endpoints, and backend errors

• Explain how external applications can communicate with a Claude-powered service

• Understand the limitations of sequential API request processing

• Implement asynchronous concurrency for processing multiple API requests

• Compare sequential and concurrent execution times for complaint classification workloads

• Recognize how concurrency improves throughput without requiring faster individual model responses

• Identify situations where asynchronous execution is beneficial for application performance

• Explain why Claude API responses should be validated before processing

• Recognize common parsing failures caused by empty content, unexpected response structures, and missing tool calls

• Differentiate between naive parsing and defensive response-handling approaches

• Implement checks for missing or unexpected API response content

• Understand how retry mechanisms and error feedback can support recovery from invalid responses

• Handle unexpected API behavior without unnecessarily crashing the application

• Apply HTTP integration, asynchronous concurrency, and defensive parsing techniques to improve the reliability of Claude-based applications

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with HTTP web services, API endpoint development, asynchronous concurrency, performance comparison, defensive response parsing, and error handling covered in Domain 2: Applications and Integration.

In this hands-on lab, you'll learn how to manage application configuration, track model and prompt versions, understand the software development lifecycle, and distinguish between application-level settings and Claude Code configuration. Through three practical demonstrations using the Civics municipal complaint management project, you'll explore how to make application behavior traceable, reproducible, and easier to troubleshoot.

Topics Covered:

• Understanding configuration management and why it is essential for reliable Claude-based applications

• Exploring three demonstrations: Configuration Management, System Lifecycle, and Plugins and Configuration

• Understanding how the Civics project manages configuration through core/config.py and shared configuration files

• Exploring model version pinning and why using a specific Claude model version helps prevent unexpected behavior changes

• Understanding prompt versioning using files such as triage_v1.txt and triage_v2.txt

• Recognizing the importance of recording active model versions, prompt versions, and application settings

• Exploring how configuration details can be logged at application startup for auditing and troubleshooting

• Understanding how configuration records help investigate historical complaint classification errors

• Exploring the eight lifecycle stages presented in the demonstration: Requirements, Design, Build, Test, Deploy, Operate, Maintain, and Retire

• Understanding the purpose of each lifecycle stage and the consequences of skipping important development activities

• Recognizing how AI applications differ from traditional software because model behavior, prompts, and generated outputs can change

• Understanding why model pinning, prompt management, and testing are essential throughout the application lifecycle

• Exploring how the Civics project separates business logic, HTTP integration, configuration, and demonstration scripts

• Differentiating between application configuration and Claude Code-specific configuration

• Understanding how the .env file and application configuration control the Civics service

• Exploring the roles of CLAUDE.md and .claude/settings.json in configuring Claude Code

• Recognizing why Claude Code instructions and local settings are not automatically included in Civics API requests

• Understanding how local configuration differences can cause developers to experience different Claude Code behavior

• Exploring plugins, skills, commands, and connectors as extensions of the Claude Code development environment

• Recognizing why application configuration and developer tooling configuration must be managed separately

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of configuration management in Claude-based applications

• Identify the configuration files used by the Civics project

• Understand how model versions and prompt versions influence application behavior

• Explain why pinning a specific Claude model version improves reproducibility

• Track active prompt versions and configuration settings

• Recognize the importance of logging configuration information for future audits

• Investigate application behavior by identifying which model, prompt, and settings were active during execution

• Describe the eight software lifecycle stages presented in the demonstration

• Understand the consequences of skipping important lifecycle activities

• Recognize the unique maintenance challenges associated with generative AI applications

• Explain how code organization and separation of responsibilities improve maintainability

• Differentiate between application-level configuration and Claude Code configuration

• Identify the roles of .env, core/config.py, CLAUDE.md, and .claude/settings.json

• Understand why Claude Code-specific instructions do not automatically control production API behavior

• Recognize how differences in local developer settings can affect development workflows

• Explain how plugins, skills, commands, and connectors relate to the Claude Code environment

• Apply configuration tracking, version management, and lifecycle principles to improve the reliability and traceability of Claude-based applications

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with configuration management, model version pinning, prompt versioning, software lifecycle planning, application auditing, and Claude Code configuration concepts covered in Domain 2: Applications and Integration.

In this lecture, you'll learn the essential building blocks of Claude Code, including rules, skills, slash commands, agents, and memory. Through practical examples, you'll explore how these components help configure Claude Code, automate repetitive tasks, manage project instructions, and delegate specialized work while keeping conversation context organized.

Topics Covered:

• Understanding what Claude Code is and how it works directly within a software development project

• Exploring Claude Code interfaces, including the terminal, desktop application, and integrated development environments (IDEs)

• Understanding how Claude Code reads files, executes commands, edits code, and helps identify and fix errors

• Introducing rules and how project-specific instructions can be organized inside the .claude/rules/ directory

• Exploring how focused rule files, such as database.md, frontend.md, and testing.md, provide relevant guidance for different parts of a project

• Understanding how path-specific rules help reduce unnecessary context usage

• Introducing Claude Code skills as reusable instructions for specific tasks

• Exploring the structure of a skill using SKILL.md, including its name, description, and task instructions

• Understanding how skills can be invoked manually or selected automatically when a relevant task is identified

• Exploring built-in slash commands such as /init, /clear, and /compact

• Understanding how custom slash commands provide reusable shortcuts for team-specific workflows

• Introducing specialized Claude Code agents for tasks such as code review, test writing, and refactoring

• Understanding how sub-agents use independent context to perform focused tasks and report results to the main session

• Exploring the benefits of context isolation and parallel execution when using specialized agents

• Understanding the difference between developer-authored project instructions in CLAUDE.md and Claude Code's auto memory

• Recognizing how persistent memory helps retain useful project information and working preferences across sessions

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and key capabilities of Claude Code

• Identify the different environments in which Claude Code can operate

• Understand how Claude Code interacts directly with project files and development tools

• Explain the purpose of the .claude/rules/ directory

• Organize project instructions into focused rule files

• Recognize how relevant rules help maintain cleaner conversation context

• Define the purpose of Claude Code skills and their reusable task instructions

• Understand the structure and role of a SKILL.md file

• Differentiate between manually invoked and automatically selected skills

• Identify common built-in slash commands and explain their purposes

• Recognize how custom commands simplify repetitive development activities

• Explain how specialized Claude Code agents handle delegated subtasks

• Understand how independent agent contexts support focused execution

• Differentiate between project instructions stored in CLAUDE.md and automatically retained memory

• Recognize how persistent memory supports continuity between development sessions

• Select appropriate Claude Code building blocks based on project requirements

• Apply rules, skills, commands, agents, and memory concepts to certification exam scenarios

This lecture is part of Domain 3: Claude Code of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of Claude Code capabilities, project rules, reusable skills, slash commands, specialized agents, and persistent memory for AI-assisted software development.

In this lecture, you'll learn how to initialize, configure, and run Claude Code for software development projects. Through practical examples, you'll explore project initialization, the CLAUDE.md instruction hierarchy, settings management, session controls, and different execution modes, including interactive, headless, streaming, and auto mode.

Topics Covered:

• Understanding how to start working with Claude Code in an existing software development project

• Using the /init command to analyze a repository and generate an initial CLAUDE.md file

• Understanding why generated project instructions should be reviewed and customized

• Exploring the CLAUDE.md instruction hierarchy across user, project, and subdirectory levels

• Understanding how general project instructions and more specific directory-level instructions work together

• Reviewing the purpose of .claude/settings.json as a machine-readable configuration file

• Understanding how user-level and project-level settings contribute to Claude Code configuration

• Exploring tool permissions and configuration precedence across different settings files

• Understanding Claude Code session management capabilities, including resume, checkpoints, branching, and reset

• Using session resume to continue previous development work

• Exploring checkpoints and how they allow developers to restore earlier project states

• Understanding why checkpoints cannot reverse external side effects such as API calls or sent messages

• Using /clear to reset conversation context when switching tasks or managing cluttered sessions

• Comparing interactive and headless Claude Code execution

• Running Claude Code interactively using the claude command

• Using claude -p for non-interactive execution in scripts and CI/CD pipelines

• Understanding streaming JSON output for applications that process execution events incrementally

• Exploring auto mode and how automatic permission reviews can reduce manual approval requests

• Differentiating between streaming output controls and automatic tool approval mechanisms

By the End of This Lecture, You Will Be Able To:

• Initialize a Claude Code project using /init

• Explain how Claude Code generates initial project instructions from repository information

• Customize CLAUDE.md to include project-specific guidance

• Identify the different levels of the CLAUDE.md instruction hierarchy

• Understand how broad and directory-specific instructions apply to development tasks

• Explain the purpose of .claude/settings.json in Claude Code configuration

• Recognize how configuration files influence tool permissions and application behavior

• Manage Claude Code sessions using resume, checkpoints, branching, and /clear

• Differentiate between restoring a checkpoint and using Git version control

• Recognize the limitations of checkpoints when external actions have already occurred

• Execute Claude Code interactively from the terminal

• Use headless execution for automated scripts and CI/CD workflows

• Understand how streaming JSON output supports programmatic integrations

• Explain the purpose of auto mode in reviewing and approving tool requests

• Differentiate between output streaming and permission automation

• Select appropriate Claude Code execution modes based on development and automation requirements

• Apply Claude Code initialization, configuration, session management, and execution concepts to certification exam scenarios

This lecture is part of Domain 3: Claude Code of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of project initialization, CLAUDE.md hierarchy, settings configuration, session management, checkpoints, interactive and headless execution, streaming output, and automatic permission handling.

Remove overlapping learning outcomesClarify checkpoint and Git differences

In this hands-on lab, you'll learn how to set up Claude Code, explore an existing Python repository, and manage development sessions effectively. Through a practical library management project called ShelfMark, you'll explore Claude Code installation, project initialization, CLAUDE.md instructions, conflicting project rules, context monitoring, conversation compaction, and session resumption.

Topics Covered:

• Introducing the ShelfMark project and its role in demonstrating Claude Code development and configuration concepts

• Exploring a library lending system that manages books, members, loans, and overdue fines

• Understanding the project structure, including Python source files, test cases, lab documentation, and demonstration scripts

• Exploring the .claude directory containing agents, commands, skills, and settings

• Understanding why the project includes multiple CLAUDE.md files with potentially conflicting instructions

• Introducing the difference between the current fine policy of ₹2 per day and the legacy fine policy of ₹1.50 per day

• Resetting the demonstration repository to restore its original state before experiments

• Installing and configuring the required Python testing dependency, pytest

• Installing Claude Code and understanding the available installation options for Windows, macOS, and Linux

• Launching Claude Code from the terminal and authenticating with a Claude account

• Verifying the development environment and running project test cases

• Exploring deliberately failing test cases related to conflicting fine calculation policies

• Using /init to analyze the repository and generate or update project instructions in CLAUDE.md

• Asking Claude Code questions about repository functionality and business rules

• Using /context to inspect conversation context usage and token allocation

• Understanding how reading additional project files increases conversation context consumption

• Using /compact to summarize conversation history and reduce context usage

• Exiting Claude Code and resuming an earlier development session using its session identifier

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and structure of the ShelfMark library management project

• Identify the roles of project source files, test cases, demonstrations, and Claude Code configuration files

• Understand how multiple CLAUDE.md files can provide different instructions for different project areas

• Recognize potential conflicts between current and legacy business rules

• Reset a demonstration repository to a known starting state

• Install and launch Claude Code from the terminal

• Authenticate Claude Code using an available account

• Verify that Python dependencies and project testing tools are configured correctly

• Execute project tests and identify intentionally failing test cases

• Initialize or update project documentation using /init

• Use Claude Code to explore an existing repository and explain its functionality

• Identify differences between current and legacy fine calculation policies

• Inspect context window usage using /context

• Recognize how additional file reads and conversation turns increase context consumption

• Reduce conversation history using /compact

• Understand how compaction helps manage long-running development sessions

• Resume a previous Claude Code session without starting the conversation from scratch

• Apply Claude Code initialization, repository exploration, context management, and session handling techniques to software development workflows

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with Claude Code setup, repository initialization, CLAUDE.md configuration, project testing, context monitoring, conversation compaction, and session resumption covered in Domain 3: Claude Code.

In this hands-on lab, you'll learn how to configure project instructions and tool permissions in Claude Code using CLAUDE.md files and settings.json. Through practical demonstrations with the ShelfMark library management project, you'll explore how instruction hierarchy works, how folder-specific rules handle exceptions, and how permission settings control which operations Claude Code can perform.

Topics Covered:

• Understanding the difference between project instructions and enforceable tool permissions in Claude Code

• Exploring the ShelfMark project and its use of multiple CLAUDE.md files across different directories

• Resetting the demonstration repository to restore a clean environment before testing configuration changes

• Understanding the CLAUDE.md hierarchy and how instructions apply at different directory levels

• Exploring root-level project instructions that establish shared coding conventions

• Understanding how directory-specific CLAUDE.md files introduce rules for particular areas of a project

• Comparing root-level instructions with specialized rules in the legacy and tests directories

• Exploring conflicting instructions involving Python type hints and legacy code restrictions

• Understanding why legacy code may require different conventions from modern application code

• Recognizing how more specific directory instructions can provide exceptions to broader project rules

• Exploring the settings.json configuration file for managing Claude Code tool permissions

• Understanding three permission behaviors: Allow, Ask, and Deny

• Identifying operations that can run automatically without additional approval

• Exploring permission requirements for sensitive operations, including changes to legacy files

• Understanding how permission settings can restrict operations involving environment files, data directories, destructive commands, and Git operations

• Comparing behavioral guidance in CLAUDE.md with permission enforcement through settings.json

• Recognizing when to use project instructions for coding conventions and permission settings for restricting sensitive operations

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of project rules and permissions in Claude Code

• Differentiate between instructional guidance and enforceable permission controls

• Identify the locations and purposes of multiple CLAUDE.md files within a project

• Understand how root-level and directory-specific instructions work together

• Recognize how specialized instructions handle exceptions to general project conventions

• Explain how legacy code requirements may differ from modern development standards

• Analyze conflicting rules involving type hints and coding conventions

• Understand why focused directory instructions are preferable to placing every exception in one large file

• Locate and inspect Claude Code permission settings in settings.json

• Differentiate between Allow, Ask, and Deny permission behaviors

• Identify which operations can proceed automatically and which require human approval

• Recognize operations that should be restricted because they involve sensitive data or destructive actions

• Explain why CLAUDE.md instructions do not provide the same enforcement guarantees as permission settings

• Select appropriate configuration mechanisms for coding conventions, project rules, and security restrictions

• Apply instruction hierarchy and permission management concepts to practical Claude Code development scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with CLAUDE.md instruction hierarchy, directory-specific rules, settings.json configuration, tool permissions, and enforceable execution controls covered in Domain 3: Claude Code.

Reduce the repeated learning outcomesAdd a concise hands-on workflow

In this hands-on lab, you'll learn how Claude Code applies project instructions and enforces tool permissions during real development tasks. Through practical demonstrations using the ShelfMark library management project, you'll explore how CLAUDE.md instruction hierarchy influences Claude's decisions, how settings.json controls file modifications, and how Claude responds when users request actions that conflict with project rules.

Topics Covered:

• Understanding how Claude Code applies project-specific instructions and permission settings during live execution

• Exploring the differences between instructions defined in CLAUDE.md and permissions configured in settings.json

• Understanding how root-level and directory-specific CLAUDE.md files influence development tasks

• Exploring a conflict between root-level Python type hint conventions and legacy directory restrictions

• Requesting type hints for the compute_fine function in legacy/old_fines.py

• Observing how Claude Code handles conflicting instructions from different levels of the project hierarchy

• Understanding why more specific legacy directory rules can take precedence over general project conventions

• Exploring how settings.json controls permission requirements for modifying sensitive project files

• Understanding how Claude Code requests human approval before performing certain file modifications

• Using Shift + Tab to switch between available Claude Code permission modes

• Exploring manual approval behavior when modifying files in the legacy directory

• Requesting a change to the legacy overdue fine rate from ₹1.50 to ₹2 per day

• Observing how a denied permission request prevents the proposed file modification

• Exploring a scenario where Claude Code is asked to delete a deliberately failing test

• Understanding how project instructions protect important regression tests from inappropriate changes

• Recognizing why deleting failing tests merely to make a test suite pass is not an appropriate solution

• Comparing instruction-based behavioral guidance with tool-level permission enforcement

By the End of This Lecture, You Will Be Able To:

• Explain how Claude Code uses project instructions during development tasks

• Differentiate between CLAUDE.md guidance and settings.json permission controls

• Identify how directory-specific instructions influence files within their scope

• Recognize conflicts between general coding conventions and legacy project requirements

• Understand how Claude Code responds to instructions that conflict with established project rules

• Explain why legacy code may require exceptions to standard development conventions

• Locate and interpret file modification permissions configured in settings.json

• Understand when Claude Code requires human approval before editing sensitive files

• Switch between available Claude Code permission modes

• Review and reject proposed changes that require manual authorization

• Recognize how permission controls prevent unauthorized file modifications

• Explain the difference between Claude choosing not to perform an action and a permission system blocking that action

• Identify inappropriate requests involving the deletion of deliberately failing tests

• Understand how persistent project instructions help maintain coding standards across sessions

• Select appropriate mechanisms for behavioral guidance, coding conventions, and enforceable restrictions

• Apply instruction hierarchy and permission enforcement concepts to practical Claude Code development scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with CLAUDE.md instruction hierarchy, legacy code conventions, settings.json permissions, manual approval workflows, permission modes, and project rule enforcement covered in Domain 3: Claude Code.

In this hands-on lab, you'll learn how to extend Claude Code using custom slash commands, reusable skills, and specialized sub-agents. Through practical demonstrations using the ShelfMark library management project, you'll explore how to automate repetitive development tasks, invoke skills with supporting Python scripts, and delegate focused work to sub-agents with independent context.

Topics Covered:

• Understanding how Claude Code extensions help automate repetitive development activities

• Exploring three extension types: Custom Slash Commands, Skills, and Sub-Agents

• Understanding the structure of the .claude directory and its commands, skills, and agents subdirectories

• Validating the configuration and availability of custom Claude Code extensions

• Comparing slash commands, skills, and sub-agents based on their purpose and execution behavior

• Understanding custom slash commands as reusable prompts stored in Markdown files

• Exploring custom commands such as /test-report and /explain-fine

• Using positional arguments such as $1 and $2 to pass values into custom slash commands

• Executing /test-report to run project tests and review their results

• Using /explain-fine with overdue days and membership category arguments

• Understanding skills as reusable task instructions that can include supporting code and resources

• Exploring the Overdue Notice skill and its SKILL.md and generate.py files

• Understanding how skill descriptions help Claude Code identify when a skill is relevant

• Invoking skills explicitly or through natural-language requests

• Generating overdue notices for library members using a reusable skill

• Understanding sub-agents as specialized helpers that operate with independent context

• Exploring the Convention Checker sub-agent for reviewing project coding standards

• Delegating a review of legacy/import_members.py to the Convention Checker agent

• Understanding how sub-agents return focused results without filling the main conversation with unnecessary details

By the End of This Lecture, You Will Be Able To:

• Explain how Claude Code can be extended with commands, skills, and sub-agents

• Identify the directory structure used to organize Claude Code extensions

• Differentiate between custom slash commands, reusable skills, and specialized agents

• Determine when a repeated prompt should become a slash command

• Understand how Markdown files define custom slash commands

• Execute custom slash commands from the Claude Code interface

• Pass arguments into commands using $1 and $2

• Run project testing and reporting tasks through reusable commands

• Explain how skills combine instructions with supporting scripts and resources

• Identify the purpose of SKILL.md and related Python files

• Invoke Claude Code skills using natural-language instructions

• Generate overdue notices using the ShelfMark project's reusable skill

• Understand how skill descriptions support automatic skill selection

• Explain the purpose of sub-agents and their independent execution context

• Delegate code review tasks to a specialized Convention Checker agent

• Interpret sub-agent reports against project-specific coding conventions

• Select the appropriate extension type based on task repetition, reusable instructions, and context isolation

• Apply Claude Code extensibility concepts to practical development and automation scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with custom slash commands, parameterized commands, reusable skills, Python-backed skill execution, specialized sub-agents, and task delegation covered in Domain 3: Claude Code.

In this hands-on lab, you'll learn how to automate development tasks using Claude Code's headless execution mode and command-line interface (CLI). Through practical demonstrations using the ShelfMark library management project, you'll explore non-interactive execution, structured output formats, session continuation, automated bug fixing, and test validation using custom Claude Code commands.

Topics Covered:

• Understanding how Claude Code supports automation without requiring an interactive session

• Exploring headless execution for repetitive development and maintenance tasks

• Introducing automation scenarios involving repository audits, pre-commit checks, and log analysis

• Using claude -p to execute a specific instruction, print the result, and exit

• Comparing interactive Claude Code sessions with non-interactive CLI execution

• Running a headless command to summarize the ShelfMark project's overdue fine policy

• Understanding how headless execution can support automated scripts and development pipelines

• Exploring different CLI output formats, including Text, JSON, and Stream JSON

• Using --output-format json to generate structured output for programmatic processing

• Understanding how Stream JSON supports incremental processing of execution events

• Exploring session continuation using --resume or -r with a session identifier

• Understanding how -c can continue the most recent Claude Code session

• Identifying a deliberately failing test in the ShelfMark project's fine calculation functionality

• Using Claude Code to investigate the cause of a failing test and implement the necessary code changes

• Understanding the role of edit approvals during automated development tasks

• Running the custom /test-report command to verify the results of code modifications

• Comparing test results before and after bug fixing, including the final successful execution of all 13 tests

• Recognizing the importance of validating AI-generated code changes through automated testing

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and benefits of headless execution in Claude Code

• Differentiate between interactive and non-interactive Claude Code workflows

• Execute one-time development tasks using claude -p

• Understand how headless execution can support repository audits, pre-commit checks, and other automation tasks

• Generate structured CLI output using the --output-format option

• Differentiate between Text, JSON, and Stream JSON output formats

• Recognize when structured output is useful for automated scripts and integrations

• Resume a previous Claude Code session using its session identifier

• Continue the most recent session using the appropriate CLI option

• Use Claude Code to investigate failing Python tests

• Identify and correct issues affecting the ShelfMark fine calculation functionality

• Understand how edit permissions and approvals affect automated code modification

• Execute custom Claude Code commands to validate development changes

• Run the project's automated test suite after implementing a fix

• Verify that all 13 test cases pass after resolving the identified issue

• Explain why successful test execution is essential for validating AI-assisted code changes

• Apply Claude Code CLI automation, session management, bug fixing, and test validation techniques to practical software development workflows

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with Claude Code headless execution, CLI output formats, session continuation, automated debugging, code modification, custom commands, and test validation covered in Domain 3: Claude Code.

Reduce repetition between sectionsAdd a concise lab workflow

In this lecture, you'll learn how to systematically debug Claude-based applications by identifying error types, locating the source of failures, analyzing execution traces, and selecting appropriate recovery strategies. Through practical examples, you'll explore common API errors, distinguish integration problems from model output issues, and understand why effective debugging begins with diagnosis rather than trial and error.

Topics Covered:

• Understanding the importance of systematic debugging in Claude-based applications

• Introducing the four-step debugging approach: Error Type, Origin, Trace, and Recovery

• Recognizing why randomly changing prompts, configurations, or retry settings can make troubleshooting more difficult

• Understanding common Claude API error codes and their meanings

• Exploring HTTP 429 errors caused by exceeding API rate limits

• Understanding HTTP 529 errors caused by temporary service overload

• Identifying HTTP 400 errors resulting from malformed or invalid API requests

• Differentiating between integration-layer failures and model output problems

• Exploring integration issues involving application code, network communication, and API requests

• Understanding model output failures involving missing JSON fields or unexpected response structures

• Introducing execution traces and how they help identify where a request failed

• Analyzing the execution sequence: Request, Tool Call, Tool Result, and Response

• Identifying failure modes involving missing tool calls, invalid tool results, and incorrect interpretation of tool outputs

• Understanding why different failure types require different recovery approaches

• Applying exponential backoff when retrying temporary service overload errors

• Using retry-after information to handle API rate-limit errors

• Recognizing why malformed requests and invalid schemas must be corrected rather than repeatedly retried

• Understanding how accurate failure classification reduces debugging time and improves application reliability

By the End of This Lecture, You Will Be Able To:

• Explain the importance of classifying errors before attempting to fix them

• Apply the four-step debugging process: Type, Origin, Trace, and Recover

• Identify common Claude API errors using HTTP status codes

• Explain the differences between 429 rate-limit errors, 529 overload errors, and 400 bad-request errors

• Differentiate between problems originating in application integration and problems involving Claude-generated outputs

• Recognize when an API request succeeds but the returned data does not meet application expectations

• Analyze execution traces to identify the exact stage where a failure occurred

• Understand the purpose of tracing tool requests, tool execution results, and final responses

• Identify specific failure modes in Claude-powered workflows

• Determine when retrying an API request is appropriate

• Apply exponential backoff to recover from temporary service overloads

• Use retry-after guidance to handle rate-limit errors

• Recognize when malformed API requests require corrections instead of retries

• Select appropriate recovery strategies based on the identified error type

• Avoid unnecessary retries and ineffective debugging approaches

• Apply systematic troubleshooting techniques to improve the reliability of Claude-based applications

• Answer certification exam questions involving API errors, execution tracing, failure classification, and recovery strategies

This lecture is part of Domain 4: Evaluation, Testing and Debugging of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of API error classification, integration troubleshooting, execution traces, failure modes, retry strategies, and systematic recovery techniques for Claude-based applications.

Reduce repetition between the two listsMake the recovery terminology consistent

In this hands-on lab, you'll learn how to evaluate the accuracy of Claude-based applications using human-verified ground truth and identify silent errors that do not produce technical failures. Through a practical exam grading project called RedPen, you'll explore how multiple workers process exam papers, how incorrect calculations can lead to inaccurate results, and why reliable evaluation requires a carefully prepared answer key.

Topics Covered:

• Introducing the RedPen project and its role in demonstrating evaluation, testing, and debugging concepts

• Exploring a practical scenario involving Asha, a teacher responsible for grading eight student exam papers

• Understanding a two-worker architecture where Claude reads marks and Python code calculates totals and grades

• Exploring the RedPen project structure, including sample exam papers, demonstration scripts, and ground truth data

• Resetting the working dataset to prepare a fresh environment for evaluation experiments

• Verifying project setup, required dependencies, sample files, and Anthropic API connectivity

• Understanding the four-stage grading process: Exam Paper, Claude Extraction, Python Calculation, and Ground Truth Validation

• Exploring how Claude extracts marks from handwritten or text-based examiner records

• Understanding how incorrect interpretation of question-level subtotals can lead to double-counting

• Analyzing a grading scenario where a student receives an impossible score of 84 out of 80

• Identifying how separate question components and their subtotals can be incorrectly added together

• Understanding why the correct score of 70 differs from the incorrectly calculated total

• Introducing ground truth as a human-verified reference for evaluating application outputs

• Understanding why an answer key is essential for identifying incorrect results

• Exploring edge cases involving grade boundaries and pass/fail classifications

• Recognizing how an incorrect comparison operator can produce an inaccurate grade

• Understanding silent failures where an application returns an incorrect result without displaying an error

• Recognizing why evaluation datasets must include difficult cases and boundary conditions rather than only straightforward examples

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of the RedPen exam grading project

• Understand how multiple workers collaborate to process exam papers

• Differentiate between Claude-based information extraction and Python-based calculation

• Navigate the project's sample data and ground truth files

• Reset and verify the development environment before running evaluation demonstrations

• Describe the four stages of the automated exam grading process

• Identify how double-counting question subtotals can produce incorrect marks

• Recognize impossible grading results, such as scores exceeding the maximum available marks

• Explain the importance of human-verified ground truth in evaluating AI applications

• Compare application-generated results against an established answer key

• Identify silent errors that do not trigger exceptions or API failures

• Understand how boundary conditions affect grade and pass/fail calculations

• Recognize the difference between > and >= when implementing grading thresholds

• Explain why evaluation datasets should include edge cases and difficult examples

• Identify whether incorrect results originate from data extraction or calculation logic

• Understand why successful program execution does not guarantee correct application output

• Apply ground truth validation and edge-case testing principles to Claude-based application evaluation

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with multi-worker evaluation, exam grading validation, human-verified ground truth, silent error detection, calculation debugging, and boundary-condition testing covered in Domain 4: Evaluation, Testing and Debugging.

In this hands-on lab, you'll learn how to identify different failure types in Claude-based applications and select appropriate recovery strategies. Through two practical demonstrations using the RedPen exam grading project, you'll explore why generic error messages are insufficient, how to detect incorrect results that produce no errors, and why different failures require different recovery actions.

Topics Covered:

• Understanding the importance of identifying specific failure types in Claude-based applications

• Exploring the RedPen grading system, where Claude extracts exam marks and Python code calculates totals and grades

• Resetting the sample dataset before running debugging and recovery demonstrations

• Understanding why the previous calculation bug is intentionally fixed to isolate new failure scenarios

• Introducing two demonstrations: Error Classification and Error Recovery

• Comparing generic error reporting with detailed, actionable failure classification

• Understanding why displaying the same error message for different problems makes troubleshooting difficult

• Exploring API service overload as a temporary integration failure

• Identifying failures caused by missing or unreadable exam paper information

• Recognizing problems involving incomplete or improperly structured Claude-generated responses

• Exploring silent failures where the system produces incorrect marks without raising an exception

• Analyzing grading discrepancies, including scores of 41 instead of 47 and 14 instead of 37

• Understanding why incorrect results without technical errors are particularly difficult to detect

• Recognizing the importance of ground truth for identifying silent grading mistakes

• Exploring why retrying every failed operation is not an effective recovery strategy

• Understanding how temporary service overloads can be handled by waiting and retrying

• Exploring how incomplete model responses may require another Claude request

• Recognizing when missing source information requires human intervention instead of repeated API calls

• Comparing blind retries with recovery decisions based on the actual failure type

By the End of This Lecture, You Will Be Able To:

• Explain why specific error classification is essential for effective debugging

• Differentiate between integration failures, model output problems, and silent correctness errors

• Identify the responsibilities of Claude and Python code within the RedPen grading system

• Understand why isolating known bugs helps investigate new failure scenarios

• Recognize the limitations of generic error messages

• Identify different failure types based on their underlying causes

• Detect incorrect grading results that do not generate technical errors

• Compare system-generated marks against human-verified ground truth

• Explain why a successful execution does not guarantee an accurate result

• Differentiate between temporary failures and problems requiring corrective action

• Recognize when retrying an operation is appropriate

• Apply a wait-and-retry approach to temporary service overloads

• Understand when an incomplete Claude response should be requested again

• Identify situations where missing exam paper information requires human review

• Explain why blindly retrying every failure can waste time and resources

• Select appropriate recovery strategies based on specific error classifications

• Apply failure diagnosis and recovery principles to Claude-based application debugging scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with error classification, silent failure detection, ground truth validation, retry strategies, human escalation, and failure-specific recovery mechanisms covered in Domain 4: Evaluation, Testing and Debugging.

In this hands-on lab, you'll learn how to use execution traces, failure origin analysis, and evaluation harnesses to identify and verify problems in Claude-based applications. Through three practical demonstrations using the RedPen exam grading project, you'll explore how to trace mistakes to individual workers, distinguish model errors from application code bugs, and measure whether code fixes actually improve system accuracy.

Topics Covered:

• Understanding the importance of execution tracing, failure origin analysis, and systematic evaluation in Claude-based applications

• Exploring the RedPen grading system, where Claude reads exam marks and Python code calculates totals and grades

• Resetting the sample dataset to ensure consistent evaluation conditions

• Understanding why recording only the final result is insufficient for diagnosing incorrect outputs

• Introducing execution traces as detailed records of intermediate processing steps

• Running the tracing demonstration to observe what each worker reads, processes, and returns

• Analyzing a grading discrepancy where Aditya receives 41 marks instead of the correct 47

• Identifying how Claude incorrectly reads Question 7's score of 7 as 1

• Understanding how intermediate trace records help locate the exact stage where an error occurs

• Exploring failure origin analysis to determine whether an issue comes from source data, Claude extraction, or Python calculation logic

• Comparing errors caused by missing paper information, incorrect model extraction, and application code bugs

• Understanding why incorrect results should not automatically be blamed on Claude

• Analyzing an example where six errors originate from application code, one from Claude, and one from source data

• Introducing evaluation harnesses for systematically testing application outputs against human-verified ground truth

• Running repeated evaluations across eight exam papers under different code configurations

• Comparing baseline results with results after correcting the marks calculation logic

• Measuring the improvement from zero correct totals to six correct totals after fixing the calculation bug

• Evaluating the additional impact of correcting grade assignment logic

• Understanding why fixing one component at a time makes it easier to measure the effectiveness of each change

• Recognizing why evaluation results provide stronger evidence than simply assuming a fix worked

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of execution traces in debugging Claude-based applications

• Understand how recording intermediate steps improves error diagnosis

• Identify the exact processing stage where an incorrect result originates

• Analyze discrepancies between source exam marks and Claude-extracted values

• Recognize errors caused by incorrect character or number interpretation

• Differentiate between model extraction errors, application code bugs, and missing source information

• Perform failure origin analysis across multiple workers

• Explain why application failures should not automatically be attributed to the AI model

• Use trace information to identify which component requires correction

• Understand the purpose of an evaluation harness

• Compare generated grading results against human-verified ground truth

• Evaluate application accuracy across multiple exam papers

• Establish a baseline before making changes to application logic

• Fix one issue at a time and measure its impact on evaluation results

• Understand how correcting calculation and grading logic can improve system accuracy

• Identify remaining errors after implementing code fixes

• Use measurable evaluation results to determine whether a fix was effective

• Apply tracing, failure isolation, and evaluation-driven debugging techniques to improve the reliability of Claude-based applications

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with execution tracing, failure origin identification, multi-worker debugging, ground truth comparison, evaluation harnesses, and systematic fix verification covered in Domain 4: Evaluation, Testing and Debugging.

In this lecture, you'll learn how Large Language Models (LLMs) work, including tokenization, context windows, next-token generation, sampling, and non-deterministic behavior. Through beginner-friendly examples, you'll explore how Claude processes text, generates responses one token at a time, and why identical prompts can produce slightly different outputs.

Topics Covered:

• Understanding the fundamental working principles of Large Language Models (LLMs)

• Introducing tokens as the basic units of text processing in language models

• Understanding how text is divided into tokens rather than complete words

• Exploring tokenization through simple examples involving words and word fragments

• Understanding why token counts determine API usage costs and context consumption

• Using the approximate relationship between characters and tokens for estimating text length

• Introducing the context window as the maximum amount of information a model can process in a single request

• Understanding how system prompts, conversation history, and documents share the available context window

• Recognizing why even large context windows have finite capacity

• Exploring next-token generation and how language models produce responses incrementally

• Understanding how previously generated tokens influence subsequent token predictions

• Introducing sampling and how models choose from multiple possible next-token candidates

• Exploring how candidate tokens are assigned probabilities during text generation

• Understanding how temperature influences output consistency and variation

• Comparing lower-temperature generation with higher-temperature generation

• Introducing non-determinism and why identical prompts can produce different responses

• Understanding why output variation is a normal characteristic of language models

• Recognizing how non-determinism affects testing and validation of Claude-based applications

• Understanding why AI application testing should focus on output correctness rather than exact text matching

By the End of This Lecture, You Will Be Able To:

• Explain the basic principles behind how Large Language Models process and generate text

• Define tokens and understand their role in language model operations

• Differentiate between words, characters, and tokens

• Estimate approximate token counts for English text

• Explain how token consumption influences API pricing and application costs

• Define the context window and understand its limitations

• Identify the different types of information that occupy a model's context window

• Explain how Claude generates responses through next-token prediction

• Understand how generated tokens become part of the context for subsequent predictions

• Describe how sampling determines which token is selected during generation

• Explain how temperature influences the variability of model outputs

• Differentiate between more predictable and more varied generation behavior

• Understand why identical prompts may produce slightly different responses

• Recognize that non-deterministic behavior does not necessarily indicate an application error

• Explain why traditional exact-string testing may be unsuitable for evaluating AI-generated responses

• Apply tokenization, context window, sampling, and non-determinism concepts to Claude model selection and optimization scenarios

This lecture is part of Domain 5: Model Selection and Optimization of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of LLM tokenization, context windows, next-token generation, sampling, temperature, and non-deterministic behavior for understanding and optimizing Claude-based applications.

In this lecture, you'll learn how Claude's thinking modes and prompting techniques influence response quality, speed, and token consumption. Through beginner-friendly examples, you'll explore fast mode, extended thinking, adaptive thinking, effort levels, and zero-shot, single-shot, and multi-shot prompting to understand how to select the appropriate approach for different tasks.

Topics Covered:

• Understanding the relationship between thinking modes, prompting techniques, response quality, and API costs

• Introducing fast mode and how Claude generates responses without an additional extended reasoning stage

• Exploring why fast mode is appropriate for everyday tasks such as summarization, rewriting, and simple questions

• Understanding the speed and cost advantages of using fast mode for straightforward tasks

• Introducing extended thinking and how additional reasoning supports complex problem-solving

• Exploring extended thinking for mathematical problems, multi-step logic, and careful planning

• Recognizing the trade-offs between improved reasoning capabilities, token consumption, and response latency

• Understanding adaptive thinking and how Claude dynamically determines when deeper reasoning is necessary

• Exploring thinking effort levels: Low, Medium, High, X-High, and Max

• Understanding how effort settings influence reasoning depth, performance, and cost

• Comparing adaptive thinking with the earlier approach of manually specifying thinking token budgets

• Introducing zero-shot prompting and how Claude performs tasks without receiving examples

• Exploring zero-shot classification using positive and negative customer reviews

• Understanding single-shot prompting and how one example demonstrates the expected response pattern

• Introducing multi-shot prompting and how multiple examples help establish consistent output formats

• Comparing zero-shot, single-shot, and multi-shot prompting based on complexity, consistency, and token usage

• Recognizing why additional reasoning and examples should be introduced only when necessary

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of different thinking modes in Claude

• Differentiate between fast mode, extended thinking, and adaptive thinking

• Identify when fast mode is suitable for everyday tasks

• Recognize scenarios where extended thinking can improve complex reasoning

• Understand how additional reasoning affects response time and token consumption

• Explain how adaptive thinking determines the need for deeper reasoning

• Identify the available thinking effort levels and their intended purposes

• Differentiate between adaptive thinking and fixed thinking token budgets

• Define zero-shot prompting and recognize when it is sufficient

• Write simple zero-shot prompts for classification and other common tasks

• Explain how single-shot prompting uses one example to establish an expected output pattern

• Understand how multi-shot prompting uses multiple examples to improve consistency

• Select appropriate examples to demonstrate different classification categories

• Compare prompting approaches based on response consistency, task requirements, and token costs

• Recognize why more examples or higher thinking effort do not automatically produce better results

• Apply a cost-conscious approach by starting with simpler prompting and reasoning configurations

• Select suitable thinking modes and prompting techniques for Claude model optimization and certification exam scenarios

This lecture is part of Domain 5: Model Selection and Optimization of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of fast mode, extended thinking, adaptive thinking, effort levels, zero-shot prompting, single-shot prompting, and multi-shot prompting for optimizing Claude-based applications.

Reduce Repetition Between SectionsAdd A Clear Lecture Title

In this lecture, you'll learn how Software Development Kits (SDKs) simplify communication with Claude's REST API and how different connection methods support AI applications. Through beginner-friendly examples, you'll explore SDK functionality, authentication, error handling, automatic retries, streaming, and the differences between REST APIs and WebSocket connections.

Topics Covered:

• Understanding the purpose of a Software Development Kit (SDK) in AI application development

• Introducing SDKs as convenient wrappers around REST APIs

• Comparing raw HTTP requests with simplified SDK function calls

• Exploring the POST /v1/messages endpoint used to communicate with Claude

• Understanding how SDKs simplify API interactions through methods such as client.messages.create()

• Exploring SDK support for Python and TypeScript applications

• Understanding how SDKs automatically handle API authentication and request headers

• Exploring error handling and how SDKs convert API failures into readable exceptions

• Understanding automatic retries and exponential backoff for temporary API failures

• Connecting SDK retry behavior with HTTP 429 rate-limit and HTTP 529 service overload errors

• Exploring how SDKs simplify streaming responses and incremental token delivery

• Understanding why SDK calls still use the underlying REST API

• Recognizing that SDKs provide convenience without changing the fundamental API behavior

• Understanding how existing API concepts involving messages, tools, and JSON continue to apply when using an SDK

• Exploring when direct REST API requests may be useful instead of SDK methods

• Introducing WebSocket connections and how they maintain a persistent, two-way communication channel

• Comparing REST request-response communication with continuous WebSocket connections

• Exploring real-time application scenarios involving live voice interactions and bidirectional streaming

• Comparing REST and WebSocket connections based on communication patterns, latency, and application requirements

• Understanding when to choose SDK-based REST communication and when persistent connections are more appropriate

By the End of This Lecture, You Will Be Able To:

• Define an SDK and explain its role in simplifying API integration

• Differentiate between raw REST API requests and SDK-based API calls

• Explain how client.messages.create() interacts with Claude's Messages API

• Recognize the benefits of using official SDKs for Python and TypeScript development

• Understand how SDKs manage authentication and API request configuration

• Explain how SDKs simplify API error handling

• Understand automatic retries and exponential backoff for temporary failures

• Recognize how SDKs can assist with handling rate limits and service overload conditions

• Explain how SDKs support streaming responses

• Understand why an SDK is a convenience layer rather than a replacement for the REST API

• Apply knowledge of API messages, tools, and JSON when working with SDKs

• Identify scenarios where direct REST API access may be appropriate

• Define WebSockets and explain how persistent, bidirectional communication works

• Differentiate between REST request-response interactions and WebSocket connections

• Recognize when real-time communication requires a persistent connection

• Compare REST and WebSocket approaches based on latency, communication patterns, and application needs

• Select appropriate API integration methods for different Claude-based application scenarios

• Apply SDK, REST API, and WebSocket concepts to model integration and certification exam questions

This lecture is part of Domain 5: Model Selection and Optimization of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of SDKs, REST API integration, authentication, error handling, automatic retries, streaming, WebSocket communication, and connection selection for building efficient Claude-based applications.

In this lecture, you'll learn how to choose the right Claude model for different application requirements by comparing Haiku, Sonnet, and Opus. Through practical examples, you'll explore the trade-offs between response quality, latency, and cost, understand model reasoning capabilities, and learn why version pinning and re-evaluation are important when upgrading Claude models.

Topics Covered:

• Understanding the Claude model family and its three tiers: Haiku, Sonnet, and Opus

• Introducing Haiku as a fast, cost-efficient model for simple and high-volume tasks

• Exploring Sonnet as a balanced model offering strong capabilities at a moderate cost

• Understanding Opus as the most capable tier for complex reasoning and demanding tasks

• Comparing Claude models based on capability, response speed, and pricing

• Understanding how different Claude models use a consistent Messages API structure

• Exploring the quality, latency, and cost trade-off triangle in model selection

• Recognizing why the most capable model is not necessarily the best choice for every application

• Comparing extended thinking and adaptive thinking support across different model tiers

• Understanding how advanced reasoning capabilities influence model selection

• Recognizing the importance of verifying thinking-mode support for specific model versions

• Introducing Sonnet as a practical starting point for common Claude application workloads

• Exploring when to choose Haiku for classification, tagging, routing, and other simple tasks

• Understanding when to upgrade to Opus for challenging reasoning and problem-solving

• Identifying common model selection mistakes, including unnecessary spending and insufficient model capability

• Understanding why model behavior can change across different releases

• Exploring how model upgrades can affect response quality, tokenization, latency, and cost

• Understanding the importance of re-evaluating applications when new Claude models become available

• Introducing model version pinning to maintain predictable application behavior

• Recognizing opportunities to reduce costs when newer models can handle tasks previously requiring more capable models

By the End of This Lecture, You Will Be Able To:

• Identify the three main Claude model tiers: Haiku, Sonnet, and Opus

• Explain the strengths and intended use cases of each model tier

• Differentiate between Claude models based on capability, latency, and cost

• Understand how the quality, latency, and cost trade-off influences model selection

• Explain why no single Claude model is ideal for every application

• Recognize how shared API structures simplify switching between Claude models

• Understand the importance of model-specific support for extended and adaptive thinking

• Identify when advanced reasoning capabilities are necessary

• Select Haiku for suitable high-volume and relatively simple workloads

• Choose Sonnet as a starting point for balanced performance and cost

• Recognize when complex tasks justify using Opus

• Avoid unnecessary API expenses caused by selecting overly powerful models

• Recognize situations where choosing a cheaper model may reduce application accuracy

• Explain why model upgrades require testing and performance evaluation

• Understand how model releases may affect response behavior, token usage, and application costs

• Apply model version pinning to support predictable deployments

• Re-evaluate model choices when newer Claude versions become available

• Apply model selection principles to practical Claude application development and certification exam scenarios

This lecture is part of Domain 5: Model Selection and Optimization of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of Claude's Haiku, Sonnet, and Opus model tiers, quality-latency-cost trade-offs, reasoning capabilities, model selection strategies, version pinning, and model upgrade evaluation.

In this lecture, you'll learn how to manage token usage and optimize the cost of Claude-based applications without unnecessarily reducing model capabilities. Through practical examples, you'll explore input and output token pricing, usage tracking, cost estimation, prompt caching, batch processing, and a systematic approach to reducing API expenses.

Topics Covered:

• Understanding how token consumption influences the cost of Claude API requests

• Differentiating between input tokens and output tokens

• Exploring how system prompts, user messages, documents, and conversation history contribute to input token consumption

• Understanding why conversation history increases API costs when repeatedly included in requests

• Recognizing why output tokens generally cost more per token than input tokens

• Exploring how model selection influences overall API expenses

• Understanding the usage information returned in Claude API responses

• Tracking token consumption using input_tokens and output_tokens

• Exploring how usage logging helps identify expensive requests and optimization opportunities

• Understanding the importance of monitoring token consumption over time

• Introducing cost estimation before deploying or scaling Claude-based applications

• Estimating application expenses using token consumption, request volume, and model pricing

• Exploring how cost projections support model selection and application design decisions

• Introducing prompt caching as a technique for reusing repeated system instructions and reference documents

• Understanding how cache creation and cache reads affect token pricing

• Exploring cache checkpointing for long prompts and growing conversations

• Introducing batch processing as a cost optimization technique for non-urgent workloads

• Understanding how shorter prompts can reduce unnecessary input token consumption

• Exploring the recommended optimization order: Caching, Batching, Prompt Reduction, and Model Downgrading

• Recognizing why reducing unnecessary token usage should come before sacrificing model capabilities

By the End of This Lecture, You Will Be Able To:

• Explain how Claude API pricing depends on input tokens, output tokens, and model selection

• Differentiate between input and output token consumption

• Identify common sources of unnecessary token usage in Claude-based applications

• Understand how repeated conversation history can increase API costs

• Interpret token usage information returned in API responses

• Track input and output token consumption using the API's usage fields

• Recognize expensive requests through systematic usage monitoring

• Estimate API expenses before scaling an application

• Calculate projected costs using token counts, request volume, and model-specific pricing

• Understand why input and output token rates should be considered separately when estimating costs

• Explain how prompt caching reduces the cost of repeatedly processing shared context

• Identify application scenarios where prompt caching provides significant benefits

• Understand the purpose of cache checkpointing in long-running conversations

• Recognize when batch processing is appropriate for reducing API expenses

• Apply prompt optimization techniques to reduce unnecessary token consumption

• Compare different cost optimization strategies without immediately changing models

• Understand when switching to a less expensive Claude model may be appropriate

• Prioritize caching, batching, and prompt reduction before model downgrading

• Apply token tracking, cost estimation, and optimization principles to practical Claude application development and certification exam scenarios

This lecture is part of Domain 5: Model Selection and Optimization of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of token-based pricing, API usage tracking, cost estimation, prompt caching, cache checkpointing, batch processing, and cost optimization strategies for building efficient and cost-effective Claude-based applications.

In this hands-on lab, you'll learn how Claude models process text as tokens and how token consumption affects API costs and context window usage. Through practical demonstrations using the Byline news processing project, you'll explore token counting across English and Marathi articles, compare token usage between Haiku, Sonnet, and Opus, and understand how language and model selection influence application costs.

Topics Covered:

• Introducing the Byline project, a fictional morning news processing desk for a Pune newspaper

• Exploring a multilingual news processing application containing English and Marathi articles

• Understanding how Claude models can analyze news articles and generate structured information

• Exploring the Byline project structure, including JSON article files, datasets, and demonstration scripts

• Resetting the project dataset to prepare a clean environment for hands-on experiments

• Verifying project setup, article accessibility, and Claude API connectivity

• Processing a sample news article using Claude and generating structured output

• Understanding how application outputs can be checked against expected results

• Introducing tokens as the fundamental units used for processing text in Large Language Models

• Understanding the relationship between text length, token consumption, and API billing

• Differentiating between input tokens and output tokens

• Recognizing why output token pricing can significantly influence application costs

• Exploring how different languages can produce different token counts for similar content

• Comparing English and Marathi versions of the same Pune Metro news article

• Analyzing an example where English text consumes 100 tokens while Marathi text consumes 189 tokens

• Understanding why multilingual applications require careful token usage estimation

• Comparing token counts for identical text across different Claude model versions

• Exploring an example where Haiku counts 77 tokens while Sonnet counts 100 tokens for the same text

• Comparing token consumption across Haiku, Sonnet, and Opus

• Understanding the context window as the maximum token capacity available within a single model request

• Analyzing token usage when processing a collection of ten news articles

• Recognizing how language selection, model tokenization, and context window limits influence application design

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and structure of the Byline news processing project

• Understand how Claude can process multilingual news articles

• Navigate JSON-based article datasets used in Claude application demonstrations

• Reset and verify the project environment before running experiments

• Process a sample article and understand its associated API usage

• Define tokens and explain their role in Claude model processing

• Differentiate between input and output tokens

• Explain how token counts influence API billing

• Recognize why output token pricing is important when estimating application costs

• Compare token consumption between English and Marathi content

• Understand why text with similar meaning can require different numbers of tokens

• Analyze language-dependent token usage differences in multilingual applications

• Compare token counts for identical input text across different Claude models

• Recognize that tokenization behavior can vary between model versions

• Explain how model selection can influence token consumption and cost

• Understand the purpose and limitations of a model's context window

• Estimate whether a collection of documents can fit within a model's context window

• Interpret token usage results from practical Claude API demonstrations

• Apply token counting, multilingual text analysis, and context window concepts to Claude application optimization scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with token counting, multilingual text processing, model-specific tokenization, input and output token usage, API cost awareness, and context window analysis covered in Domain 5: Model Selection and Optimization.

In this hands-on lab, you'll learn how Claude generates responses, how prompting and thinking modes affect token consumption, and how SDKs simplify API integration. Through practical demonstrations using the Byline news processing project, you'll explore next-token generation, temperature and output variability, zero-shot and few-shot prompting, extended and adaptive thinking, and the differences between raw REST API requests and Claude SDK calls.

Topics Covered:

• Understanding how Claude generates responses one token at a time

• Resetting the Byline project dataset to prepare a clean environment for experimentation

• Exploring next-token prediction and how Claude selects from possible token candidates

• Using a sample news article from article_101.json to demonstrate text generation

• Understanding how max_tokens limits the number of output tokens generated

• Observing how Claude may stop in the middle of a sentence when the output token limit is reached

• Exploring temperature settings and their influence on response consistency and variation

• Comparing lower-temperature and higher-temperature generation behavior

• Understanding non-determinism and why identical prompts can produce different responses

• Exploring SDK compatibility issues and model-specific changes affecting temperature configuration

• Recognizing how model updates can introduce breaking changes in API parameters

• Understanding how clear prompting instructions can improve output consistency

• Comparing zero-shot, one-shot, and few-shot prompting techniques

• Evaluating factual accuracy using examples with different numbers of demonstrations

• Comparing results where zero-shot, one-shot, and few-shot prompting achieve 5, 6, and 7 correct facts out of 10

• Understanding how additional prompting examples increase input token consumption

• Exploring extended thinking and how reasoning budgets affect output token usage

• Understanding adaptive thinking and how Claude determines the reasoning effort required

• Comparing token consumption between standard responses and thinking-enabled responses

• Recognizing why increased reasoning effort does not automatically guarantee better results

• Comparing raw REST API requests with simplified Claude SDK calls

• Understanding how SDKs reduce boilerplate code for authentication, request formatting, and API communication

• Exploring streaming responses using the Claude SDK

By the End of This Lecture, You Will Be Able To:

• Explain how Claude generates responses through next-token prediction

• Understand how sampling influences token selection during text generation

• Use max_tokens to control the maximum length of generated responses

• Recognize why responses may stop before completing a sentence

• Explain how temperature can affect response variability

• Differentiate between more consistent and more varied text generation

• Understand the concept of non-determinism in Claude-based applications

• Recognize potential compatibility issues when API parameters change across model or SDK versions

• Explain how prompting instructions can help control response format and consistency

• Differentiate between zero-shot, one-shot, and few-shot prompting

• Understand how additional examples influence input token consumption

• Compare prompting approaches using factual accuracy measurements

• Explain the purpose of extended thinking and reasoning token budgets

• Understand how adaptive thinking adjusts reasoning effort based on task requirements

• Recognize how thinking modes affect output token consumption and API costs

• Evaluate the trade-offs between reasoning effort, response quality, and token usage

• Differentiate between raw REST API integration and SDK-based API calls

• Explain why SDKs simplify Claude application development

• Understand how the Claude SDK supports streaming responses

• Apply sampling, prompting, thinking, and API integration concepts to practical Claude application optimization scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with next-token generation, sampling, non-determinism, prompting techniques, extended thinking, adaptive thinking, token usage analysis, REST API integration, and Claude SDK streaming covered in Domain 5: Model Selection and Optimization.

In this hands-on lab, you'll learn how to compare Claude models based on response quality, execution speed, and API costs, and how prompt caching can reduce expenses in AI applications. Through practical demonstrations using the Byline news processing project, you'll evaluate Haiku, Sonnet, and Opus across different article complexities, track token consumption, estimate long-term costs, and measure the savings achieved through prompt caching.

Topics Covered:

• Understanding the importance of selecting cost-effective Claude models for real-world applications

• Resetting the Byline project dataset to prepare a clean environment for model comparison experiments

• Comparing the three Claude model tiers: Haiku, Sonnet, and Opus

• Understanding the relationship between model capabilities, response latency, and API pricing

• Exploring model selection through practical comparisons of quality, speed, and cost

• Evaluating Claude models using six easy news articles and four difficult news articles

• Comparing model accuracy across different levels of article complexity

• Understanding why more expensive models do not always produce significantly better results

• Exploring how measured evaluation results support model selection decisions

• Comparing execution times across Haiku, Sonnet, and Opus

• Understanding how input and output token consumption affects the cost of individual API requests

• Tracking token usage across multiple requests for each Claude model

• Comparing the total processing costs of Haiku, Sonnet, and Opus

• Understanding how small differences in per-request costs become significant when processing hundreds of articles daily

• Estimating long-term API expenses for high-volume news processing applications

• Introducing prompt caching as a technique for reducing repeated input token costs

• Understanding minimum cacheable token requirements and cache eligibility

• Exploring cache checkpoints and how reusable prompt content is stored

• Comparing cache creation tokens and cache read tokens across repeated API requests

• Analyzing an example where caching reduces processing costs from approximately 0.63 to 0.25 in the demonstration's reported cost units

• Understanding why cached input reads can be considerably cheaper than processing the same content again

• Recognizing how thinking settings, model parameters, and repeated context influence cost optimization

By the End of This Lecture, You Will Be Able To:

• Explain the importance of evaluating quality, latency, and cost before selecting a Claude model

• Differentiate between Haiku, Sonnet, and Opus based on their performance characteristics

• Compare model performance on easy and difficult news processing tasks

• Understand why model selection should be based on measured results rather than assumptions

• Identify when a less expensive Claude model can satisfy application requirements

• Recognize situations where a more capable model may justify additional costs

• Interpret model evaluation results involving accuracy, processing time, and API expenses

• Track input and output token usage across multiple Claude API requests

• Compare token-based costs between different Claude models

• Estimate how API expenses increase with daily request volume

• Understand the importance of considering long-term costs when designing AI applications

• Explain the purpose and benefits of prompt caching

• Identify repeated system instructions and reference content suitable for caching

• Understand how cache creation and cache read operations work

• Recognize minimum token requirements for creating cacheable content

• Compare API costs with and without prompt caching

• Interpret cache usage information from repeated API calls

• Explain how prompt caching reduces the cost of processing repeated context

• Select appropriate models and caching strategies to balance application quality and operating expenses

• Apply model benchmarking, token tracking, cost estimation, and prompt caching concepts to practical Claude application optimization scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with Claude model comparison, quality-latency-cost evaluation, token usage tracking, long-term API cost estimation, prompt caching, cache checkpoints, and cost optimization strategies covered in Domain 5: Model Selection and Optimization.

In this lecture, you'll learn how to write clear and effective prompts for Claude-based applications by providing specific instructions, relevant context, appropriate roles, and well-defined output formats. Through beginner-friendly examples, you'll explore the fundamentals of prompt engineering, understand the essential components of a prompt, and learn how better instructions improve response quality without requiring changes to the model or application code.

Topics Covered:

• Understanding prompt engineering and its role in improving Claude's response quality

• Comparing vague prompts with clear and specific instructions

• Exploring how poorly defined prompts can produce generic or unexpected responses

• Understanding why prompt engineering is often the simplest and most cost-effective way to improve AI outputs

• Introducing the four main components of a prompt: Instruction, Context, Examples, and Output Format

• Understanding the instruction component and how it defines the task Claude should perform

• Exploring the context component and how background information improves response relevance

• Understanding how examples demonstrate the expected response pattern

• Exploring output formatting instructions and how they influence response presentation

• Recognizing that not every prompt requires all four components

• Comparing vague instructions such as "Write about dogs" with more specific task descriptions

• Understanding how task, length, audience, and tone contribute to effective prompt design

• Exploring how specific instructions reduce ambiguity and unnecessary assumptions

• Introducing roles and system prompts for controlling Claude's behavior

• Understanding how system prompts establish consistent behavior across a conversation

• Exploring a system prompt that configures Claude as a patient mathematics tutor for children

• Differentiating between standing system instructions and individual user requests

• Understanding how output formatting improves readability and usability

• Comparing paragraph-style responses with structured bullet-point answers

• Differentiating between human-readable formatting and machine-readable structured outputs

By the End of This Lecture, You Will Be Able To:

• Define prompt engineering and explain its importance in Claude-based applications

• Explain how prompt clarity influences the quality and relevance of generated responses

• Differentiate between vague and well-structured prompts

• Identify the four essential components of effective prompt design

• Understand when to include instructions, context, examples, and output formatting requirements

• Write clear and specific instructions for Claude

• Improve vague prompts by defining the task, audience, length, and tone

• Recognize how missing information can lead to unexpected model responses

• Explain why prompt improvement should often be attempted before changing models or application code

• Understand the purpose of system prompts in Claude applications

• Define appropriate roles to guide Claude's communication style and behavior

• Differentiate between persistent system-level guidance and task-specific user instructions

• Use system prompts to establish consistent response behavior

• Specify output formats such as bullet points, headings, and short paragraphs

• Improve response readability through clear formatting instructions

• Differentiate between human-readable outputs and machine-readable structured responses

• Apply prompt engineering principles to practical Claude application development scenarios

• Recognize effective prompting techniques in certification exam questions

This lecture is part of Domain 6: Prompt and Context Engineering of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of prompt engineering, prompt components, clear instructions, system prompts, role configuration, and output formatting for designing effective Claude-based applications.

Condense the overlapping learning outcomesGroup the topics into clear categories

In this lecture, you'll learn how to improve Claude's responses using examples, reusable prompt templates, and iterative refinement. Through beginner-friendly examples, you'll explore how to demonstrate expected response patterns, create consistent prompts with variables, and systematically improve prompt quality through testing and small adjustments.

Topics Covered:

• Understanding how examples help Claude recognize expected response patterns

• Introducing the principle of showing examples rather than relying only on written instructions

• Exploring few-shot prompting through customer support response examples

• Demonstrating how friendly responses can be maintained for both satisfied and dissatisfied customers

• Understanding why a small number of carefully selected examples can be more effective than lengthy instructions

• Reviewing zero-shot, single-shot, and multi-shot prompting concepts

• Introducing prompt templates as reusable prompts containing placeholders

• Understanding how template variables such as {customer_name} and {issue} work

• Exploring how one template can generate responses for different customer support scenarios

• Understanding how templates maintain consistent instructions, tone, and response structure

• Recognizing why reusable templates reduce variation between individual requests

• Exploring the benefits of maintaining one central location for prompt improvements

• Understanding how prompt templates support version control and rollback

• Introducing iterative prompt refinement as a continuous improvement process

• Exploring the refinement cycle: Write, Run, Check, Adjust, and Repeat

• Understanding how to identify specific problems in generated responses

• Improving prompts by introducing constraints such as word limits and tone requirements

• Recognizing why small, targeted changes are preferable to repeatedly rewriting an entire prompt

• Understanding how examples, templates, and refinement work together to improve response reliability

By the End of This Lecture, You Will Be Able To:

• Explain how examples influence Claude's response patterns

• Use examples to demonstrate desired tone, style, and formatting

• Differentiate between zero-shot, single-shot, and multi-shot prompting

• Select a suitable number of examples for a given prompting task

• Recognize why carefully chosen examples can improve response consistency

• Define prompt templates and explain their purpose in Claude-based applications

• Create reusable prompts containing dynamic placeholders

• Populate prompt templates with different customer names and issues

• Understand how templates reduce unnecessary variation between requests

• Maintain consistent instructions and formatting across repeated tasks

• Explain why centralized prompt templates simplify ongoing improvements

• Recognize the importance of prompt versioning and rollback

• Apply the iterative refinement process to improve prompt effectiveness

• Identify common prompt problems involving response length, tone, and clarity

• Make targeted adjustments based on observed model outputs

• Test revised prompts to determine whether the changes improve results

• Understand why effective prompt development requires repeated testing and refinement

• Apply examples, reusable templates, and iterative optimization techniques to practical Claude application development and certification exam scenarios

This lecture is part of Domain 6: Prompt and Context Engineering of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of example-based prompting, few-shot learning, reusable prompt templates, prompt consistency, version control, and iterative refinement techniques for building reliable Claude-based applications.

Add a practical learner exerciseReduce repetition across learning outcomes

In this lecture, you'll learn how context engineering improves the accuracy and reliability of Claude-based applications by controlling what information the model receives. Through beginner-friendly examples, you'll explore the differences between prompt engineering and context engineering, understand context rot and attention limitations, and learn how Retrieval-Augmented Generation (RAG) and just-in-time context loading help keep the context window focused and efficient.

Topics Covered:

• Understanding context engineering and its importance in Claude-based applications

• Comparing prompt engineering with context engineering

• Exploring how prompt engineering focuses on writing clear and effective instructions

• Understanding how context engineering manages the complete information provided to Claude in each request

• Identifying major context sources, including system prompts, retrieved documents, conversation history, tool definitions, and stored memory

• Recognizing why context engineering becomes increasingly important in long-running AI agents

• Introducing context rot and how excessive context can reduce information retrieval accuracy

• Understanding why larger context windows do not automatically guarantee better responses

• Exploring how recall accuracy can decrease before reaching the maximum context window limit

• Introducing the attention budget and how irrelevant information competes with important context

• Understanding why high-value information should be prioritized over unnecessary content

• Exploring how instruction placement and document labeling can improve context organization

• Introducing Retrieval-Augmented Generation (RAG) as a technique for retrieving relevant information before generating responses

• Understanding how RAG retrieves selected document chunks instead of loading entire document collections

• Exploring a practical example of retrieving three relevant chunks from a large document repository

• Understanding how targeted retrieval helps reduce unnecessary token consumption and context overload

• Introducing just-in-time context loading for long-running AI agents

• Exploring lightweight references such as file paths, stored queries, and web links

• Understanding how agents retrieve information only when it becomes necessary

• Exploring how Claude Code uses targeted file access instead of loading an entire codebase into context

• Comparing upfront context loading with just-in-time retrieval

• Understanding how RAG and just-in-time context strategies improve context efficiency and application reliability

By the End of This Lecture, You Will Be Able To:

• Define context engineering and explain its role in Claude-based applications

• Differentiate between prompt engineering and context engineering

• Identify the different sources of information included in a model's context window

• Explain why context management is essential for long-running AI agents

• Define context rot and understand its impact on response accuracy

• Recognize why adding more context can sometimes reduce model performance

• Explain the concept of an attention budget in language model processing

• Identify high-value and low-value information within application context

• Apply context organization techniques to improve information accessibility

• Understand why important instructions and clear document labels help guide Claude

• Define Retrieval-Augmented Generation (RAG) and explain how it works

• Describe the retrieval process used to select relevant document chunks

• Explain how RAG reduces unnecessary context compared with loading entire documents

• Recognize when targeted retrieval is preferable to including all available information

• Define just-in-time context loading and explain its benefits

• Understand how lightweight references reduce unnecessary context consumption

• Explain how agents can load files and documents only when needed

• Compare RAG-based retrieval with just-in-time context loading

• Recognize how Claude Code applies targeted information retrieval in software development workflows

• Apply context selection, retrieval, and just-in-time loading techniques to improve Claude application efficiency

• Identify context engineering strategies in practical development scenarios and certification exam questions

This lecture is part of Domain 6: Prompt and Context Engineering of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of context engineering, context rot, attention budgets, Retrieval-Augmented Generation (RAG), context organization, and just-in-time information loading for building efficient and reliable Claude-based applications.

In this lecture, you'll learn how to make Claude-generated outputs more reliable, predictable, and suitable for integration into software applications. Through beginner-friendly examples, you'll explore structured outputs, response validation, refusal and error handling, and consistency techniques that help applications manage the natural variability of AI-generated responses.

Topics Covered:

• Understanding the importance of reliable outputs in Claude-based applications

• Introducing structured outputs and their role in generating predictable, machine-readable responses

• Comparing free-text responses with structured JSON outputs

• Exploring how JSON fields simplify data extraction and application integration

• Understanding the difference between human-readable formatting and machine-readable structured data

• Introducing schemas and how they define expected response structures

• Understanding why Claude-generated responses should be validated before use

• Exploring response validation through required fields, data types, and completeness checks

• Introducing validation gates between Claude's responses and application processing

• Understanding how validation prevents malformed or incomplete outputs from affecting downstream systems

• Differentiating between model refusals and API errors

• Recognizing that a refusal can occur even when an API request completes successfully

• Exploring common API errors, including HTTP 429 rate limits and HTTP 529 service overloads

• Understanding how applications can handle refusals and errors through helpful messages, appropriate retries, and safe fallbacks

• Recognizing why retry strategies should depend on the specific failure type

• Introducing consistency techniques for reducing unwanted variation in Claude-generated responses

• Exploring how lower temperature settings can improve output consistency when supported by the selected model

• Understanding how strict schemas help maintain predictable response structures

• Using examples to demonstrate expected output patterns and maintain consistent styles

• Recognizing how clear formatting instructions reduce ambiguity

• Understanding why non-deterministic model behavior makes validation and error handling essential

• Exploring the reliability mindset of planning for failures instead of assuming every request will succeed

By the End of This Lecture, You Will Be Able To:

• Explain why output reliability is important when building Claude-based applications

• Differentiate between free-text responses and structured outputs

• Understand how JSON improves machine-readable data exchange

• Recognize the role of schemas in defining expected response formats

• Design basic validation checks for Claude-generated responses

• Verify that required fields are present and contain appropriate data types

• Explain why generated outputs should be validated before downstream processing

• Understand how validation gates help prevent incorrect data from entering application workflows

• Differentiate between model refusals and technical API failures

• Recognize common error scenarios involving rate limits and service overloads

• Identify when retrying an API request is appropriate

• Understand why repeated retries are not suitable for every failure

• Apply safe fallback strategies when Claude cannot produce a usable response

• Explain how clear instructions and examples improve response consistency

• Understand how temperature settings can influence output variability

• Recognize how strict schemas reduce unexpected changes in response structure

• Explain why consistent formatting does not guarantee identical responses every time

• Understand the relationship between non-determinism, validation, and application reliability

• Design Claude application workflows that anticipate malformed outputs, refusals, and API errors

• Apply structured output, validation, error handling, and consistency concepts to practical development scenarios and certification exam questions

This lecture is part of Domain 6: Prompt and Context Engineering of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of structured outputs, JSON schemas, response validation, refusal handling, API error recovery, consistency techniques, and reliability-focused prompt engineering for building dependable Claude-based applications.

In this hands-on lab, you'll learn how to write clear, specific, and testable prompts for Claude-based applications. Through practical demonstrations using the Shortlist wedding reception planning project, you'll explore how vague instructions affect results, where to place important rules, how to control response formats, and how examples and iterative refinement improve prompt reliability.

Topics Covered:

• Introducing the Shortlist project and its role in demonstrating prompt engineering concepts

• Exploring a wedding reception planning scenario where Asha needs to shortlist vendors in Pune

• Understanding the vendor directory containing 15 venues, caterers, photographers, and decorators

• Exploring project requirements involving guest capacity, vegetarian catering, alcohol restrictions, event dates, and budget limits

• Resetting the Shortlist project dataset and preparing the development environment

• Introducing the difference between vague prompts and precise, measurable instructions

• Exploring an ambiguous wedding planning request using terms such as "grand," "memorable," and "traditional"

• Understanding why vague descriptions lead Claude to make assumptions about user requirements

• Comparing vendor shortlisting results produced by vague and detailed prompts

• Understanding how explicit rules improve compliance with budget and vendor requirements

• Exploring the importance of writing instructions that can be objectively verified

• Understanding how instructions can be distributed across system prompts, user messages, and tool descriptions

• Comparing the behavior of rules placed in different parts of a Claude application

• Exploring how long conversations can affect instruction compliance

• Understanding when to place persistent requirements in system prompts

• Recognizing the purpose of user messages for task-specific instructions and tool descriptions for tool-related constraints

• Comparing vague formatting requests such as "Be concise" with measurable output requirements

• Controlling response structure through exact line counts, word limits, and formatting restrictions

• Exploring how examples communicate expected behavior when written instructions are insufficient

• Understanding the importance of including unusual or difficult cases in prompting examples

• Introducing iterative prompt refinement by changing one instruction at a time

• Measuring the impact of prompt changes on output quality and rule compliance

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and structure of the Shortlist wedding reception planning project

• Understand how Claude uses vendor information to generate recommendations

• Identify the requirements that influence vendor selection and budget compliance

• Recognize the limitations of vague and ambiguous prompts

• Transform general instructions into clear and measurable requirements

• Write prompts containing explicit constraints for budget, guest capacity, catering, and vendor selection

• Explain why testable instructions improve prompt reliability

• Compare the results of vague and precise prompts using measurable evaluation criteria

• Differentiate between system prompts, user messages, and tool descriptions

• Understand where to place persistent rules and task-specific instructions

• Recognize how instruction placement can affect compliance during longer conversations

• Identify the limitations of relying on vague formatting instructions

• Define measurable response constraints involving line counts, word limits, and output structure

• Use examples to demonstrate desired response patterns

• Recognize when examples are more effective than additional written instructions

• Understand why difficult examples help clarify expected behavior

• Apply iterative refinement to improve prompt quality

• Change one prompt component at a time and measure its effect on results

• Evaluate prompt effectiveness using output quality and requirement compliance

• Apply clear instructions, rule placement, formatting constraints, and example-based prompting to practical Claude application development scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with prompt clarity, measurable instructions, system and user prompt design, tool description rules, output formatting, example-based prompting, and iterative refinement covered in Domain 6: Prompt and Context Engineering.

In this hands-on lab, you'll learn how to manage context efficiently in Claude-based applications by controlling conversation history, reducing unnecessary token consumption, and organizing tasks across sub-agents. Through practical demonstrations using the Shortlist wedding reception planning project, you'll explore context growth, context bloat, rule reinforcement, pruning, compaction, and context isolation to improve application efficiency and reliability.

Topics Covered:

• Understanding the importance of context management in Claude-based applications

• Resetting the Shortlist project dataset to prepare a clean environment for context management experiments

• Introducing the context window as the information Claude can access within a single request

• Exploring how system instructions, conversation history, and tool results contribute to context consumption

• Understanding how growing conversations increase input token usage and API costs

• Introducing context bloat and context rot in long-running conversations

• Exploring how repeated searches and large vendor brochures accumulate in conversation history

• Understanding how important instructions can become harder to follow as context grows

• Comparing token consumption across shorter and longer conversations

• Analyzing an example where context usage increases from approximately 1,700 to 5,485 tokens

• Measuring vendor selection compliance as conversation history increases

• Introducing three context management techniques: Restating Rules, Pruning Tool Outputs, and Compacting History

• Understanding how restating important requirements can reinforce instructions during long conversations

• Exploring pruning as a technique for removing unnecessary or outdated tool results

• Understanding how conversation compaction preserves useful information while reducing historical context

• Comparing context usage and rule compliance before and after applying optimization techniques

• Introducing sub-agents as a method for isolating independent tasks into separate contexts

• Comparing one large conversation with multiple specialized sub-agent conversations

• Exploring a single-agent approach that handles all wedding vendor categories within one shared context

• Understanding a multi-agent approach where four independent workers research venues, caterers, photographers, and decorators

• Exploring how sub-agents return concise findings without carrying complete research histories into the main conversation

• Recognizing when task dependencies make separate sub-agents less appropriate

• Understanding how efficient context organization supports cleaner final decisions and lower token consumption

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of context management in Claude-based applications

• Define the context window and understand how information accumulates within it

• Identify major sources of context consumption, including conversation history and tool outputs

• Explain how longer conversations can increase API costs

• Understand the concepts of context bloat and context rot

• Recognize how excessive context can affect instruction compliance

• Measure context growth using token consumption

• Compare application behavior across short and long conversations

• Apply rule restatement to reinforce important requirements

• Identify unnecessary tool outputs that can be removed from conversation context

• Use context pruning to reduce irrelevant information

• Explain how conversation compaction reduces context usage while preserving important details

• Compare the effectiveness of different context optimization techniques

• Understand how sub-agents provide separate execution contexts for specialized tasks

• Differentiate between single-agent and multi-agent context management approaches

• Explain how delegating independent tasks can reduce context accumulation in the main conversation

• Organize vendor research into separate category-specific tasks

• Understand how concise sub-agent results support efficient final decision-making

• Recognize when dependent tasks should remain within a shared context

• Evaluate context management strategies based on token usage, task requirements, and instruction compliance

• Apply context optimization and sub-agent isolation techniques to practical Claude application development scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with context window management, context bloat, context rot, instruction reinforcement, tool output pruning, conversation compaction, sub-agent delegation, and context isolation covered in Domain 6: Prompt and Context Engineering.

In this hands-on lab, you'll learn how to protect Claude-based applications from untrusted input and validate AI-generated outputs before using them. Through practical demonstrations using the Shortlist wedding reception planning project, you'll explore prompt injection risks, safe handling of external data, structured response parsing, schema validation, and factual verification.

Topics Covered:

• Understanding the importance of treating external input and AI-generated output as untrusted information

• Resetting the Shortlist project dataset to prepare a clean environment for security and validation experiments

• Introducing prompt injection and how malicious instructions can be hidden inside external content

• Exploring a wedding venue scenario where vendor information contains instructions intended to override application rules

• Identifying malicious instructions that attempt to bypass budget and dietary restrictions

• Understanding why external vendor descriptions must be treated as data rather than authoritative instructions

• Recognizing how prompt injection attempts can appear in web pages, emails, PDFs, and other external documents

• Exploring how untrusted content can influence Claude's behavior if appropriate boundaries are not established

• Introducing three techniques for handling external input: Fencing, Labeling, and Limiting

• Understanding how delimiters and tags separate external content from trusted instructions

• Labeling retrieved information explicitly as data rather than instructions

• Limiting the amount of external content included in a model request

• Evaluating whether vendors satisfy established requirements despite misleading claims in their descriptions

• Understanding why Claude's generated responses should be treated as claims rather than automatically accepted facts

• Introducing the three-stage output checking process: Parse, Validate, and Verify

• Understanding how parsing identifies and extracts information from a response

• Exploring schema and field validation to check whether responses have the expected structure and data types

• Understanding factual verification and how application rules can be used to check output correctness

• Comparing careless response handling with defensive output processing

• Analyzing a demonstration where unsafe response handling causes three failures across six sample responses

• Understanding how defensive parsing and validation help applications handle malformed responses without crashing

• Recognizing why confident AI-generated answers still require independent verification

By the End of This Lecture, You Will Be Able To:

• Explain why both external input and AI-generated output require appropriate validation

• Define prompt injection and recognize common injection techniques

• Identify malicious instructions embedded in otherwise legitimate external content

• Differentiate between trusted application instructions and untrusted vendor information

• Understand why external documents should not override application requirements

• Apply fencing techniques to separate source content from instructions

• Label untrusted content clearly as data

• Limit the amount of external information provided to Claude

• Recognize prompt injection attempts involving budget restrictions and vendor selection rules

• Evaluate vendor information against trusted application requirements

• Explain why AI-generated responses should not be trusted without verification

• Differentiate between parsing, schema validation, and factual verification

• Check whether Claude responses contain the expected structure and fields

• Identify malformed or incomplete responses before downstream processing

• Validate response data types and required values

• Verify generated claims against available source data and application rules

• Compare unsafe response handling with defensive processing techniques

• Understand how proper error handling prevents malformed outputs from crashing applications

• Recognize why a confident response is not necessarily an accurate response

• Apply input boundary protection and output validation techniques to practical Claude application development scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with prompt injection protection, untrusted input handling, content fencing, instruction boundaries, response parsing, schema validation, factual verification, and defensive output processing covered in Domain 6: Prompt and Context Engineering.

In this lecture, you'll learn how to secure Claude-based applications against common AI security threats, including prompt injection, malicious external content, and sensitive data exposure. Through beginner-friendly examples, you'll explore direct and indirect attacks, trust boundaries, and practical techniques for protecting application instructions, user information, and confidential credentials.

Topics Covered:

• Understanding why security is essential when building Claude-based applications

• Exploring how AI applications can read files, execute commands, and interact with external tools

• Introducing the attack surface of Claude applications, including user messages, uploaded files, and external websites

• Understanding how increased application capabilities can introduce additional security risks

• Introducing prompt injection as a major security threat to AI-powered applications

• Exploring how malicious instructions can be embedded inside otherwise legitimate documents

• Understanding how prompt injection attempts can manipulate application behavior without exploiting traditional software vulnerabilities

• Differentiating between direct and indirect prompt injection attacks

• Exploring direct prompt injection, where a user attempts to bypass established application rules

• Understanding jailbreak attempts and how attackers use crafted prompts to influence model behavior

• Exploring indirect prompt injection through external content such as web pages, emails, documents, and tool results

• Recognizing why indirect attacks can affect applications even when the original user request is legitimate

• Introducing trust boundaries and their role in separating trusted instructions from untrusted content

• Understanding how system prompts and application-defined rules establish trusted instructions

• Exploring why retrieved documents, uploaded files, and external tool responses should be treated as data rather than instructions

• Understanding how clearly labeling external content helps maintain instruction boundaries

• Introducing Personally Identifiable Information (PII) and common examples of sensitive personal data

• Exploring privacy risks involving names, identification numbers, payment information, and health records

• Understanding three important data protection techniques: Data Minimization, Data Masking, and Access Control

• Recognizing security risks associated with exposed API keys, environment files, and application credentials

• Understanding why sensitive information should be protected throughout AI application workflows

By the End of This Lecture, You Will Be Able To:

• Explain why Claude-based applications require appropriate security controls

• Identify common security risks affecting AI applications with file, tool, and command execution capabilities

• Define the attack surface of an AI-powered application

• Explain what prompt injection is and how it can influence application behavior

• Recognize malicious instructions embedded in external documents and retrieved content

• Differentiate between direct and indirect prompt injection

• Identify jailbreak attempts involving malicious user instructions

• Understand how indirect prompt injection can originate from web pages, emails, uploaded files, and tool responses

• Explain why external information must not automatically be treated as trusted instructions

• Define trust boundaries and explain their importance in secure AI application design

• Differentiate between trusted application instructions and untrusted source content

• Understand how content labeling and instruction separation help reduce prompt injection risks

• Recognize why prompt-based boundaries should be supported by appropriate application-level security controls

• Define Personally Identifiable Information (PII)

• Identify common categories of sensitive information requiring protection

• Explain how data minimization reduces unnecessary exposure of confidential information

• Understand how data masking and redaction protect sensitive fields

• Recognize the importance of access controls in protecting application data and resources

• Identify risks associated with exposed API keys and .env files

• Apply prompt injection awareness, trust boundary principles, and data protection techniques to practical Claude application development scenarios

This lecture is part of Domain 7: Security and Safety of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of AI application security, attack surfaces, prompt injection, direct and indirect attacks, trust boundaries, personally identifiable information, data minimization, masking, access control, and credential protection.

In this lecture, you'll learn how to keep Claude-based applications safe through guardrails, layered security controls, and human oversight. Through beginner-friendly examples, you'll explore the differences between safety and security, understand how input screening and output moderation work, and learn how Claude Code permissions, hooks, sandboxes, and human approvals help prevent unsafe actions.

Topics Covered:

• Understanding the importance of safety in Claude-based applications

• Differentiating between application security and AI safety

• Exploring how security protects applications against malicious actors and external threats

• Understanding how safety focuses on keeping Claude's responses and actions appropriate

• Recognizing why safety controls are necessary even when no attacker is involved

• Understanding Claude's built-in safety capabilities and the need for additional application-level protections

• Introducing guardrails as additional checks around model inputs and outputs

• Exploring input screening to identify potentially harmful or risky requests

• Understanding how a lightweight model such as Haiku can perform preliminary harmlessness checks

• Introducing output filtering and moderation before responses are delivered to users

• Exploring a layered safety pipeline involving input screening, Claude processing, and output moderation

• Understanding defense in depth and why multiple protective layers are more reliable than a single control

• Introducing the Claude Code enforcement ladder: CLAUDE.md, Permissions, Hooks, and Sandboxing

• Understanding how CLAUDE.md provides behavioral guidance without guaranteeing enforcement

• Exploring Claude Code permissions and how they restrict or require approval for specific tool operations

• Recognizing the limitations of permission rules and the importance of additional safeguards

• Understanding how hooks can inspect actions and enforce restrictions before execution

• Exploring sandboxes as operating system-level boundaries for containing potentially unsafe operations

• Introducing Human-in-the-Loop (HITL) approval for sensitive or high-risk actions

• Understanding how manual approval helps prevent unauthorized or unintended tool execution

• Recognizing the risks associated with bypassing permission checks using --dangerously-skip-permissions

• Understanding why secure AI applications combine model safety, guardrails, permissions, hooks, sandboxing, and human oversight

By the End of This Lecture, You Will Be Able To:

• Explain the difference between AI safety and application security

• Identify situations where safety risks can arise without malicious user intent

• Understand the role of Claude's built-in safety behavior

• Define guardrails and explain their importance in AI application development

• Differentiate between input screening and output moderation

• Explain how lightweight models can support cost-effective input screening

• Understand how output filtering helps prevent inappropriate responses from reaching users

• Describe the concept of defense in depth

• Explain why a single security or safety control is insufficient

• Identify the different layers of the Claude Code enforcement ladder

• Differentiate between advisory instructions and enforceable restrictions

• Explain why CLAUDE.md instructions cannot replace technical security controls

• Understand how Claude Code permissions influence tool execution

• Recognize the role of hooks in enforcing action-level restrictions

• Explain how sandboxing provides additional execution isolation

• Identify situations where human approval is appropriate before performing sensitive actions

• Understand the risks of bypassing permission checks

• Recognize how human oversight complements automated safety controls

• Design a layered safety approach using guardrails, permissions, hooks, sandboxes, and human review

• Apply safety, defense-in-depth, and Human-in-the-Loop concepts to practical Claude application development scenarios and certification exam questions

This lecture is part of Domain 7: Security and Safety of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of AI safety, guardrails, input screening, output moderation, defense in depth, Claude Code permissions, hooks, sandboxing, and Human-in-the-Loop approval for building secure and responsible Claude-based applications.

Reduce repeated learning objectivesAdd a concise lecture takeaway

In this hands-on lab, you'll learn how to protect Claude-based applications against prompt injection, jailbreak attempts, sensitive data leakage, and unauthorized access. Through practical demonstrations using the BazaarDesk customer support project, you'll explore how attackers can manipulate external content, why prompt-based instructions alone are insufficient for security, and how application-level controls help protect customer information and sensitive operations.

Topics Covered:

• Introducing the BazaarDesk project, a customer support assistant for Asha's Bazaar online store

• Exploring the application's order lookup, refund processing, and customer support capabilities

• Understanding the project structure, including customer records, orders, support tickets, invoices, and policy documents

• Resetting the project dataset and preparing the development environment

• Identifying common security risks in Claude-based applications that interact with external data and tools

• Introducing prompt injection through malicious instructions hidden inside uploaded documents

• Comparing clean invoices with poisoned invoices containing unauthorized refund instructions

• Exploring an injection attempt that tries to trigger an ₹18,000 refund without the customer's request

• Understanding why information inside an uploaded invoice must be treated as untrusted data

• Applying content fencing and labeling to separate external information from trusted application instructions

• Recognizing why prompt-based protections reduce risk but cannot guarantee complete security

• Introducing the principle of least privilege by restricting access to unnecessary or dangerous tools

• Understanding why removing access to a refund tool provides stronger protection than relying only on instructions

• Exploring jailbreak attempts involving role-playing, translation, summarization, and impersonation of developer authority

• Understanding how canary strings can be used to detect sensitive information leakage during security testing

• Comparing jailbreak outcomes across multiple attempts and different application configurations

• Recognizing why confidential credentials and secrets should not be embedded in model prompts

• Introducing Personally Identifiable Information (PII) and the importance of protecting customer data

• Exploring application-level masking for email addresses, phone numbers, payment information, and identification numbers

• Understanding why sensitive information should be redacted before constructing Claude API requests

• Comparing unprotected logging with approaches that prevent sensitive values from appearing in application logs

• Introducing authentication and authorization for customer-specific operations

• Exploring impersonation attempts where users claim to be another customer or a shop administrator

• Understanding why identity verification must rely on authenticated application sessions rather than model interpretation

• Enforcing order ownership restrictions and preventing unauthorized access to other customers' information

• Understanding why refund operations require application-level checks against authorized orders and transaction amounts

By the End of This Lecture, You Will Be Able To:

• Explain the purpose and structure of the BazaarDesk customer support project

• Identify common security vulnerabilities in AI-powered customer support applications

• Define prompt injection and recognize malicious instructions embedded in external documents

• Differentiate between legitimate customer requests and unauthorized instructions hidden in uploaded invoices

• Apply content fencing and labeling to separate untrusted data from application instructions

• Explain why prompt instructions alone cannot guarantee protection against prompt injection

• Understand the principle of least privilege when granting tools to Claude

• Recognize how restricting unnecessary tool access reduces the risk of unauthorized actions

• Identify common jailbreak techniques involving role-playing and authority impersonation

• Understand how canary strings support controlled data leakage testing

• Interpret jailbreak test results across repeated attempts

• Explain why confidential secrets should be stored outside model prompts

• Identify sensitive customer information that requires protection

• Apply data masking and redaction before sending information to Claude

• Recognize how application logs can unintentionally expose sensitive information

• Understand the importance of testing data masking against expected results

• Differentiate between authentication and authorization

• Explain why user identity must be established through trusted login mechanisms

• Recognize impersonation attempts involving customer and administrator identities

• Restrict order lookup operations to authenticated and authorized customers

• Understand how application-level checks prevent unauthorized refunds and data access

• Apply prompt injection defenses, least-privilege principles, PII protection, and authorization controls to practical Claude application security scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with prompt injection mitigation, jailbreak testing, confidential data protection, PII masking, least-privilege tool access, authentication, authorization, and application-level security enforcement covered in Domain 7: Security and Safety.

In this hands-on lab, you'll learn how to implement layered guardrails, business-specific content policies, and least-privilege access controls in Claude-based applications. Through practical demonstrations using the BazaarDesk customer support project, you'll explore defense in depth, policy enforcement, role-based tool permissions, and human approval workflows to build safer and more secure AI applications.

Topics Covered:

• Understanding the importance of guardrails and responsible deployment in Claude-based applications

• Resetting the BazaarDesk project dataset to prepare a clean environment for security experiments

• Introducing defense in depth and why multiple security layers provide stronger protection than a single control

• Exploring a three-layer guardrail architecture: Input Screening, Claude-Based Review, and Output Validation

• Understanding how different guardrail layers detect different types of unsafe or unauthorized requests

• Evaluating guardrail performance using ten sample requests, including three ordinary requests and seven attack scenarios

• Analyzing how malicious requests can be blocked at different stages of the processing pipeline

• Understanding why individual guardrails may have blind spots and how layered checks reduce overall risk

• Introducing business-specific content policies and their role in responsible AI application behavior

• Differentiating between Anthropic's built-in safety policies and application-specific business rules

• Exploring a policy.md file containing BazaarDesk's customer support requirements

• Understanding policies involving discounts, receipt verification, refund limits, and human escalation

• Exploring how refund requests above ₹5,000 require human review

• Understanding how potentially dangerous product complaints should be escalated appropriately

• Comparing application decisions with and without business-specific policy instructions

• Analyzing an evaluation where policy compliance improves from 21 out of 27 to 27 out of 27 decisions

• Introducing the principle of least privilege for Claude-based tools and application users

• Exploring role-based tool access for guests, customers, and agents

• Comparing permissions for order lookup, refund processing, and customer data export

• Understanding why users and agents should receive only the tools necessary for their responsibilities

• Exploring why tool access must be checked both when tools are exposed to Claude and when they execute

• Introducing Human-in-the-Loop approval for sensitive or high-value operations

• Understanding how authorization checks and human oversight reduce the risk of unsafe actions

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of guardrails in Claude-based applications

• Define defense in depth and understand why multiple protective layers are necessary

• Differentiate between input screening, model-based safety checks, and output validation

• Understand how layered guardrails reduce the likelihood of unsafe requests reaching users or application tools

• Interpret evaluation results showing which guardrail layer blocked a particular request

• Recognize the limitations of relying on a single security control

• Differentiate between Anthropic's built-in safety policies and application-specific business requirements

• Explain why Claude applications need clearly documented business policies

• Understand how a policy.md file can define application-specific rules

• Identify customer support scenarios requiring policy checks or human escalation

• Recognize why high-value refunds should require additional authorization

• Compare application behavior before and after introducing business-specific policy instructions

• Evaluate policy effectiveness using measurable test results

• Define the principle of least privilege in AI application development

• Differentiate between tool permissions assigned to guests, customers, and support agents

• Understand how role-based access limits unnecessary tool exposure

• Explain why authorization must be enforced when a tool executes

• Recognize why model instructions alone cannot guarantee secure tool access

• Identify sensitive actions that should require Human-in-the-Loop approval

• Apply layered guardrails, business policies, role-based permissions, and human oversight to practical Claude application security scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with layered guardrails, defense in depth, business-specific content policies, least-privilege access, role-based tool permissions, execution-time authorization, and Human-in-the-Loop approval covered in Domain 7: Security and Safety.

Reduce repetitive learning outcomesGroup topics into clear sections

In this hands-on lab, you'll learn how to protect sensitive credentials, enforce identity and access controls, and prevent dangerous operations using Claude Code hooks. Through practical demonstrations using the BazaarDesk customer support project, you'll explore secret scanning, secure credential storage, key rotation, role-based access control, audit logging, and PreToolUse hooks that enforce security restrictions before tools execute.

Topics Covered:

• Understanding the importance of secrets management, identity verification, and tool execution controls in Claude-based applications

• Resetting the BazaarDesk project dataset to prepare a clean environment for security demonstrations

• Introducing the risks associated with exposed API keys, access tokens, and application credentials

• Exploring a deliberately insecure application containing hardcoded and leaked secrets

• Identifying exposed Anthropic API keys, AWS access keys, and bearer tokens in application files

• Understanding how secret scanning helps locate credentials accidentally stored in source code and logs

• Exploring the role of .env files and .gitignore in protecting local development credentials

• Understanding why API keys and access tokens should not be hardcoded into application source code

• Comparing secure credential storage approaches for development and production environments

• Introducing secret managers for protecting production application credentials

• Understanding credential rotation and why compromised keys should be revoked promptly

• Exploring authentication and authorization through a customer support application

• Introducing role-based access control for viewers, support agents, and managers

• Understanding how different user roles receive different permissions

• Exploring a sample access hierarchy involving Sana as a viewer, Asha as an agent, and Ravi as a manager

• Understanding why authentication tokens should be securely represented and validated rather than exposed

• Comparing authorized and unauthorized operations involving order lookup and refund processing

• Introducing audit logs for recording permitted and denied application actions

• Understanding why sensitive actions may require additional approval or higher authorization levels

• Introducing Claude Code hooks as executable controls around tool operations

• Exploring the PreToolUse hook and how it evaluates tool requests before execution

• Understanding how hook configuration is defined in .claude/settings.json

• Exploring how hooks inspect tool call information through JSON input

• Understanding hook exit codes, including 0 for successful execution and 2 for blocking an operation

• Comparing allowed operations with blocked actions, such as unauthorized audit log modifications

• Understanding why executable hooks provide stronger enforcement than advisory instructions alone

By the End of This Lecture, You Will Be Able To:

• Explain the importance of protecting API keys, tokens, and other application secrets

• Identify common locations where credentials may be accidentally exposed

• Understand how secret scanning helps detect sensitive information in source code and logs

• Explain why credentials should not be stored directly in application code

• Recognize the purpose of .env files and .gitignore in development environments

• Differentiate between local environment variables and production secret management solutions

• Understand when compromised API keys should be revoked and rotated

• Explain the differences between authentication, authorization, and auditing

• Identify user roles and their associated access permissions

• Understand how role-based access control restricts unauthorized operations

• Recognize why viewers should not have the same privileges as support agents or managers

• Explain how authenticated identities and access levels influence tool execution

• Understand the importance of protecting authentication tokens

• Interpret audit logs containing successful and denied operations

• Recognize when high-risk actions require additional authorization or human approval

• Define Claude Code hooks and explain their purpose

• Understand how PreToolUse hooks inspect actions before tools execute

• Locate hook configuration in .claude/settings.json

• Explain how hook scripts use JSON input to evaluate proposed tool operations

• Differentiate between hook execution results that allow or block an action

• Understand how hooks can prevent destructive commands and unauthorized modifications

• Explain why fail-closed behavior and audit logging strengthen security controls

• Differentiate between prompt-based guidance and executable security enforcement

• Apply secrets management, access control, audit logging, and Claude Code hook concepts to practical application security scenarios

This hands-on lab is part of the Claude Certified Developer Foundations Exam Guide course and provides practical experience with secret scanning, secure credential storage, key rotation, authentication, role-based authorization, audit logging, Claude Code PreToolUse hooks, and enforceable tool execution controls covered in Domain 7: Security and Safety.

Shorten the learning outcomesRemove repeated learning points

In this lecture, you'll learn how tool use enables Claude to interact with external systems, retrieve information, and perform actions beyond generating text. Through beginner-friendly examples, you'll explore tool definitions, the tool execution loop, parallel tool calls, and the differences between built-in and custom tools.

Topics Covered:

• Understanding the purpose of tool use in Claude-based applications

• Exploring how tools extend Claude's capabilities beyond text generation

• Introducing practical tool use scenarios such as order lookup, weather checking, and database queries

• Understanding the separation between Claude requesting an action and application code executing it

• Introducing tool definitions and their role in making capabilities available to Claude

• Exploring the three main components of a tool definition: Name, Description, and Input Schema

• Understanding how tool descriptions help Claude determine when a tool should or should not be used

• Exploring JSON Schema for defining tool input parameters and their data types

• Understanding the get_weather tool example with a city parameter

• Introducing the tool use loop and its four main stages

• Exploring how Claude generates a tool use request with the required arguments

• Understanding how application code receives and executes a requested tool operation

• Exploring how tool execution results are returned to Claude

• Understanding how Claude uses tool results to generate a final response

• Recognizing how the tool use loop can repeat when additional information or actions are required

• Introducing parallel tool use for executing multiple independent operations

• Exploring parallel calls involving weather information, calendar events, and stock prices

• Understanding how parallel execution can reduce overall application latency

• Differentiating between independent tool calls and dependent operations that require sequential execution

• Comparing Anthropic-provided built-in tools with application-specific custom tools

• Exploring built-in capabilities such as web search and code execution

• Understanding how custom tools connect Claude to internal databases and application APIs

• Recognizing the differences in execution responsibilities between built-in and developer-managed tools

By the End of This Lecture, You Will Be Able To:

• Explain what a tool is and why tool use is important in Claude-based applications

• Identify common scenarios where Claude requires external tools

• Differentiate between generating a response and requesting an external action

• Define a tool using its name, description, and input schema

• Explain why clear tool descriptions improve tool selection

• Understand how JSON Schema defines the required inputs for a tool

• Recognize how Claude decides whether a particular tool is appropriate for a task

• Describe the complete tool use loop from request generation to final response

• Explain the responsibilities of Claude and application code during tool execution

• Understand how tool results are passed back into the conversation

• Recognize when Claude may need multiple tool calls to complete a request

• Define parallel tool use and explain its benefits

• Identify tool calls that can be executed independently

• Recognize when tool dependencies require sequential execution

• Explain how parallel tool execution can improve application performance

• Differentiate between built-in tools and custom tools

• Identify appropriate use cases for Anthropic-provided tools

• Understand when application-specific tools are required

• Explain how custom tools interact with external APIs and internal databases

• Recognize the importance of application-level control over tool execution

• Apply tool definitions, execution loops, parallel processing, and tool selection concepts to practical Claude application development scenarios

This lecture is part of Domain 8: Tools and MCP of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of Claude tool use, tool definitions, JSON input schemas, tool execution loops, parallel tool calls, built-in tools, and custom tool integration for developing tool-enabled Claude applications.

Reduce repeated learning outcomesAdd a brief lecture roadmap

In this lecture, you'll learn how the Model Context Protocol (MCP) provides a standardized way to connect Claude-based applications with external tools and data sources. Through beginner-friendly examples, you'll explore the integration challenges MCP solves, understand its host-client-server architecture, and learn how capability discovery, transport, and session management make tool integrations reusable across different AI applications.

Topics Covered:

• Understanding the challenges of connecting multiple AI applications to multiple external tools

• Exploring the traditional approach of building separate custom integrations for every application and tool combination

• Introducing the M × N integration problem and how integration complexity increases as applications and tools grow

• Understanding why custom integrations create maintenance, authentication, and data-handling challenges

• Introducing the Model Context Protocol (MCP) as an open standard for connecting AI applications with external capabilities

• Exploring the USB-C analogy to understand standardized AI tool connectivity

• Understanding how MCP reduces the need for application-specific tool integrations

• Comparing the traditional M × N integration approach with MCP's M + N connectivity model

• Introducing the three core roles in MCP architecture: Host, Client, and Server

• Understanding the MCP Host as the user-facing AI application

• Exploring MCP hosts such as Claude Desktop, Claude Code, and Cursor

• Understanding the MCP Client as the component responsible for communicating with an MCP server

• Exploring the relationship between MCP clients and servers

• Understanding the MCP Server as an independent program that exposes tools and data

• Recognizing how a single MCP host can connect to multiple servers through separate clients

• Introducing the MCP connection process: Connect, Discover, and Use

• Understanding capability discovery and how MCP servers advertise available functionality

• Exploring how standardized discovery allows compatible hosts to identify server capabilities

• Understanding how MCP builds upon the existing Claude tool use mechanism

• Comparing traditional tool use with MCP-based tool connectivity

• Introducing the three additional MCP capabilities: Discovery, Transport, and Session Management

• Understanding how MCP standardizes communication without replacing the underlying tool execution process

By the End of This Lecture, You Will Be Able To:

• Explain the integration challenges that MCP is designed to solve

• Define the M × N integration problem in AI application development

• Understand how standardized protocols reduce integration complexity

• Define the Model Context Protocol (MCP) and explain its purpose

• Describe MCP using the USB-C analogy for reusable connectivity

• Differentiate between traditional custom integrations and standardized MCP connections

• Explain how MCP supports reusable tool integrations across compatible applications

• Identify the three major components of MCP architecture

• Define the responsibilities of MCP Hosts, Clients, and Servers

• Recognize common AI applications that can act as MCP hosts

• Explain why an MCP host can maintain multiple client connections

• Understand how MCP servers expose tools and other capabilities

• Describe the MCP connection lifecycle from initialization to capability usage

• Explain the purpose of capability discovery

• Understand how MCP clients learn about available server functionality

• Differentiate between tool use and MCP-based tool connectivity

• Explain how the existing tool use loop operates within an MCP integration

• Understand the roles of discovery, transport, and session management in MCP

• Recognize why MCP complements rather than replaces Claude's tool use capabilities

• Identify scenarios where MCP provides advantages over individually developed tool integrations

• Apply MCP architecture, standardized connectivity, and capability discovery concepts to practical Claude application development and certification exam scenarios

This lecture is part of Domain 8: Tools and MCP of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of the Model Context Protocol, integration complexity, MCP Hosts, Clients and Servers, capability discovery, transport, session management, and the relationship between MCP and Claude tool use.

Shorten the topic listAdd a simple MCP exampleReduce repeated learning outcomes

In this lecture, you'll learn how MCP servers expose tools, resources, and prompts to Claude-based applications and how to select and connect MCP servers for practical use. Through beginner-friendly examples, you'll explore the three core MCP primitives, local and remote transports, reusable MCP integrations, and important security considerations when connecting external servers.

Topics Covered:

• Understanding the purpose of MCP servers in connecting Claude to external tools and information

• Introducing the three core MCP primitives: Tools, Resources, and Prompts

• Understanding how MCP servers advertise their available capabilities through capability discovery

• Exploring how a single MCP server can expose one or more types of capabilities

• Introducing MCP Tools as executable operations that perform actions

• Exploring tool examples such as executing database queries and sending emails

• Understanding MCP Resources as a way to expose data for applications to read

• Exploring resource examples such as reading files and retrieving stored records

• Introducing MCP Prompts as reusable templates for common tasks and workflows

• Differentiating between reading information, performing actions, and reusing predefined prompts

• Understanding how MCP provides capabilities beyond traditional document retrieval

• Introducing MCP transport mechanisms and how clients communicate with servers

• Exploring STDIO transport for connecting to locally running MCP servers

• Understanding how local MCP servers interact with applications such as Claude Desktop and Claude Code

• Introducing Streamable HTTP transport for connecting to remotely hosted MCP servers

• Comparing local STDIO connections with remote HTTP-based communication

• Understanding how MCP maintains standardized communication across different transport mechanisms

• Exploring the MCP ecosystem and available integrations for services such as GitHub, Google Drive, Slack, and databases

• Understanding how reusable MCP servers reduce the need for custom application-specific integrations

• Exploring the option to connect existing MCP servers or develop custom servers

• Recognizing the importance of reviewing MCP server permissions and trustworthiness

• Understanding how malicious tool descriptions and untrusted server content can introduce prompt injection risks

• Applying security and trust boundary principles when selecting MCP servers

By the End of This Lecture, You Will Be Able To:

• Explain the purpose of MCP servers in Claude-based applications

• Identify the three core MCP primitives: Tools, Resources, and Prompts

• Differentiate between executable tools, readable resources, and reusable prompt templates

• Recognize when to use an MCP Tool to perform an action

• Understand when MCP Resources are appropriate for accessing information

• Explain how MCP Prompts support reusable workflows

• Understand how MCP servers expose their capabilities to compatible clients

• Recognize that an MCP server can provide different combinations of tools, resources, and prompts

• Define STDIO transport and explain its role in local MCP connections

• Understand how Streamable HTTP enables communication with remotely hosted MCP servers

• Differentiate between local and remote MCP server deployments

• Explain how MCP transport mechanisms affect communication without changing the fundamental capabilities exposed by a server

• Identify common MCP integrations involving source control, cloud storage, messaging, and databases

• Explain how standardized MCP servers support reusable integrations across compatible applications

• Recognize when to use an existing MCP server instead of developing a custom integration

• Understand the basic considerations involved in building a custom MCP server

• Identify security risks associated with connecting untrusted MCP servers

• Recognize how malicious tool descriptions can introduce prompt injection threats

• Apply trust boundary and permission management principles when evaluating MCP integrations

• Select appropriate MCP primitives and transport mechanisms based on application requirements

• Apply MCP server architecture, transport selection, capability discovery, and security concepts to practical Claude application development and certification exam scenarios

This lecture is part of Domain 8: Tools and MCP of the Claude Certified Developer Foundations Exam Guide course and provides foundational knowledge of MCP server primitives, tools, resources, prompts, STDIO and Streamable HTTP transports, reusable MCP integrations, capability discovery, and secure MCP server selection.

Group the overlapping learning outcomesReduce the topics and outcomes