Claude Certified Architect: Foundations Exam Guide - 2026

In this lecture, you'll learn the core principles behind building reliable agentic loops in Claude-powered applications. Instead of hardcoding workflows, you'll discover how to let Claude decide the next action, maintain conversation history correctly, and use the stop_reason signal to determine when an agent should continue working or stop. These concepts are fundamental for designing autonomous AI agents that are efficient, predictable, and production-ready.

In this lecture, you will learn:

• What an agentic loop is and why it is essential for AI agents

• How to use stop_reason to control the execution loop correctly

• Why tool outputs must be fed back into the conversation history

• How Claude decides which tool to use next without fixed workflows

• Why you should avoid guessing when an agent should stop

• Best practices for building reliable, flexible, and autonomous agent workflows

In this lecture, you'll explore the Coordinator and Sub-Agent architecture, one of the most important design patterns for building scalable AI agent systems. You'll learn how a central coordinator delegates work to specialized sub-agents, maintains control over the workflow, and ensures that every task is completed efficiently without duplication or confusion. Through practical analogies and real-world examples, you'll understand how to design multi-agent systems that are organized, reliable, and easy to maintain.

In this lecture, you will learn:

• The roles and responsibilities of a coordinator and sub-agents

• Why all communication should flow through a central coordinator

• How to provide sub-agents with the right context for effective execution

• How coordinators select the most appropriate agents for each task

• Best practices for splitting work without overlaps or missing coverage

• How to identify gaps, refine results, and improve output through iterative coordination

In this lecture, you'll learn the best practices for spawning and managing sub-agents in Claude-based multi-agent systems. You'll discover how a coordinator creates specialized agents, provides them with the right context, defines clear responsibilities, and executes tasks efficiently. You'll also explore techniques for parallel execution, branching workflows, and goal-oriented delegation that help build scalable and high-performing AI architectures.

In this lecture, you will learn:

• How coordinators create and delegate work to sub-agents

• Why sub-agents require complete context before execution

• The importance of defining clear roles and responsibilities for each agent

• How to branch workflows to explore multiple solutions efficiently

• Why every generated result should include traceable sources

• How parallel execution improves performance and reduces execution time

• Why assigning goals instead of fixed steps leads to more intelligent agent behavior

In this lecture, you'll learn how to enforce reliable AI workflows by moving critical logic out of prompts and into code. You'll explore best practices for validating prerequisites, decomposing complex requests into parallel tasks, and handing off complete context between agents. These workflow enforcement principles help build AI systems that are secure, predictable, and maintainable in real-world production environments.

In this lecture, you will learn:

• Why critical workflow rules should be enforced in code instead of prompts

• How to block important actions until required prerequisites are satisfied

• Best practices for decomposing complex requests into independent parallel tasks

• How to design workflows that handle multiple related concerns efficiently

• Why complete context should always be passed during agent handoffs

• Techniques for building reliable, scalable, and production-ready AI workflows

In this lecture, you'll explore how hooks can be used to intercept requests, enforce business rules, and normalize data before it reaches your AI agent. You'll learn why preprocessing tool inputs and outputs leads to more reliable AI behavior, and how hooks provide deterministic control that prompts alone cannot guarantee. These techniques are essential for building secure, consistent, and production-ready AI workflows.

In this lecture, you will learn:

• How to normalize tool outputs before sending them to an AI model

• Why consistent data formatting improves AI accuracy and reliability

• How pre-tool hooks intercept and validate requests before execution

• When to block requests and when to redirect them to an alternative workflow

• Why hooks are more reliable than prompts for enforcing critical business rules

• Best practices for implementing validation, interception, and workflow enforcement using hooks

In this lecture, you'll learn how to break down complex tasks into smart, manageable subtasks using the right workflow strategy. You'll explore when to use fixed sequential workflows, when to adopt flexible planning, and how to structure reviews for better accuracy. These principles help AI agents solve both predictable and open-ended problems more efficiently while adapting to new information as it becomes available.

In this lecture, you will learn:

• How to choose the right workflow based on the type of task

• When to use fixed sequential execution versus adaptive planning

• Why known workflows should follow a clear step-by-step process

• How to perform per-file analysis before cross-file integration

• How adaptive workflows evolve as new information is discovered

• Best practices for decomposing large tasks into efficient and reliable subtasks

