Select Course▼🌐Language▼0PricingLogin▼
💻

Claude Architect

PYTHON

Master the architecture of production Claude applications — agentic systems, tool & MCP design, Claude Code, prompt engineering and structured output. Your complete prep for the official Claude Certified Architect exam.

🤖 AI-Powered
Start Learning →
Course Overview

Become a Claude Certified Architect

This track prepares you for Anthropic's official Claude Certified Architect — Foundations exam: a scenario-based certification for solution architects who design and ship production applications on Claude.

The Five Exam Domains

You will master all five tested domains: Agent Architecture & Orchestration, Tool Design & MCP Integration, Claude Code Configuration & Workflows, Prompt Engineering & Structured Output, and Context Management & Reliability.

What You Will Learn

Design agentic loops that terminate on stop_reason instead of fragile text parsing. Build hub-and-spoke multi-agent systems with isolated context. Enforce business rules with deterministic hooks, not hopeful prompts. Write tool descriptions that route correctly, return structured errors, and integrate MCP servers. Configure Claude Code with CLAUDE.md hierarchies, skills, plan mode and CI/CD. Get reliable structured output with tool_use, JSON Schema and validation-retry loops. And manage context, escalation and provenance for production reliability.

How It Works

Short, focused courses move from fundamentals through each domain to a capstone of the real exam scenarios and the anti-patterns that cost candidates points. Every lesson is grounded in the official Agent SDK, MCP, Claude Code and prompt-engineering documentation.

Start Learning →
Tools

Explore Course Tools

Supercharge your learning with AI-powered tools and features

⚡
AI Code Generator
Generate code with AI
🐛
AI Bug FixPRO
Find & fix code errors
🔍
AI InsightPRO
Deep code analysis
💬
AI Chat
Chat with AI tutor
🧠
Ask Super QuestionPRO
Get expert-level answers
📝
Create LessonPRO
AI-powered lesson builder
🏆
Start Certification ExamPRO
Earn your certificate
💻
Code Editor
Write & run code
🎯
Start Challenge
Test your skills

How You'll Learn

🎯
Interactive Lessons
Hands-on coding exercises with real-time feedback
🤖
AI Tutor
Get instant help from our AI when you're stuck
💻
Built-in Editor
Write and run code directly in your browser
🏆
Certificate
Earn a certificate when you complete the course
Curriculum

26 Courses

Every course in the Claude Architect learning path.

01

What Is the Claude Certified Architect Cert?

A14 lessons

Get oriented: what the certification proves, how the exam works, the five domains, scoring, and who should take it.

  • The Certification at a Glance
  • The Five Exam Domains
  • Scenario-Based Format & Scoring
  • +1 more
02

Claude Models & API Foundations

A24 lessonsPRO

The bedrock every architect needs: the model family, the shape of an API request, stop reasons, and how tokens and context work.

  • The Claude Model Family
  • Anatomy of an API Request
  • Stop Reasons Explained
  • +1 more
03

Introduction to Agentic Systems

A24 lessonsPRO

What makes a system truly agentic, model-driven decisions versus hard-coded trees, and the loop at the heart of every agent.

  • What Makes a System Agentic
  • Model-Driven vs Hard-Coded Decisions
  • When to Use an Agent
  • +1 more
04

The Claude Agent SDK

B14 lessonsPRO

Build agents the right way: SDK building blocks, defining agents, spawning subagents with the Task tool, and least-privilege tool access.

  • Agent SDK Building Blocks
  • Defining an Agent
  • The Task Tool & allowedTools
  • +1 more
05

Agentic Loops & Termination

B14 lessonsPRO

The single most tested idea: terminate on stop_reason, never by parsing text or capping iterations. Loop design done right.

  • The Core Loop
  • Terminating on stop_reason
  • Anti-Pattern: Parsing Text for Completion
  • +1 more
06

Multi-Agent Orchestration

B24 lessonsPRO

Coordinate specialists with a hub-and-spoke coordinator. Master context isolation — subagents do not inherit the coordinator's history.

  • Hub-and-Spoke Coordinator Topology
  • Coordinator Responsibilities
  • Subagents Don't Inherit History
  • +1 more
07

Hooks & Workflow Enforcement

B24 lessonsPRO

When failure has legal, financial or safety cost, prompts aren't enough. Use hooks and programmatic preconditions for deterministic guarant…

  • PostToolUse & Outgoing-Call Hooks
  • Deterministic Enforcement vs Prompts
  • Programmatic Preconditions
  • +1 more
08

Sessions & Task Decomposition

B24 lessonsPRO

Fixed pipelines versus adaptive decomposition, multi-pass strategies, and managing sessions with resume and fork.

  • Fixed Pipelines vs Adaptive Decomposition
  • Multi-Pass Decomposition
  • Session Management
  • +1 more
09

Designing Effective Tools

B14 lessonsPRO

Tool descriptions are the primary selection mechanism. Write descriptions that route correctly and never overlap.

  • Tool Descriptions Drive Selection
  • Anatomy of a Great Description
  • Avoiding Overlapping Tools
  • +1 more
10

Structured Error Responses

