# AI Engineering Curriculum Multi-Phase Progression System: From Phase 0 to Phase 19

> Explore the 20-phase AI Engineering curriculum from scratch. This linear progression system ensures mastery with automated verification at each stage. Advance your AI skills systematically.

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

---

**The rohitg00/ai-engineering-from-scratch repository implements a strict 20-phase linear progression system where each phase builds upon the artifacts of the previous, enforced by automated verification scripts that validate prerequisite completion before allowing advancement.**

The **multi-phase progression system** in this AI Engineering curriculum is designed as a stacked dependency graph spanning Phase 0 (Setup & Tooling) through Phase 19 (Capstone Projects). Unlike traditional courses that allow random access to modules, this repository enforces a linear learning path where you construct neural networks, transformers, and autonomous agents from scratch before touching high-level APIs. The curriculum structure ensures that every advanced concept rests on a foundation you have personally coded and validated according to the source repository.

## The 20-Phase Linear Architecture

The curriculum organizes content into **20 sequential phases** forming a dependency chain visualized in the main [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) via a Mermaid diagram. Each phase represents a coherent skill cluster that produces reusable artifacts consumed by downstream lessons.

### Foundation Phases (0–3): Environment Setup to Deep Learning Core

**Phase 0 — Setup & Tooling** validates your development environment through scripts like [`phases/00-setup-and-tooling/01-dev-environment/code/verify.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/00-setup-and-tooling/01-dev-environment/code/verify.py), ensuring Git, Python 3.11+, and core dependencies are installed before any code execution.

**Phase 1 — Math Foundations** establishes the mathematical floor with linear algebra, calculus, and probability implementations that subsequent neural network code imports directly.

**Phase 2 — ML Fundamentals** covers classical algorithms (SVMs, decision trees, clustering) that still power production feature pipelines.

**Phase 3 — Deep-Learning Core** transitions from perceptrons to backpropagation, culminating in a mini-framework that mirrors PyTorch internals. Artifacts created here—custom autograd engines and optimizers—are reused in Phases 4 through 10.

### Modality Specialization Phases (4–10): Vision, NLP, and LLMs

These phases branch from the deep learning core while maintaining strict dependencies on Phase 3 artifacts:

**Phase 4 — Vision**, **Phase 5 — NLP**, and **Phase 6 — Speech & Audio** each implement domain-specific architectures (CNNs, RNNs, spectrogram transformers) using the backpropagation and optimizer code written in Phase 3.

**Phase 7 — Transformers Deep-Dive** and **Phase 8 — Generative AI** extend the NLP foundation with self-attention mechanisms and GANs/VAEs, producing model weights and tokenizers consumed later.

**Phase 9 — Reinforcement Learning** applies deep learning knowledge to policy gradients and Q-learning.

**Phase 10 — LLMs from Scratch** integrates everything—tokenizers from Phase 7, distributed training logic, RLHF implementations, quantization kernels, and inference optimizations—producing production-grade language model artifacts.

### Production and Advanced Systems (13–19): Agents to Capstone

The final arc transitions from model training to system deployment:

**Phase 13 — Tools & Protocols** introduces the **Model-Context-Protocol (MCP)** for interoperability, teaching you to build server implementations that expose tools to AI systems.

**Phase 14 — Agent Engineering** provides a framework-free implementation of autonomous agent loops using the MCP servers from Phase 13 and the LLM artifacts from Phase 10.

**Phase 15 — Autonomous Systems**, **Phase 16 — Multi-Agent & Swarms**, and **Phase 17 — Infrastructure & Production** cover deployment pipelines, distributed inference, and multi-agent orchestration patterns.

**Phase 18 — Ethics & Alignment** implements safety filters and reward modeling techniques.

**Phase 19 — Capstone Projects** mandates integration of all prior artifacts—custom optimizers (Phase 3), transformer weights (Phase 10), MCP servers (Phase 13), and agent loops (Phase 14)—into end-to-end production systems deployed via the infrastructure tools from Phase 17.

## Dependency Enforcement Mechanisms

The curriculum prevents conceptual gaps through three layers of automation that verify artifact existence before execution.

### Pre-Flight Verification with verify.py

Every lesson ships a [`verify.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/verify.py) script located at `phases/<phase-number>-<name>/<lesson>/code/verify.py`. These scripts validate:

- Presence of required files from previous phases
- Environment variables and Python version compatibility
- Previous-phase output artifacts (model weights, configuration files)

For example, the Phase 0 verification script checks for Git installation and Python 3.11+ before permitting progression. Attempting to run Phase 7's self-attention code without Phase 3's neural network foundation causes the verification to fail with a prerequisite error.

### Skill-Driven Tutor and Placement Logic