In this lecture, you'll learn how to manage AI sessions effectively by resuming previous work, branching into multiple strategies, and keeping context fresh. You'll explore techniques for naming sessions, forking workflows, tracking code changes, and knowing when to start a new session. These best practices help improve productivity, reduce redundant work, and ensure your AI agents always operate with the most relevant context.

In this lecture, you will learn:

• How to name and resume AI sessions efficiently

• Why forking sessions is useful for comparing multiple approaches

• How to inform agents about code or context changes when resuming work

• When to reuse an existing session versus starting a new one

• How fresh context improves the accuracy and reliability of AI responses

• Best practices for managing long-running AI workflows and development sessions

In this lecture, you'll set up the complete development environment required for building Claude AI agents in Python. You'll create a virtual environment, install the required dependencies, configure the Anthropic API, and explore the structure of a simple order support agent. You'll also understand how the agent interacts with tools, processes user requests, and uses the stop_reason field to determine whether to invoke a tool or generate a final response.

In this lecture, you will learn:

• How to set up a Python virtual environment for AI agent development

• How to install project dependencies using a requirements.txt file

• How to configure the Anthropic API key using a .env file

• The purpose of helper files, mock data, and reusable tools in an AI agent project

• How a single order support agent is structured and processes customer requests

• How the stop_reason field controls tool execution and agent responses

• The workflow of tool calling within a Claude-powered AI agent

• What to expect in the upcoming hands-on execution and anti-pattern demonstration lectures

In this lecture, you'll execute your first Claude-powered AI agent and observe how it responds to real customer queries. You'll learn how the agent uses the stop_reason field to decide whether to invoke tools or return a final response, and why relying on this mechanism is far more reliable than checking for arbitrary keywords. You'll also explore an anti-pattern implementation to understand common mistakes that should be avoided when building AI agents.

In this lecture, you will learn:

• How to run a Claude-powered AI agent from the command line

• How the order support agent processes customer requests step by step

• How the stop_reason field determines whether to use a tool or return a final answer

• How tool calls enable the agent to retrieve customer, order, and refund information

• Why providing complete user information affects the agent's workflow

• Why checking for random response text or keywords is an unreliable agent design pattern

• How an anti-pattern implementation can lead to incorrect or premature agent termination

• Best practices for building robust and predictable AI agent workflows using stop_reason

In this lecture, you'll enhance your AI agent architecture by introducing a coordinator agent that delegates work to specialized sub-agents. You'll explore how task spawning, explicit context passing, and parallel execution make multi-agent systems more organized, scalable, and efficient. You'll also compare this recommended approach with an anti-pattern implementation to understand why proper context management is essential for reliable AI agent workflows.

In this lecture, you will learn:

• How a coordinator agent delegates work to specialized sub-agents

• How task spawning improves the organization and consistency of AI workflows

• How explicit context passing enables sub-agents to share relevant information

• How parallel task execution improves the efficiency of multi-agent systems

• How a coordinator combines outputs from multiple sub-agents into a final response

• How to execute and test a multi-agent coordinator using sample customer support scenarios

• Why directly invoking sub-agents without proper task coordination is an anti-pattern

• Best practices for designing scalable and maintainable multi-agent architectures

In this lecture, you'll build a more advanced coordinator agent that can handle multiple user requests within a single conversation. You'll learn how the coordinator decomposes a complex request into individual concerns, identifies dependencies between them, executes independent tasks in parallel, and combines the results into a single, coherent response. You'll also compare this approach with an anti-pattern implementation that skips request decomposition.

In this lecture, you will learn:

• How a coordinator agent decomposes a complex user request into multiple concerns

• How to identify independent and dependent tasks within a single user message

• How independent concerns can be executed in parallel to improve efficiency

• How dependent concerns are executed sequentially with proper context passing

• How a coordinator combines results from multiple sub-agents into a unified response

• How to execute and test a multi-concern AI agent using real customer support scenarios

• Why sending an entire user request directly to a single sub-agent is an anti-pattern

• Best practices for designing AI agents that efficiently manage multiple user intents in a single conversation

In this lecture, you'll learn how to use pre-tool and post-tool hooks to add validation, control, and output processing to your AI agents. You'll explore how hooks automatically execute before and after tool calls, allowing you to enforce business rules, block invalid operations, escalate requests when necessary, and format tool outputs before they are returned to the user.

