How do you turn a first Claude API request into a conversation workflow that can be evaluated and improved? This module walks you through the practical foundations of Claude API use, including API keys, messages, max_tokens, stop_reason, manual history, reusable chat helpers, system prompts, generation controls, and prompt evaluation. You will learn why the API is stateless, how applications preserve relevant conversation context, and why the Claude App and API should not be treated as having the same memory model. The lessons also address temperature, model selection, prefill, stop sequences, representative evaluation cases, code-based grading, model-based grading, human review, precision criteria, false positives, and few-shot examples. ShopAssist keeps the work concrete: customer ID, order ID, refund intent, and behavioral boundaries must remain clear while the application enforces rules that a prompt alone cannot guarantee. This module is designed for certification candidates, application developers, product builders, and technical leads; basic programming or pseudocode literacy is helpful but not required. You will take away a reliable conversation pattern, a prompt evaluation workflow, and a set of criteria for choosing the right grading method.

How can you make Claude produce structured information that an application can validate and safely use? This module develops the data-contract and tool-use skills needed for structured output, extraction workflows, and reliable automation. You will work with JSON objects, fields and values, required and optional properties, enums, nullable fields, JSON Schema, tool names, descriptions, parameters, return values, tool_choice, and tool_use blocks. The program emphasizes an important architectural distinction: syntactically valid JSON can still be semantically wrong. You will therefore practice validation-retry loops, specific error feedback, missing-source handling, calculated versus stated values, confidence calibration, labeled validation sets, accuracy by field and document type, and human-review thresholds. You will also compare synchronous requests with the Message Batches API and learn when independent review passes improve reliability. The module is for architects, developers, data engineers, exam candidates, and AI application builders who understand basic JSON; no prior structured-output implementation is assumed. You will learn to distinguish contract failures from business decisions during implementation. You will leave with the design for a validated ShopAssist return-request extractor, including its schema, retry policy, confidence signals, review routing, and verification approach.

How do you connect Claude to backend capabilities and MCP integrations without losing control of execution or error recovery? This module explains how a model request becomes a multi-step tool-driven workflow and how MCP organizes clients, servers, tools, resources, configuration, and scope. You will follow assistant tool-use blocks, tool-use IDs, external execution, returned tool results, stop reasons, loop continuation, and correct termination. The lessons classify transient, validation, business, and permission failures, distinguishing retryable problems from non-retryable ones and valid empty results from failed requests. You will also select the smallest direct built-in tool for a code operation, decide when a specialized MCP capability is justified, and scope access by agent responsibility rather than exposing every capability everywhere. The ShopAssist build turns customer lookup, order lookup, refund, and human escalation into a realistic backend tool layer with structured success and error responses. This module is intended for solution architects, developers, technical product owners, and Claude certification candidates; basic workflow and API concepts are enough to begin. You will take away a tool contract set, error taxonomy, access matrix, and MCP integration design.

When is one agent enough, and when does specialization solve a real architectural problem? This module develops the reasoning needed to design coordinator-worker and other multi-agent workflows without adding complexity for its own sake. You will compare single-agent, sequential, parallel, and dynamically decomposed work; identify dependencies; invoke subagents selectively; and pass context and results explicitly. The lessons cover coordinator responsibilities, subagent isolation, allowed tools, system prompts, provenance, gates, hooks, post-tool normalization, structured human handoffs, session resumption, scratchpads, state manifests, and recovery from context degradation. ShopAssist supplies a practical case: customer verification must precede financial operations, refund limits need enforcement, multi-concern requests may benefit from parallel investigation, and escalation must preserve useful case facts. The module is designed for architects, developers, technical leads, and exam candidates with basic API and tool concepts; no specific multi-agent framework is required. The emphasis is on proportionate design, explicit communication, and recoverable control for reliable architecture decisions. You will leave with a delegation design, coordinator diagram, control checklist, durable state manifest, and recovery plan. The final build brings these patterns together in a production-style agentic workflow.

How do you reason about Claude Code inside a real software-delivery workflow? This module provides the Git, repository, instruction, session, testing, and CI/CD knowledge needed to understand Claude Code certification scenarios and apply them responsibly. You will review repositories, commits, branches, pull requests, user- and project-level instructions, directory rules, path-scoped configuration, reusable commands, skills, plan mode, direct execution, examples, tests, interviews, non-interactive runs, structured JSON output, and review-session isolation. The lessons focus on preserving useful state without allowing long-running context to become stale, using explicit recovery artifacts, and improving solutions through evidence rather than vague requests. You will also design automated code reviews that can report machine-readable findings and avoid duplicate issues after new commits. This module is for certification candidates, developers, engineering leaders, reviewers, and technical product professionals; basic version-control vocabulary is helpful, but prior Claude Code experience is not required. The activities connect repository practice to architectural judgment and delivery risk. You will take away a repository instruction map, a session-recovery checklist, a refinement workflow, and a CI review contract aligned to Domain 3 and related reliability concerns.

How do you decide when an autonomous Claude workflow should continue, ask for clarification, recover locally, or hand control to a person? This module synthesizes production-reliability principles across the certification domains and turns them into scenario-solving judgment. You will examine explicit human requests, policy exceptions, ambiguity, multiple customer matches, field-level confidence, calibration, review capacity, persistent case facts, structured issue state, failure types, partial results, alternative recovery paths, and valid empty results. You will also preserve provenance by connecting claims to sources, retaining attribution and dates, representing conflicting credible evidence, and making coverage gaps visible instead of hiding uncertainty. The final lesson brings ShopAssist and the other exam scenarios together so that you can distinguish missing information from insufficient reasoning, failed requests from empty results, clarification from escalation, and necessary specialization from unnecessary architecture. This module is intended for all learners completing the Claude Certified Architect – Foundations program, including architects, developers, reviewers, and technical leads; no new tools are required. You will leave with a reliability decision framework and a final scenario checklist built around one principle: choose the simplest architecture that reliably solves the actual requirement.