B14 lessonsPRO

Generic errors block recovery; structured errors enable intelligent routing. Categorize, flag retryability and return partial results.

  • The isError Flag
  • Error Categories
  • Retryable Metadata & Partial Results
  • +1 more
11

Model Context Protocol (MCP)

B24 lessonsPRO

Integrate external systems through MCP: tools, resources and prompts; project versus user scope; and secrets done safely.

  • Tools, Resources & Prompts
  • Project vs User Scope
  • Secrets with Environment Variables
  • +1 more
12

Tool Allocation & Built-in Tools

B14 lessonsPRO

How many tools per agent, controlling output with tool_choice, and Claude Code's built-in tools for incremental investigation.

  • How Many Tools Per Agent
  • tool_choice: auto / any / forced
  • Claude Code Built-in Tools
  • +1 more
13

Claude Code Fundamentals

B14 lessonsPRO

What Claude Code is, interactive versus headless use, the edit loop, and persisting knowledge with memory and compact.

  • What Is Claude Code
  • Interactive vs Headless
  • The Read / Edit / Write Loop
  • +1 more
14

CLAUDE.md Hierarchy & Rules

B14 lessonsPRO

Configure Claude with layered instructions: user, project and directory CLAUDE.md, the @path import syntax, and path-scoped rules.

  • User / Project / Directory Levels
  • The @path Import Syntax
  • .claude/rules/ with Frontmatter Paths
  • +1 more
15

Commands, Skills & Plan Mode

B24 lessonsPRO

Extend Claude Code with custom commands and skills, isolate verbose output, and know when to plan versus execute directly.

  • Custom Commands vs Skills
  • Skill Frontmatter
  • Plan Mode vs Direct Execution
  • +1 more
16

Claude Code in CI/CD

B24 lessonsPRO

Run Claude Code in pipelines: non-interactive mode, structured JSON output, isolated review sessions, and reliable test generation.

  • Non-Interactive Mode
  • Structured Output
  • Session Isolation for Reviews
  • +1 more
17

Prompt Engineering for Architects

B14 lessonsPRO

Explicit criteria beat vague instructions. Define what to report versus ignore, set severity levels, and cut false positives.

  • Explicit Criteria over Vague Instructions
  • Categorical Examples
  • Severity Criteria with Examples
  • +1 more
18

Few-Shot Prompting

B14 lessonsPRO

Two to four targeted examples make output consistent and handle edge cases — without the model merely repeating them.

  • Why 2-4 Examples Work
  • Examples for Format & Edge Cases
  • Generalization vs Repetition
  • +1 more
19

Structured Output with tool_use & JSON Schema

B24 lessonsPRO

Guarantee machine-readable output with tool_use and JSON Schema. Design required versus optional fields and extensible enums.

  • tool_use for Guaranteed Structure
  • Designing a JSON Schema
  • Required vs Optional/Nullable Fields
  • +1 more
20

Validation & Retry Loops

B24 lessonsPRO

Validate structured output and retry with feedback. Know when retry helps, when it can't, and how independent review beats self-review.

  • When Retry Helps (and When It Can't)
  • Retry-with-Feedback Prompts
  • Self-Correction
  • +1 more
21

Context Management Essentials

B24 lessonsPRO

The model keeps no state — you send full history every turn. Manage summarization risk, the lost-in-the-middle effect and output bloat.

  • Full History Is Required
  • Progressive Summarization Risks
  • Lost-in-the-Middle Effect
  • +1 more
22

Escalation & Error Propagation

B24 lessonsPRO

Escalate on clear triggers — not sentiment or self-rated confidence. Propagate structured error context and recover locally when you can.

  • Clear Escalation Triggers
  • Anti-Pattern: Sentiment & Confidence Scores
  • Structured Error Context
  • +1 more
23

Provenance & Human Oversight

C14 lessonsPRO

Preserve claim-to-source mappings, handle conflicting data with dates, and use stratified sampling because aggregate metrics hide failures.

  • Claim to Source Mappings
  • Conflicting Data & Dates
  • Aggregate Metrics Hide Failures
  • +1 more
24

The Exam Scenarios

C14 lessonsPRO

Walk through all eight exam scenarios end to end, mapping each to the domains and patterns it tests.

  • Support Agent & Multi-Agent Research
  • Code Gen & Developer Productivity
  • CI/CD & Structured Extraction
  • +1 more
25

Anti-Patterns Masterclass

C14 lessonsPRO

The wrong answers that cost points. Every major anti-pattern, why it's tempting, and the correct architecture instead.

  • Loop & Orchestration Anti-Patterns
  • Tool & Error Anti-Patterns
  • Prompt & Review Anti-Patterns
  • +1 more
26

Mock Exam & Test-Taking Strategy

C14 lessonsPRO

Bring it together: how scenario questions are scored, how to read them, eliminate wrong answers, and a full mock walkthrough.

  • How Scenario Questions Are Scored
  • Reading a Scenario Prompt
  • Eliminating Wrong Answers
  • +1 more

Start Claude Architect Now

Join thousands of learners mastering programming with AI-powered lessons.

Get Started Free →Browse All Courses