In this lecture, you will learn:

• What pre-tool and post-tool hooks are and why they are important in AI agent workflows

• How pre-tool hooks validate requests before a tool is executed

• How business rules can prevent tool execution and trigger escalation when required

• How refund requests can be automatically approved or escalated based on policy conditions

• How post-tool hooks clean, format, and standardize tool outputs before they reach the agent

• How to execute and test hook-based AI agents using real customer support scenarios

• How hooks improve the reliability, security, and consistency of AI agent behavior

• Best practices for implementing pre-processing and post-processing logic around tool execution

In this lecture, you'll explore dynamic adaptive planning, where an AI agent continuously updates its execution plan based on information discovered during each step. Instead of following a fixed workflow, the agent analyzes intermediate results, revises its strategy, and determines the next best action until the user's request is fully resolved.

In this lecture, you will learn:

• What dynamic adaptive planning is and when it should be used in AI agents

• How an AI agent creates an initial execution plan from a vague or incomplete user request

• How the agent revises its plan after each step based on newly discovered information

• How sequential tasks are executed when each step depends on the results of the previous one

• How the agent investigates customer orders, identifies issues, and applies relevant policies dynamically

• How dynamic planning enables agents to solve complex, multi-step customer requests

• How to execute and observe an adaptive planning agent in a real customer support scenario

• Best practices for designing AI agents that can reason, adapt, and refine their workflows as new information becomes available

In this lecture, you'll learn how AI agents manage conversations across multiple sessions. You'll explore how to create named sessions, resume previous conversations, fork existing sessions into new workflows, update session context with new information, and start fresh while preserving a concise summary. These techniques help build AI agents that maintain long-term context and support flexible conversation management.

In this lecture, you will learn:

• How to create and manage named sessions for AI agent conversations

• How session history is stored and reused across multiple interactions

• How to resume a previous session while preserving conversational context

• How to fork an existing session into a new branch without losing prior context

• How to update an active session by informing the agent of new changes

• How to start a fresh session using a summarized version of previous conversations

• How session files store conversation history and metadata

• Best practices for building AI agents with persistent memory and effective session management

In this lecture, you'll learn how to design robust error handling that enables AI agents to recover automatically and respond intelligently when things go wrong. You'll explore different error types, how to structure error responses, and when to retry, escalate, or inform the user. These practices are essential for building reliable, production-ready AI applications that can gracefully handle failures.

In this lecture, you will learn:

• Why tool failures should always be marked using the is Error flag

• How to classify and handle different types of errors effectively

• Why detailed error messages improve automatic agent recovery

• How to communicate errors clearly to end users in plain language

• When to retry locally and when to escalate unresolved issues

• The difference between an empty result and a genuine system failure

• Best practices for building resilient AI workflows with structured error handling

In this lecture, you'll learn how Claude selects the right tool and why well-designed tool descriptions are essential for accurate tool selection. You'll explore how clear naming, detailed descriptions, and proper tool separation help Claude make reliable decisions. You'll also discover how system prompts can influence tool selection and how to avoid common design mistakes that lead to incorrect tool usage.

In this lecture, you will learn:

• How Claude uses tool descriptions to select the appropriate tool

• What information should be included in an effective tool description

• Why overlapping tool responsibilities lead to incorrect tool selection

• How to split generic tools into specialized, single-purpose tools

• How system prompts can influence or override tool selection behavior

• Best practices for designing clear, reliable, and production-ready tool definitions

In this lecture, you'll learn how to assign the right tools to the right AI agents for maximum efficiency and accuracy. You'll explore best practices for limiting toolsets, defining clear agent responsibilities, controlling tool access, and using Claude's tool_choice modes effectively. These design principles help reduce confusion, improve tool selection, and create secure, production-ready agent workflows.

In this lecture, you will learn:

• Why limiting the number of tools improves tool selection accuracy

• How to assign tools based on an agent's specific responsibilities

• When to share tools across agents and when to keep them isolated

• How to restrict tool capabilities for better security and control

• The differences between tool_choice modes: auto, any, and tool

• How to force critical tools to execute before other workflow steps

• Best practices for designing focused, reliable, and efficient AI agents