The `start-learning` skill implements an intelligent placement quiz that records your optimal starting phase in [`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md). When you invoke the `learn` command, the system:

1. Reads your current phase from [`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md)
2. Validates prerequisite completion via [`verify.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/verify.py)
3. Increments to the next lesson only upon successful verification

This prevents accidental skipping while allowing informed jumps (e.g., starting at Phase 1 if you know Python) through explicit `--route intermediate` flags passed to verification scripts.

### Roadmap Validation and CI Consistency

The [`ROADMAP.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ROADMAP.md) file maintains the canonical status of each phase and lesson. Continuous integration checks validate that phase links in [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) remain consistent with the Mermaid dependency diagram and that all [`verify.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/verify.py) scripts reference existing prerequisite paths.

## Navigating the Curriculum: Code Examples

Accessing the curriculum requires interacting with the verification and skill systems through specific CLI patterns.

To initialize the curriculum and determine your starting phase:

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

```

The `start-learning` skill stores your placement in [`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md) and triggers the appropriate `learn` command sequence.

To verify Phase 0 completion manually:

```bash
python3 phases/00-setup-and-tooling/01-dev-environment/code/verify.py --route beginner

```

This script validates Git, Python 3.11+, and environment configuration before emitting a completion token.

To jump to a later phase with existing prerequisites (e.g., Phase 7):

```bash
python3 phases/07-transformers-deep-dive/02-self-attention-from-scratch/code/verify.py --route intermediate

```

The verification succeeds only if the core neural network code from Phase 3 exists in your artifact directory.

## Critical File Paths Controlling Progression

Understanding these files helps debug progression issues:

- **[`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md)** (root): Contains the Mermaid diagram defining the linear and branching dependencies between all 20 phases.
- **[`ROADMAP.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ROADMAP.md)**: Tracks completion status for each phase and drives CI validation of curriculum integrity.
- **[`skills/start-learning/SKILL.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/skills/start-learning/SKILL.md)**: Implements the placement quiz logic and phase-selection algorithms.
- **[`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md)**: Records your personal progress state and optimal starting phase.
- **[`phases/00-setup-and-tooling/01-dev-environment/code/verify.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/00-setup-and-tooling/01-dev-environment/code/verify.py)**: Template for all verification scripts; checks environment readiness.
- **[`phases/19-capstone-projects/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/README.md)**: Defines integration requirements for the final phase, consuming artifacts from Phases 3, 10, 13, and 14.

## Summary

- The **multi-phase progression system** comprises 20 strictly sequential phases (0–19) forming a linear dependency chain.
- **Phase 0** establishes environment prerequisites, while **Phase 19** requires integration of all prior artifacts into production systems.
- **Pre-flight verification** via [`verify.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/verify.py) scripts enforces prerequisites by checking for files and outputs from previous phases.
- The **`start-learning`** skill and **[`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md)** file enable personalized entry points while preventing accidental skipping.
- Early phases (0–3) produce foundational artifacts (optimizers, autograd engines) consumed by later phases (10–14) through explicit import dependencies.
- **Phase 13 (MCP)** and **Phase 14 (Agents)** serve as critical bridges between model training (Phase 10) and autonomous system deployment (Phase 19).

## Frequently Asked Questions

### What happens if I try to skip a phase without completing prerequisites?

The [`verify.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/verify.py) script for your target phase will fail with a prerequisite error. For example, attempting to run Phase 7's transformer code without Phase 3's neural network implementation causes the verification to detect missing autograd artifacts in your directory and halt execution until you complete the foundational phase.

### How does the curriculum handle students with existing AI knowledge?

The **`start-learning`** skill administers a placement quiz that records an alternative entry point in [`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md). While you can start at Phase 1 (skipping environment setup) or Phase 4 (skipping foundations), you must still possess the artifacts from skipped phases. You can validate existing knowledge by running verification scripts with the `--route intermediate` flag, which checks for equivalent prior work without requiring you to re-execute lessons.

### What is the Model-Context-Protocol (MCP) introduced in Phase 13?

**Phase 13 — Tools & Protocols** teaches the Model-Context-Protocol, a specification for exposing tools and resources to AI systems. You will build MCP server implementations that standardize how agents from Phase 14 access external APIs and data sources, replacing ad-hoc function calling with a structured interoperability layer.

### How does Phase 19 differ from earlier project-based phases?

**Phase 19 — Capstone Projects** uniquely requires the integration of artifacts spanning the entire curriculum: custom optimizers from Phase 3, transformer weights from Phase 10, MCP servers from Phase 13, and agent orchestration logic from Phase 14. Unlike isolated projects in Phases 4–6, the capstone mandates building end-to-end autonomous systems using your own tooling stack rather than external frameworks.