# How the AI Engineering from Scratch Curriculum Is Structured: 20 Phases, 511 Lessons, and 3 Learning Paths

> Explore the AI Engineering from Scratch curriculum structure. Discover 20 phases, 511 lessons, and 3 learning paths designed to build production AI systems effectively.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: architecture
- Published: 2026-08-30

---

**The AI Engineering from Scratch curriculum uses a layered architecture of 20 sequential phases containing 511 lessons, each following a 5-step "build-it-then-use-it" pattern to progress from basic tooling to production AI systems.**

The `rohitg00/ai-engineering-from-scratch` repository implements one of the most comprehensive open-source curricula for learning AI engineering. Unlike fragmented tutorial collections, this curriculum enforces strict structural conventions across every lesson, enabling learners to generate reusable artifacts—prompts, skills, agents, and MCP servers—that compound across phases.

## Phase-Based Architecture: 20 Levels of Progression

The curriculum organizes content into **20 phases**, visualized in the [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) Mermaid diagram spanning lines 78–99. Each phase represents a broad topical block that stacks on previous knowledge:

| Phase Range | Focus Area | Example Phase |
|-------------|-----------|---------------|
| 0–2 | Tooling and mathematics | `phases/01-math-foundations/` |
| 3–12 | Core ML and deep learning | `phases/09-transformers/` |
| 13–18 | Tools, protocols, and agents | `phases/14-agent-engineering/` |
| 19 | Integration and capstones | `phases/19-capstone-projects/` |

The phase map in [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) explicitly shows dependencies, allowing learners to **skip ahead** when they master lower layers while preserving logical connections that explain why higher-level concepts work.

## Lesson Structure: 5 Beats and 4 Output Types

Every lesson across all 511 units follows an identical folder layout in `phases/<NN>-<phase-name>/<NN>-<lesson-name>/`:

```

<lesson>/
├── code/          # Runnable implementations

├── docs/          # Narrative content (docs/en.md)

└── outputs/       # Generated artifacts

```

As documented in [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) lines 110–118 and 124–132, each lesson implements **five beats**:

1. **MOTTO** – Core principle in one sentence
2. **PROBLEM** – Concrete challenge to solve
3. **CONCEPT** – Theoretical foundation
4. **BUILD IT** – Implementation phase
5. **USE IT → SHIP IT** – Deployment and real-world application

This structure ensures every lesson produces a **reusable artifact**—either a prompt, skill, agent, or MCP server—that learners carry forward into subsequent phases.

## Code Implementations: Up to 4 Languages Per Lesson

Lessons provide runnable implementations across multiple languages. For example, Phase 1's linear algebra intuition lesson:

```bash

# Clone and run a sample lesson

git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch
python3 phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

```

The `code/` directory in each lesson contains language-specific implementations, with Python as the primary reference and additional languages where pedagogically relevant.

## Three Entry Points: Adaptive Learning Paths

The curriculum supports three distinct entry points, defined in the `skills/` directory and documented in [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) lines 64–71:

| Entry Point | Command | Generated File | Best For |
|-------------|---------|----------------|----------|
| Placement tutor | `learn start-learning` | [`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md) | Assessing current skill level |
| MCP path | MCP host integration | [`MCP-LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/MCP-LEARNING.md) | Engineers building tool ecosystems |
| Agent-Skills path | Agent host integration | [`AGENT-SKILLS-LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENT-SKILLS-LEARNING.md) | Developers creating autonomous agents |

To use the placement tutor:

```bash

# Requires npx and a skill-capable host

npx skills add rohitg00/ai-engineering-from-scratch
learn start-learning

```

Each path generates a personalized learning file that guides the learner through a relevant subset of phases rather than enforcing linear progression.

## Capstone Projects and Certification Tracks

**Phase 19** aggregates capstone projects that combine artifacts from earlier phases into end-to-end systems. Located in `phases/19-capstone-projects/`, these projects require integrating prompts, skills, agents, and MCP servers built throughout the curriculum.

Separate **Claude certification tracks** in `certifications/claude/` map lesson subsets to official exam objectives. These tracks reuse the same lesson infrastructure while adding diagnostic assessments aligned with certification requirements.

## MCP Labs and Protocol Implementation

Phase 13 covers the **Model Context Protocol (MCP)**, with lessons like `phases/13-tools-and-protocols/06-mcp-fundamentals/` demonstrating protocol implementation:

```bash

# Run an MCP fundamentals lab

python3 phases/13-tools-and-protocols/06-mcp-fundamentals/code/run_mcp.py

```

The [`skills/learn-mcp/SKILL.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/skills/learn-mcp/SKILL.md) file defines the MCP learning path, enabling integration with MCP-compatible hosts for hands-on protocol practice.

## Summary

- **20 phases** provide topical progression from tooling to production systems, visualized in [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) with explicit dependency graphs.

- **511 lessons** follow identical 5-beat structure (MOTTO → PROBLEM → CONCEPT → BUILD IT → USE IT → SHIP IT) with consistent folder layouts.

- **Four artifact types**—prompts, skills, agents, and MCP servers—accumulate across phases and compose into capstone projects.

- **Three adaptive entry points** via the `skills/` directory generate personalized learning files based on learner background and goals.

- **Phase 19 capstones** and **Claude certification tracks** provide integration testing and credentialing pathways using the same lesson infrastructure.

## Frequently Asked Questions

### How many lessons are in the AI Engineering from Scratch curriculum?

The curriculum contains **511 lessons** distributed across 20 phases. Each lesson follows the same structural conventions with `code/`, `docs/`, and `outputs/` directories, as defined in [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) lines 110–118.

### Can I skip phases if I already know the material?

Yes. The phase architecture explicitly supports skipping— the [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) dependency graph (lines 75–77) shows logical connections between phases, allowing learners to enter at appropriate skill levels while maintaining understanding of why higher-level concepts work.

### What programming languages does the curriculum use?

Lessons primarily use **Python** for implementations, with up to four languages available in select lessons. The `code/` directory in each lesson contains runnable examples, with Python serving as the reference implementation across all 511 lessons.

### How do the certification tracks differ from the main curriculum?

The Claude certification tracks in `certifications/claude/` map a **subset of lessons and diagnostics** to official exam objectives. They reuse the same lesson infrastructure as the main curriculum but add assessment-focused scaffolding for credentialing purposes.