In this lecture, you'll learn how to configure and manage MCP (Model Context Protocol) servers in Claude Code for both personal and team environments. You'll explore where MCP configurations should be stored, how to securely manage secrets, and how Claude discovers and prioritizes MCP tools. You'll also learn best practices for deciding when to use existing MCP servers versus building custom ones for your own workflows.

In this lecture, you will learn:

• The difference between project-level (.mcp.json) and user-level (claude.json) MCP configurations

• How to securely manage API keys and secrets using environment variables

• How Claude discovers MCP servers and loads their available tools at startup

• Why clear tool descriptions improve MCP tool selection over built-in tools

• When to use existing MCP servers versus creating custom MCP servers

• How MCP resources help Claude discover available data and reduce unnecessary tool calls

• Best practices for organizing, securing, and maintaining MCP server configurations

In this lecture, you'll explore the built-in tools available in Claude Code and learn how to use them efficiently for searching, reading, editing, and navigating codebases. You'll understand the purpose of each built-in tool, when to use it, and how combining these tools helps you analyze and modify projects with greater speed and accuracy.

In this lecture, you will learn:

• How to use Grep to search for text and patterns inside files

• How Glob helps locate files based on filenames and file patterns

• The differences between the Read, Write, and Edit tools and when to use each one

• Why combining Read + Write is sometimes safer than using Edit alone

• How to explore large codebases incrementally instead of scanning everything at once

• How to trace function calls through wrappers to understand complete execution flows

• Best practices for using Claude Code's built-in tools efficiently during software development

In this lecture, you'll explore why tool descriptions play a critical role in Model Context Protocol (MCP) applications. You'll learn how clear, well-defined tool descriptions help AI models select the correct tool for a given task, while vague or overlapping descriptions can lead to incorrect tool selection. You'll also compare a well-designed implementation with an anti-pattern to understand the importance of effective tool documentation.

In this lecture, you will learn:

• Why tool descriptions are essential for accurate tool selection in MCP-based AI agents

• How AI models use tool descriptions to determine which tool to invoke

• The characteristics of a well-written tool description, including purpose, inputs, and usage

• Why vague or overlapping tool descriptions can result in incorrect tool selection

• How to define tool schemas with clear names, descriptions, and input parameters

• How to execute and test MCP tools using real document search scenarios

• How poorly described tools lead to unpredictable behavior in an anti-pattern implementation

• Best practices for designing descriptive, unambiguous tools that improve AI agent reliability and accuracy

In this lecture, you'll learn how to implement structured error responses in AI agents instead of relying on generic error messages. You'll explore how structured error objects provide detailed information about validation, permission, and execution failures, making debugging, monitoring, and error handling significantly more reliable. You'll also compare this approach with an anti-pattern that returns vague, unhelpful error messages.

In this lecture, you will learn:

• Why structured error responses are preferable to generic error messages in AI agents

• How to use an is_error flag to distinguish successful responses from failures

• How to categorize errors such as validation, permission, and execution failures

• How structured error responses improve debugging and troubleshooting

• How to implement descriptive error handling within MCP tools

• How to execute and test structured error scenarios using document access examples

• Why generic "operation failed" responses are considered an anti-pattern

• Best practices for designing consistent, informative, and machine-readable error responses for AI agent workflows

In this lecture, you'll learn how to control tool selection in MCP-based AI agents using tool choice. You'll explore the different tool choice modes—auto, any, and forced tool selection—and understand when each should be used. You'll also compare a well-scoped implementation with an anti-pattern that exposes too many tools without proper selection logic.

In this lecture, you will learn:

• What tool choice is and how it influences tool selection in AI agents

• The differences between auto, any, and forced tool selection modes

• When to force the model to invoke a specific tool for predictable behavior

• When allowing the model to choose any appropriate tool is beneficial

• How automatic tool selection enables the model to answer directly when no tool is required

• How to configure and test different tool choice strategies in an MCP-based agent

• Why exposing too many tools without proper scoping is an anti-pattern

• Best practices for designing reliable and efficient AI agents with controlled tool invocation

In this lecture, you'll learn how to integrate external MCP servers into your AI agent applications. You'll understand the purpose of MCP servers, how to configure them using project-level and user-level configuration files, and how to securely manage environment-specific settings. You'll also explore the role of the FastMCP library and learn the differences between shared team configurations and local user configurations.

In this lecture, you will learn:

• What an MCP server is and how it extends the capabilities of AI agents

