
Compare deterministic workflows with agentic systems, and learn when fixed control flow and prompt chaining outperform agents, using routing and parallelization to reduce token cost, latency, and ensure auditable steps.
Break complex goals into meaningful subtasks with explicit handoffs and an orchestrator to improve reliability and manage complexity in agentic workflows.
Explore hierarchical, sequential, and parallel decomposition patterns and how real systems mix them to balance specialization, data dependency, and latency. Identify anti-patterns like over-decomposition, under-decomposition, and false parallelism.
discover sequential pipelines and prompt chaining, map dependencies with graphs, and design explicit handoffs to reduce latency while maintaining reliable, auditable data flow.
Explore adaptive planning in agentic systems, comparing static versus dynamic planning, and identify replanning triggers like tool failures, state changes, and constraint violations, with bounds to prevent drift.
Explore the orchestrator role in multi-agent systems, mastering task decomposition, assignment to sub-agents, and result aggregation with bounded sub-tasks, observability, and robust error handling.
Explore sub-agent design by scoping authority, enforcing context isolation, and crafting precise instructions to ensure predictable, minimal, and testable outputs.
design robust inter-agent handoff schemas that include the task description, relevant context, output format, and constraints; version schemas, test them with contract tests, and ensure forward compatibility and substitutability.
Learn how to achieve session continuity by designing durable checkpoints, applying state versioning, and practicing memory hygiene to resume tasks after interruptions without duplicating work.
Identify optimal interruption point placement, design effective handoff messages, and manage external state to enable safe, asynchronous or synchronous escalation and seamless resumption in HITL workflows.
Discover how tool descriptions drive Claude's routing through semantic matching, and avoid misrouting by ensuring descriptions that specify what a tool does, its inputs and outputs, when to call it.
Design tool errors with a stable code, a clear message, and a context of the failed input, plus a suggested action to guide Claude.
Explore how Claude selects tools from a palette, prevent no good match and two good matches failures, and use disambiguation patterns and production logging to improve routing.
Explore the model context protocol (MCP), an open, vendor-neutral standard that unifies server and client interactions, replacing bespoke adapters with a single contract for discovering and invoking capabilities.
Learn how to build a first MCP server in Python using the MCP SDK, covering installation, transport options, project structure, and lifecycle hooks for reliable startup and shutdown.
Explore how an MCP client mediates between the language model and tool servers, managing discovery, tool and resource lists, caching, and routing across stdio or streamable http transports.
Turn MCP server into an HTTP service with server sent events for streaming. Use stateless or session-based state for remote and production deployments, secured with TLS, authentication, and load balancing.
Explore how built-in tools in the Cloud API work—web search and computer use—covering their boundaries, cost and latency, and when to use custom tools for server and client deployments.
Explore how context quality shapes Cloud Code outputs. Identify four context entry methods—file path mentions, at sign references, pasted URLs, inline instructions—and explain deny rules and Cloud.md.
Exclude sensitive files by writing read deny rules in settings.json using glob syntax; deny beats allow across managed, local, project, and user layers, and there's no dot clodignore.
Discover how to encode repo-specific decisions—language and runtime versions, style conventions, test requirements, and commit format—into structured Cloud.md for reliable Cloud Code behavior.
Explore clod.md patterns across front-end, back-end, and full-stack projects, detailing directives, security and test patterns, anti-patterns like tool duplication, and how to avoid drift.
This course contains the use of artificial intelligence. However, every lecture recording involves me reading the scripts, and I am fully involved in scripting and production. Be careful buying courses with instructors that don't appear in person. AI courses are becoming quite common on learning platforms.
This course is a complete, structured study program for the Anthropic Claude Certified Architect — Foundations (CCA-F, CCAR-F) exam. Built domain by domain against the official exam blueprint, it covers every topic area you need to understand before sitting for the exam. Each lesson is a narrated video that explains how concepts connect to each other and to real-world practice — not just what the definition is, but how a practitioner applies it.
D1 — Agentic Architecture & Orchestration (27% of the exam) — covers defining agentic systems — autonomy, tool use, and the action loop, agents vs. workflows vs. conversational systems, when to use agentic architecture vs. simpler patterns, task analysis and decomposition strategies, sequential vs. parallel execution patterns, dynamic planning, replanning, and ambiguity handling, orchestrator-subagent model — roles, scope, and context isolation, multi-agent topology patterns — hub-and-spoke, pipeline, peer-to-peer, agent communication, handoff schemas, and error propagation, state and session management — in-context vs. external memory, error classification — tool, reasoning, and environment errors, fallback and retry strategies, programmatic enforcement vs. prompt-based guardrails, human-in-the-loop escalation design. You will understand how each of these areas is tested on the exam and how they connect to real-world practice.
D2 — Claude Code Configuration & Workflows (20% of the exam) — covers claude code architecture — tool system and execution model, project setup, context management, and session continuity, user, project, and team-level claudemd — hierarchy and precedence, path-specific rules, subdirectory config, and .claudeignore, writing effective claudemd instructions for teams, custom slash commands — creation, structure, and distribution, skills — skillmd, frontmatter, triggers, and enterprise deployment, subagents in claude code — configuration, scope, and delegation, hooks — lifecycle events, implementation, and exit code conventions, useful hook patterns — logging, safety nets, and automation, claude code sdk — programmatic session control, ci/cd integration — non-interactive mode and the -p flag. You will understand how each of these areas is tested on the exam and how they connect to real-world practice.
D3 — Prompt Engineering & Structured Output (20% of the exam) — covers clarity, specificity, and instruction design, system prompts — structure, role definition, and context injection, xml tags and document structure for complex prompts, few-shot prompting and high-quality example design, chain-of-thought and extended thinking, prefilling, output steering, and format anchoring, temperature, top_p, top_k — generation parameter control, multi-turn conversation design and context accumulation, json mode and schema-constrained output, tool use for structured data extraction and validation loops, prompt evaluation — test datasets, grading, and regression testing. You will understand how each of these areas is tested on the exam and how they connect to real-world practice.
D4 — Tool Design & MCP Integration (18% of the exam) — covers tool descriptions as routing mechanisms, tool input schema design — parameters, enums, and constraints, tool error handling, idempotency, and partial success, mcp architecture — servers, clients, and the three primitives, building mcp servers — defining and exposing tools, resources and prompt templates in mcp, mcp clients — discovery, invocation, and multi-server routing, mcp transport mechanisms — stdio vs. streamablehttp, advanced mcp features — sampling, notifications, and roots, mcp security — access scoping, authentication, and production hardening. You will understand how each of these areas is tested on the exam and how they connect to real-world practice.
D5 — Context Management & Reliability (15% of the exam) — covers context window architecture — tokens, limits, and cost tradeoffs, the lost in the middle effect — evidence and mitigation, rag architecture — chunking, embedding, and the retrieval pipeline, semantic search, bm25, and hybrid retrieval, multi-index rag, production hardening, and citation, prompt caching — eligibility rules, cache placement, and cost impact, batch api — 50% cost savings, 24-hour window, and workload design, long-conversation coherence, compaction, and session memory. You will understand how each of these areas is tested on the exam and how they connect to real-world practice.
Every domain includes practice questions designed to mirror the style and difficulty of CCAR-F exam scenarios, covering not just recall but application and analysis. The course closes with full-length practice exams with detailed answer explanations, so you can measure your readiness and focus your remaining study time where it matters most.
Major topics covered: defining agentic systems — autonomy, tool use, and the action loop, agents vs. workflows vs. conversational systems, when to use agentic architecture vs. simpler patterns, task analysis and decomposition strategies, sequential vs. parallel execution patterns, dynamic planning, replanning, and ambiguity handling, orchestrator-subagent model — roles, scope, and context isolation, multi-agent topology patterns — hub-and-spoke, pipeline, peer-to-peer, agent communication, handoff schemas, and error propagation, state and session management — in-context vs. external memory, error classification — tool, reasoning, and environment errors, fallback and retry strategies, programmatic enforcement vs. prompt-based guardrails, human-in-the-loop escalation design, claude code architecture — tool system and execution model, project setup, context management, and session continuity, user, project, and team-level claudemd — hierarchy and precedence, path-specific rules, subdirectory config, and .claudeignore, writing effective claudemd instructions for teams, custom slash commands — creation, structure, and distribution, skills — skillmd, frontmatter, triggers, and enterprise deployment, subagents in claude code — configuration, scope, and delegation, hooks — lifecycle events, implementation, and exit code conventions, useful hook patterns — logging, safety nets, and automation, claude code sdk — programmatic session control, ci/cd integration — non-interactive mode and the -p flag, clarity, specificity, and instruction design, system prompts — structure, role definition, and context injection, xml tags and document structure for complex prompts, few-shot prompting and high-quality example design, CCAR-F exam prep 2026.