# How the 20 Phases of the AI Engineering Curriculum Are Structured

> Explore the AI Engineering curriculum's 20 phases, structured sequentially from basics to capstones. Each phase includes code, docs, outputs, and quizzes for comprehensive learning.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: curriculum-overview
- Published: 2026-06-13

---

**The AI Engineering curriculum is organized into 20 sequential phases that build from foundational tooling to advanced capstone projects, with each phase stored in the `phases/` directory and following a standardized lesson structure containing `code/`, [`docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md), `outputs/`, and [`quiz.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/quiz.json) components.**

The rohitg00/ai-engineering-from-scratch repository delivers a comprehensive, self-contained curriculum designed to teach AI engineering through progressive, hands-on implementation. According to the repository's README, the content is structured into **20 sequential phases** enumerated in the "The shape of the curriculum" section, which includes a Mermaid diagram illustrating the progression from environment setup to production deployment.

## The Complete 20-Phase Breakdown

The curriculum progresses through distinct domains of AI engineering, with each phase residing in a numbered folder under `phases/`:

1. **`phases/00-setup-and-tooling`** — Setup & Tooling: Environment setup, Git, Docker, notebooks, and profiling
2. **`phases/01-math-foundations`** — Math Foundations: Linear algebra, calculus, probability, optimization, and graph theory
3. **`phases/02-ml-fundamentals`** — ML Fundamentals: Classical ML algorithms including regression, trees, SVMs, clustering, and pipelines
4. **`phases/03-deep-learning-core`** — Deep Learning Core: Perceptron to multi-layer nets, back-propagation, optimizers, and mini-frameworks
5. **`phases/04-computer-vision`** — Vision: Convolutions, CNNs, detection, segmentation, diffusion, ViT, and 3D vision
6. **`phases/05-nlp-foundations-to-advanced`** — NLP: Foundations to Advanced: Tokenization, embeddings, seq-2-seq, attention, LLM-style generation, and RAG
7. **`phases/06-speech-and-audio`** — Speech & Audio: Waveforms, spectrograms, ASR, Whisper, TTS, voice cloning, and evaluation
8. **`phases/07-transformers-deep-dive`** — Transformers Deep Dive: Self-attention, multi-head mechanisms, positional encodings, BERT/GPT, MoE, and KV-cache
9. **`phases/08-generative-ai`** — Generative AI: VAEs, GANs, diffusion, latent diffusion, ControlNet, and video/audio generation
10. **`phases/09-reinforcement-learning`** — Reinforcement Learning: MDPs, dynamic programming, Q-learning, DQN, policy gradients, PPO, RLHF, and multi-agent systems
11. **`phases/10-llms-from-scratch`** — LLMs from Scratch: Tokenizers, mini-GPT pre-training, distributed training, RLHF, and quantization
12. **`phases/11-llm-engineering`** — LLM Engineering: Prompt engineering, RAG, fine-tuning (LoRA), function calling, and guardrails
13. **`phases/12-multimodal-ai`** — Multimodal AI: Vision-language (CLIP, BLIP-2), audio-language (Whisper), video, and omni-models
14. **`phases/13-tools-and-protocols`** — Tools & Protocols: Tool interfaces, MCP fundamentals, servers/clients, security, and routing
15. **`phases/14-agent-engineering`** — Agent Engineering: Agent loops, planning, memory systems, LangGraph, AutoGen, and benchmarks
16. **`phases/15-autonomous-systems`** — Autonomous Systems: Self-contained agents and autonomous system architectures
17. **`phases/16-multi-agent-and-swarms`** — Multi-Agent & Swarms: Coordination, hierarchical orchestration, and swarm dynamics
18. **`phases/17-infrastructure-and-production`** — Infrastructure & Production: Deployment, observability, logging, scaling, and CI/CD for AI services
19. **`phases/18-ethics-and-alignment`** — Ethics & Alignment: Safety, bias mitigation, interpretability, and constitutional AI
20. **`phases/19-capstone-projects`** — Capstone Projects: Real-world end-to-end projects integrating the full stack of skills

## Uniform Lesson Structure Within Each Phase