• How to configure MCP servers using the project-level .mcp.json file

• How to configure user-specific MCP servers using the home directory .claude.json file

• The differences between repository-level and user-level MCP server configurations

• How to build and expose MCP tools using the FastMCP library

• How to securely manage API keys and other sensitive settings using environment variables

• Why .env files should not be committed to source control and how .gitignore helps protect secrets

• Best practices for integrating, configuring, and sharing MCP servers across individual and team development environments

In this lecture, you'll explore several built-in tools commonly used in AI agent workflows for interacting with files and source code. You'll learn how to locate files, search file contents, read and modify files, and create new files using practical Python examples. These tools form the foundation for building AI agents that can inspect, analyze, and update codebases efficiently.

In this lecture, you will learn:

• How the Glob tool locates files based on filename patterns and extensions

• How the Grep tool searches for specific text or patterns within files

• How the Read tool opens and retrieves the contents of a file

• How the Write tool creates new files or replaces existing file contents

• How the Edit tool modifies only selected portions of an existing file

• How to implement these file operation tools within an AI agent using Python

• When to use each built-in tool for different file management and code analysis tasks

• Best practices for integrating file system tools into AI-powered agent workflows

In this lecture, you'll learn how to configure and organize CLAUDE.md files to provide persistent instructions and memory for Claude Code. You'll explore the different scopes of CLAUDE.md, understand how instruction hierarchy works, and discover best practices for organizing, sharing, and debugging your project instructions. These techniques help keep AI behavior consistent across users, projects, and directories while making large codebases easier to manage.

In this lecture, you will learn:

• The three scopes of CLAUDE.md: User, Project, and Directory

• Which instructions belong in personal versus shared project configurations

• How instruction hierarchy affects Claude's behavior across different scopes

• How to reuse rules with imports instead of duplicating instructions

• Why large CLAUDE.md files should be split into modular rule files

• How the /memory command helps inspect which instruction files are currently loaded

• Best practices for organizing and maintaining CLAUDE.md in production projects

In this lecture, you'll learn how to create and manage custom commands and skills in Claude Code to automate repetitive tasks and standardize development workflows. You'll explore where personal and team commands should be stored, how to define skills using front matter, and how to control tool access for secure execution. You'll also learn when to use CLAUDE.md versus skills to keep your projects organized and maintainable.

In this lecture, you will learn:

• The difference between personal and team custom commands in Claude Code

• How skill front matter defines context, allowed tools, and required inputs

• Why noisy or long-running tasks should be isolated using skills

• How to restrict tool access for safer and more controlled skill execution

• The importance of argument hints for creating user-friendly skills

• When to keep custom skills personal versus sharing them with your team

• How to decide between using CLAUDE.md and skills for different types of workflows

• Best practices for organizing reusable commands and scalable automation in Claude Code

In this lecture, you'll learn how to apply path-specific rules in Claude Code using conditional CLAUDE.md loading. You'll discover how to configure rules that are activated only for specific files or file types, helping keep Claude's context focused and relevant. You'll also explore the use of glob patterns to simplify rule management across large projects while avoiding unnecessary duplication.

In this lecture, you will learn:

• How to create path-specific rules that load only when needed

• Why conditional rule loading keeps Claude's context smaller and more focused

• How to match rules based on file types instead of folder locations

• How glob patterns simplify rule management across an entire project

• Why reusable path-based rules are better than duplicating CLAUDE.md files

• Best practices for organizing scalable, maintainable, and context-aware project rules

In this lecture, you'll learn when to use Plan Mode versus Direct Execution in Claude Code. You'll discover how planning helps with complex, multi-file changes, while direct execution is ideal for simple and well-defined tasks. You'll also explore how exploration mode, planning, and execution work together to reduce risk, avoid unnecessary rework, and improve productivity when working with large codebases.

In this lecture, you will learn:

• When to use Plan Mode for complex architectural and multi-file changes

• Why simple, straightforward tasks should be executed directly

• How planning helps prevent costly mistakes and unnecessary rework

• How Explorer mode analyzes large codebases without cluttering the main conversation

• The differences between planning, exploring, and direct execution

• How to combine planning and execution for safe, efficient software development workflows

• Best practices for choosing the right execution strategy based on task complexity

