How the AI Engineering from Scratch Curriculum Is Structured: Complete 2025 Guide

The AI Engineering from Scratch curriculum is organized as a hierarchical stack of 20 phases containing 511 lessons, each following a five-step "build-it-then-use-it" methodology with three customizable entry points and optional certification tracks.

The rohitg00/ai-engineering-from-scratch repository provides a comprehensive, production-focused learning path that takes practitioners from low-level mathematics to deployed AI systems. According to the source code, this curriculum uses a strict folder hierarchy in phases/ and consistent lesson beats to ensure repeatable learning outcomes across all artifacts.

The 20-Phase Architecture

The curriculum's backbone consists of 20 sequential phases that function as broad topical blocks stacking logically upon one another. As visualized in the Mermaid diagram at README.md lines 78-99, these phases begin with environment setup and math foundations, progress through model engineering and agent systems, and culminate in production deployment.

Phase Organization and Dependencies

Each phase follows a zero-padded naming convention under phases/<NN>-<phase-name>/, creating strict dependency chains that explain why higher-level concepts work. The repository structure includes:

• phases/00-setup-and-tooling/ — Environment configuration and tooling
• phases/01-math-foundations/ — Linear algebra and mathematical prerequisites
• phases/14-agent-engineering/ — Core agent construction patterns
• phases/19-capstone-projects/ — End-to-end system integration

This design allows learners to skip ahead if they master lower layers, while preserving the logical dependencies required for advanced topics.

Phase 19: The Capstone Integration

Phase 19 (phases/19-capstone-projects/) aggregates projects that combine earlier artifacts—prompts, skills, agents, and MCP servers—into cohesive end-to-end systems. Unlike standard lessons, these projects require synthesizing knowledge from multiple previous phases, validating production readiness according to the source documentation at lines 72-77.

Lesson Structure and The Five Beats

Within each phase, individual lessons follow a rigid organizational pattern documented at README.md lines 110-118. The repository contains 511 total lessons, each designed as a self-contained unit producing reusable artifacts.

Consistent Folder Layout

Every lesson directory uses a standardized three-folder layout at phases/<NN>-<phase-name>/<NN>-<lesson-name>/:

• code/ — Runnable implementations in up to four languages
• docs/ — Narrative content including en.md files
• outputs/ — Generated artifacts, prompts, skills, agents, or MCP servers

This predictable structure ensures that learners can navigate any of the 511 lessons without orientation overhead.

The MOTTO to SHIP IT Learning Loop

According to README.md lines 124-132, each lesson implements five specific beats:

1. MOTTO — The guiding principle or core concept
2. PROBLEM — The specific challenge being addressed
3. CONCEPT — Theoretical foundations and explanations
4. BUILD IT — Hands-on implementation phase
5. USE IT — Practical application and testing
6. SHIP IT — Production deployment and artifact generation

This methodology creates a "build-it-then-use-it" learning loop that ensures concepts translate immediately to working code.

Three Entry Points and Learning Paths

The curriculum supports personalized onboarding through three distinct entry points defined in the skills/ directory, bypassing linear progression for learners with existing expertise.

Placement Tutor (start-learning)

Located in skills/start-learning/SKILL.md, the placement tutor generates a personalized LEARNING.md file. This skill assesses prior knowledge and recommends the appropriate phase slice, allowing practitioners to skip foundational material they already master.

# Install and run the placement tutor (requires npx and skill-capable host)

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

MCP and Agent-Skills Paths

Alternative entry points target specific architectural patterns while respecting phase dependencies:

• MCP Path: Defined in skills/learn-mcp/SKILL.md, generates MCP-LEARNING.md and focuses on Model-Context-Protocol fundamentals (covered in Phase 13, phases/13-tools-and-protocols/)
• Agent-Skills Path: Defined in skills/learn-agent-skills/SKILL.md, creates AGENT-SKILLS-LEARNING.md for immediate agent construction

These paths optimize the sequence for specific career outcomes without breaking prerequisite chains.

Certification Tracks

The repository includes parallel certification pathways under certifications/claude/README.md. These tracks map subsets of the 511 lessons and diagnostics to official Claude exam objectives while utilizing the same lesson infrastructure and folder layouts described in lines 74-82 of the main documentation.

Practical Navigation Examples

To interact with the curriculum structure directly:

# Clone and run a Phase 1 linear algebra 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

# Execute an MCP lab from Phase 13

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

Summary

• The AI Engineering from Scratch curriculum organizes content into 20 phases and 511 lessons with strict dependency chains visualized in README.md
• Each lesson follows a five-beat methodology (MOTTO → PROBLEM → CONCEPT → BUILD IT → USE IT → SHIP IT) ensuring hands-on learning
• Three entry points (placement tutor, MCP path, agent-skills path) generate personalized learning files (LEARNING.md, MCP-LEARNING.md, AGENT-SKILLS-LEARNING.md) while respecting phase prerequisites
• Phase 19 contains capstone projects integrating prompts, skills, agents, and MCP servers into production systems
• Certification tracks under certifications/claude/ map lesson subsets to official exam objectives using identical infrastructure

Frequently Asked Questions

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

The curriculum contains 511 total lessons distributed across 20 phases, as documented in README.md at lines 110-118. Each lesson includes runnable code in up to four languages, narrative documentation, and reusable artifacts.

What is the difference between phases and lessons in the curriculum?

Phases are broad topical blocks (20 total) that function as organizational containers following the phases/<NN>-<phase-name>/ pattern, while lessons are individual learning units (511 total) containing specific implementations in subdirectories like phases/01-math-foundations/01-linear-algebra-intuition/.

Can I skip phases if I already know the material?

Yes. The curriculum supports adaptive entry points through the start-learning placement tutor skill, which generates a LEARNING.md file recommending your optimal starting point. While you can skip ahead, the phase dependencies are designed to ensure you understand why higher-level concepts work, not just how to implement them.

What are the five beats in each lesson?

Every lesson follows the sequence: MOTTO (guiding principle), PROBLEM (specific challenge), CONCEPT (theory), BUILD IT (implementation), USE IT (application), and SHIP IT (deployment). This structure, visible in README.md lines 124-132, ensures a "build-it-then-use-it" learning loop that bridges theory and production code.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}