Every phase contains multiple lessons that follow a rigid template defined in [`LESSON_TEMPLATE.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md). Each lesson directory includes:

- **`code/`** — Implementation files and source code
- **[`docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md)** — English documentation and instructional content
- **`outputs/`** — Generated artifacts, model checkpoints, or results
- **[`quiz.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/quiz.json)** — Assessment questions and answers

This structure ensures that whether you are exploring `phases/03-deep-learning-core` or `phases/10-llms-from-scratch`, the navigation pattern remains identical.

## Key Files for Curriculum Navigation

Several critical files govern the organization and maintenance of the 20 phases:

- **[`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md)** — Contains the curriculum overview, the Mermaid diagram enumerating all 20 phases, and lesson count statistics
- **[`ROADMAP.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ROADMAP.md)** — Tracks completion status, work-in-progress items, and upcoming content for each phase
- **[`LESSON_TEMPLATE.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md)** — Guarantees consistent structure across all lessons in the repository
- **[`scripts/audit_lessons.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/audit_lessons.py)** — Automates validation, README count syncing, and catalogue generation
- **[`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js)** — Transforms the markdown curriculum into the public website at aiengineeringfromscratch.com
- **[`glossary/terms.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/glossary/terms.md)** — Defines recurring concepts such as "MCP" and "Agent Loop"

## Exploring the Curriculum Programmatically

You can interact with the 20-phase structure programmatically to automate learning workflows or build custom tooling.

### List All Lessons in a Specific Phase

```python
import os
import json
import pathlib

def list_lessons(phase_folder: str):
    base = pathlib.Path('phases') / phase_folder
    lessons = sorted(p.name for p in base.iterdir() if p.is_dir())
    return lessons

print(list_lessons('01-math-foundations'))   # → ['01-linear-algebra-intuition', ...]

```

### Extract Documentation Metadata

```bash

# Show the metadata header of lesson 01 in Phase 1

sed -n '1,15p' phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md

```

### Run a Specific Lesson Implementation

```bash

# Python example – run the perceptron implementation from Phase 3

python phases/03-deep-learning-core/01-the-perceptron/code/perceptron.py

```

### Query the Complete Phase Catalogue

```javascript
const fs = require('fs');
const path = require('path');

const phases = fs.readdirSync('phases')
  .filter(name => fs.lstatSync(path.join('phases', name)).isDirectory());

console.log('All phases:', phases);

```

## Summary

- The curriculum consists of **20 sequential phases** stored in `phases/00-setup-and-tooling` through `phases/19-capstone-projects`, as enumerated in the README's "The shape of the curriculum" section
- Each phase follows a **standardized lesson structure** containing `code/`, [`docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md), `outputs/`, and [`quiz.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/quiz.json) directories
- The **[`LESSON_TEMPLATE.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md)** enforces consistency across all lessons, while **[`ROADMAP.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ROADMAP.md)** tracks completion status
- Build and validation scripts in `scripts/` (such as [`audit_lessons.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/audit_lessons.py)) automate curriculum maintenance
- The **[`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js)** processor transforms the local markdown structure into the public-facing website

## Frequently Asked Questions

### What is the recommended order for completing the 20 phases?

The phases are designed to be completed sequentially from **Phase 0 (Setup & Tooling)** through **Phase 19 (Capstone Projects)**. Each phase builds upon concepts from previous ones, starting with mathematical foundations and classical ML before progressing to deep learning, transformers, LLMs, and finally autonomous systems and production infrastructure.

### How are individual lessons structured within each phase?

Every lesson follows a **uniform template** containing four components: a `code/` directory for implementations, a [`docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md) file for instructional content, an `outputs/` directory for artifacts, and a [`quiz.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/quiz.json) file for assessments. This structure is enforced by the [`LESSON_TEMPLATE.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LESSON_TEMPLATE.md) file and maintained through automated validation scripts.

### Where can I find the roadmap and completion status of each phase?

The **[`ROADMAP.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ROADMAP.md)** file in the repository root tracks the completion status, work-in-progress items, and upcoming content for all 20 phases. This file serves as the source of truth for curriculum development progress and planned enhancements.

### How is the curriculum content transformed into the public website?

The **[`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js)** script processes the markdown curriculum and generates the static site deployed to aiengineeringfromscratch.com. This build system reads the phase structure from the `phases/` directory and renders the documentation, code examples, and navigation hierarchies into the public-facing format.