In this lecture, you'll learn how to iteratively refine AI-generated code and prompts to achieve more accurate and reliable results. You'll discover why concrete examples outperform vague instructions, how test-driven iteration improves code quality, and when to let Claude ask clarifying questions before building a solution. These techniques help you collaborate with Claude more effectively and produce better outcomes with every iteration.

In this lecture, you will learn:

• Why concrete input/output examples produce better results than vague instructions

• How test-driven iteration helps refine code one issue at a time

• When to let Claude ask clarifying questions before implementing a solution

• How detailed examples make debugging and problem-solving faster

• When to bundle related changes together versus handling independent fixes separately

• Best practices for iterative refinement and improving AI-assisted software development workflows

In this lecture, you'll learn how to integrate Claude Code into CI/CD pipelines for automated code reviews, test generation, and quality checks. You'll explore how to run Claude in non-interactive mode, generate structured JSON outputs, apply team standards using CLAUDE.md, and build reliable review workflows that avoid duplicate feedback. These practices help automate software delivery while keeping AI-driven reviews consistent and efficient.

In this lecture, you will learn:

• How to run Claude Code in non-interactive mode using the -p option for CI/CD automation

• Why structured JSON output is better than natural language for automated pipelines

• How CLAUDE.md enables Claude to follow team coding standards during CI execution

• Why separate Claude sessions produce more effective and unbiased code reviews

• How to avoid repeating the same review findings across multiple CI runs

• How existing test suites help Claude generate only the missing test cases

• Best practices for integrating Claude Code into modern CI/CD workflows

In this lecture, you'll set up Claude Code on your local machine and learn how to use it to analyze an existing Python project. You'll install the Claude CLI, authenticate your account, explore the basic workflow, and see how Claude Code can quickly understand a codebase, answer project-related questions, and identify key files without requiring you to manually inspect the source code.

In this lecture, you will learn:

• How to install and configure Claude Code on your local development machine

• How to authenticate using a Claude subscription or other supported login methods

• How to launch and use Claude Code from the command line and Visual Studio Code

• How to explore a sample Trip Planner CLI application using Claude Code

• How to execute and test a simple Python CLI application before analyzing it

• How to ask Claude Code questions about an unfamiliar codebase and receive contextual answers

• How Claude Code identifies important project files and explains their responsibilities

• Best practices for getting started with Claude Code to understand, navigate, and analyze software projects efficiently

In this lecture, you'll learn how Claude Code uses CLAUDE.md files to define coding rules, project memory, and development conventions. You'll explore the different scopes of CLAUDE.md files, understand how rule inheritance and imports work, and see how Claude Code automatically applies these instructions while analyzing and assisting with your codebase.

In this lecture, you will learn:

• What CLAUDE.md files are and how they provide rules and memory for Claude Code

• The differences between user-level, project-level, and folder-level CLAUDE.md files

• How rule precedence and inheritance work across different CLAUDE.md scopes

• How to reuse common rules by importing Markdown files into a project-level CLAUDE.md

• How to define path-specific rules for selected files and directories

• How to inspect the active memory and loaded CLAUDE.md files using Claude Code

• How to ask Claude Code questions about project rules, coding standards, and folder-specific conventions

• Best practices for organizing, sharing, and maintaining reusable coding standards and project memory with CLAUDE.md files

In this lecture, you'll learn how to design precise and reliable prompts that consistently produce high-quality results from Claude. You'll explore techniques for reducing false positives, eliminating ambiguity, and making prompt behavior more predictable through specific instructions, clear categories, concrete examples, and focused review criteria. These prompt engineering principles are essential for building dependable AI workflows and improving code review accuracy.

In this lecture, you will learn:

• Why specific instructions consistently outperform vague prompts

• How predefined categories reduce ambiguity and improve prompt reliability

• Why excessive false positives reduce trust in AI-generated results

• How defining what to report and what to ignore improves output quality

• Why focusing on fewer high-priority checks often produces better results

• How concrete examples create consistent severity classifications and decisions

• Best practices for designing prompts that deliver predictable, accurate, and repeatable outputs

In this lecture, you'll learn how to teach Claude through examples instead of relying solely on instructions. You'll discover why high-quality examples lead to more consistent outputs, reduce hallucinations, improve reasoning, and help Claude recognize patterns instead of memorizing isolated cases. These prompt engineering techniques are essential for building reliable AI applications and achieving predictable results across a wide variety of tasks.

In this lecture, you will learn:

• Why examples consistently outperform text-only instructions

• How examples help Claude resolve ambiguous and confusing scenarios

• Why teaching patterns is more effective than teaching individual cases

• How examples reduce hallucinations and encourage accurate responses

• How to distinguish acceptable behavior from genuine issues using examples

• Why exposing Claude to multiple document formats improves generalization

• Why 2–4 well-designed examples are the ideal balance for prompt engineering

• How to demonstrate the exact output format for consistent and structured responses

In this lecture, you'll learn how to enforce structured and reliable outputs from Claude using tool use and JSON schemas. You'll discover why tool-based structured output is more dependable than prompt-only instructions, how to select the appropriate tool execution mode, and how to design schemas that produce accurate, validated, and production-ready data. These techniques are essential for building robust AI pipelines and integrating Claude into real-world applications.

In this lecture, you will learn:

• Why tool use provides more reliable structured output than prompting for JSON

• How to choose between auto, any, and forced tool execution modes

• When to use multiple extraction schemas versus a specific tool in AI pipelines

• Why a valid JSON structure does not always guarantee correct business data

• How to design optional and nullable fields to prevent fabricated information

• Why adding Other and Unclear categories improves classification accuracy

• How to normalize inconsistent source data into clean, standardized outputs

• Best practices for building production-ready AI workflows with structured outputs and JSON schemas

In this lecture, you'll learn how to build self-correcting extraction pipelines that automatically detect, validate, and recover from errors. You'll explore techniques for providing meaningful retry feedback, distinguishing between syntax and semantic validation, recognizing when retries are useful, and knowing when to stop retrying altogether. These strategies help create robust AI systems that continuously improve output quality while minimizing hallucinations and unnecessary API calls.

In this lecture, you will learn:

• How to provide specific validation feedback that enables Claude to self-correct

• Why retries cannot recover information missing from the original source

• How tracking recurring error patterns improves future prompt design

• The difference between syntax validation and semantic validation

• How to build an effective self-correction loop using the original input, failed output, and validation errors

• When to retry an extraction and when to stop to avoid wasted API calls

• How dismissed findings help identify noisy prompts and improve accuracy

• How to design outputs that validate themselves by detecting internal inconsistencies

In this lecture, you'll learn how to design efficient batch processing strategies for large-scale AI workloads. You'll discover when to use Batch APIs instead of synchronous APIs, how to reduce costs, meet service-level agreements (SLAs), and optimize batch execution for production environments. You'll also explore best practices for tracking requests, handling failures, and validating prompts before processing thousands of documents.

In this lecture, you will learn:

• When to choose Batch API versus Synchronous API based on workload requirements

• How batch processing reduces costs for latency-tolerant workloads

• The limitations of Batch APIs and when they should not be used

• Why every batch request should include a unique custom ID for tracking responses

• How to align API selection with business SLAs and workflow requirements

• Why only failed batch requests should be resubmitted instead of rerunning the entire batch

• How testing prompts on a small sample improves large-scale batch success rates

• Best practices for building reliable, cost-effective, and scalable batch processing pipelines

In this lecture, you'll learn how to design an effective AI review architecture that catches more bugs, reduces bias, and improves code quality. You'll discover why the same Claude session should not review its own generated code, how fresh review sessions identify hidden issues, and why breaking reviews into focused passes produces more reliable results. These review strategies are essential for building trustworthy AI-assisted development workflows.

In this lecture, you will learn:

• Why code generators should not review their own output

• How fresh Claude sessions identify subtle bugs and hidden issues

• Why reviewing one concern at a time produces higher-quality results

• How per-file reviews differ from cross-file integration reviews

• Why separating code generation and code review improves reliability

• How confidence scores help prioritize findings for automated fixes or human review

• Best practices for building scalable and unbiased AI-powered code review workflows

In this lecture, you'll learn how to manage long conversations effectively in Claude by preserving important context while minimizing unnecessary information. You'll explore techniques for retaining critical facts, structuring multi-topic conversations, reducing context window usage, and ensuring important details are never lost. These strategies help build scalable AI applications that remain accurate and consistent even during lengthy interactions.

In this lecture, you will learn:

• Why preserving key facts is more effective than relying on high-level summaries

• How important information can get lost in the middle of long conversations

• How to reduce context window usage by trimming tool outputs at the source

• Why every Claude API call must include the required conversation history

• How combining structured facts with concise summaries improves context retention

• How to organize multiple issues into separate structured sections for better reasoning

• Why headings and structured documents improve Claude's attention to critical information

• How sub-agents should return structured findings with supporting evidence for reliable downstream processing

In this lecture, you'll learn how to design reliable escalation and ambiguity resolution workflows for AI agents. You'll explore when an agent should resolve an issue independently, when it should ask for clarification, and when it should escalate to a human. You'll also discover how clear escalation policies, objective triggers, and real-world examples help build trustworthy AI systems that avoid unnecessary escalations while ensuring users receive the right level of assistance.

In this lecture, you will learn:

• The three valid triggers for escalating an issue to a human

• Why explicit human requests should always be honored immediately

• How to resolve straightforward issues before considering escalation

• Why escalation decisions should be based on objective rules instead of sentiment or confidence

• How to handle multiple matching results by asking clarifying questions instead of guessing

• Why concrete examples teach escalation behavior better than abstract policies

• How to identify policy gaps and escalate instead of making unsupported decisions

• Best practices for designing balanced, trustworthy, and production-ready escalation workflows

In this lecture, you'll learn how to design effective error propagation across multi-agent systems so that failures can be diagnosed, recovered, and escalated correctly. You'll explore how agents should communicate meaningful error information, distinguish between valid empty results and actual failures, and handle errors without disrupting the entire workflow. These principles help build resilient AI systems where multiple agents collaborate reliably even when unexpected issues occur.

In this lecture, you will learn:

• Why errors should always include meaningful context instead of generic failure messages

• How to distinguish between valid empty results and genuine system errors

• Why specific error messages enable faster recovery than generic errors

• How to continue workflows safely without ignoring or overreacting to errors

• When agents should retry locally and when they should escalate failures

• How to annotate missing or incomplete data to improve downstream decision-making

• Best practices for propagating errors across multi-agent workflows while maintaining reliability and transparency

In this lecture, you'll learn how to explore and understand large codebases efficiently using Claude without overwhelming its context window. You'll discover techniques for preserving important findings, delegating exploration tasks to sub-agents, managing context effectively, and organizing discoveries so they remain useful throughout long analysis sessions. These practices help you navigate complex projects with greater accuracy and scalability.

In this lecture, you will learn:

• Why context quality degrades during long code exploration sessions

• How to preserve important discoveries instead of relying on conversation memory

• How sub-agents can handle detailed exploration while keeping the main workflow focused

• Why summarizing findings before spawning new agents improves efficiency

• How saving progress enables seamless recovery after interruptions

• How to reduce context clutter by retaining only the most important information

• Why coordinators should delegate exploration instead of inspecting every file themselves

• Best practices for mastering large codebases with Claude using structured exploration workflows

In this lecture, you'll learn how to design reliable human review workflows and confidence calibration for AI-powered systems. You'll explore why confidence scores should be validated, how to evaluate performance across different categories, and when human reviewers should be involved instead of relying solely on automation. These techniques help build trustworthy AI pipelines that balance automation with human oversight.

In this lecture, you will learn:

• Why overall average scores can hide critical weaknesses in specific categories

• Why AI systems should always be validated before enabling full automation

• How confidence scores should be verified using representative samples

• The difference between confidence and actual prediction accuracy

• Why evaluating results by individual segments provides better insights than overall averages

• How to route uncertain or low-confidence cases for human review while automating reliable ones

• Best practices for building safe, trustworthy, and scalable human-in-the-loop AI workflows

In this lecture, you'll learn how to preserve provenance when combining information from multiple sources. You'll discover why every fact should be traceable to its original source, how to handle conflicting information transparently, and why dates, evidence, and proper formatting are essential for building trustworthy AI systems. These practices ensure that generated content remains verifiable, reliable, and easy to audit.

In this lecture, you will learn:

• Why every factual claim should always be accompanied by its original source

• How to map individual claims back to the documents or reports they originated from

• How to present conflicting information from multiple trusted sources instead of hiding disagreements

• Why attaching dates to every claim provides essential context and avoids misleading conclusions

• How to distinguish between well-established facts and contested opinions or predictions

• Why different types of information should be presented using appropriate formats for better readability

• Best practices for creating transparent, verifiable, and trustworthy multi-source AI summaries