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

The AI Engineering from Scratch curriculum is organized into 20 progressive phases containing 511 lessons, each following a consistent five-beat learning loop (MOTTO → PROBLEM → CONCEPT → BUILD IT → USE IT → SHIP IT) that produces reusable artifacts like prompts, skills, agents, and MCP servers.

The rohitg00/ai-engineering-from-scratch repository implements a comprehensive, hierarchical learning system designed to guide learners from foundational mathematics to production-ready AI engineering. Understanding the curriculum structure helps you navigate the 511 lessons efficiently, whether you follow the standard progressive path or enter through specialized tracks like the Model-Context-Protocol (MCP) or Agent-Skills paths.

The Hierarchical Architecture: 20 Phases and 511 Lessons

The curriculum stacks 20 phases sequentially, starting with tooling and math foundations and culminating in capstone projects. Each phase acts as a broad topical block containing numbered lessons that build logical dependencies while allowing learners to skip ahead if they master lower layers.

Phase Organization

In README.md (lines 78-99), the phase map visualizes this progression using a Mermaid diagram. Phases range from 00-setup-and-tooling through 19-capstone-projects, with intermediate blocks covering 01-math-foundations, 14-agent-engineering, and 13-tools-and-protocols. The directory structure follows the pattern:

phases/<NN>-<phase-name>/

For example, linear algebra fundamentals reside in phases/01-math-foundations/01-linear-algebra-intuition/, while MCP fundamentals appear in phases/13-tools-and-protocols/06-mcp-fundamentals/.

Lesson Folder Structure

Each of the 511 lessons follows a rigid three-folder layout (lines 110-118 in README.md):

• code/ – Runnable implementations in up to four languages
• docs/ – The narrative content (en.md files explaining concepts)
• outputs/ – Generated artifacts and results

Every lesson produces a reusable artifact—either a prompt, skill, agent, or MCP server—that you can deploy in production systems.

The Five-Beat Learning Loop in Every Lesson

Individual lessons in the AI Engineering from Scratch curriculum do not rely on passive reading. Instead, they enforce a "build-it-then-use-it" methodology through five distinct beats documented in README.md (lines 124-132):

1. MOTTO – The guiding principle or core insight
2. PROBLEM – The specific challenge or use case addressed
3. CONCEPT – The theoretical foundation required
4. BUILD IT – Hands-on implementation of the solution
5. USE IT – Practical application of what you built
6. SHIP IT – Deployment and production considerations

This structure ensures that every lesson produces a tangible artifact rather than abstract knowledge.

Three Entry Points: Personalized Learning Paths

The repository offers three distinct entry points to accommodate different learning backgrounds, as defined in the skills/ directory (lines 64-71, 122-133).

The Placement Tutor (start-learning)

Run the placement tutor to generate a personalized LEARNING.md file that maps your existing skills to the optimal starting phase:

# Add the skill using npx (requires a skill-capable host)

npx skills add rohitg00/ai-engineering-from-scratch

# Invoke the tutor

learn start-learning

The skill definition resides in skills/start-learning/SKILL.md.

The MCP Learning Path

For engineers focused on Model-Context-Protocol implementation, the MCP path generates MCP-LEARNING.md and guides you through relevant phases in phases/13-tools-and-protocols/:

learn learn-mcp

Configuration exists in skills/learn-mcp/SKILL.md.

The Agent-Skills Path

Targeting autonomous agent development, this path creates AGENT-SKILLS-LEARNING.md and prioritizes phases/14-agent-engineering/ and related agent-building content:

learn learn-agent-skills

Defined in skills/learn-agent-skills/SKILL.md.

Capstone Projects and Certification Tracks

Phase 19: Integration and Production

Phase 19 (phases/19-capstone-projects/) aggregates end-to-end projects that combine artifacts from earlier phases—prompts, skills, agents, and MCP servers—into production-ready systems (lines 72-77). This phase validates your ability to integrate disparate components into cohesive AI engineering solutions.

Claude Certification Alignment

The certifications/claude/ directory contains tracks that map specific subsets of lessons and diagnostics to official Claude certification exam objectives. These tracks reuse the same lesson infrastructure (code/, docs/, outputs/) but filter the 511 lessons to those relevant for certification prep (lines 74-82).

Navigating the Repository

To begin exploring the curriculum structure locally, clone the repository and run a sample lesson:

# Clone the curriculum

git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch

# Run Phase 1, Lesson 1: Linear Algebra Intuition

python3 phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

To experiment with MCP fundamentals:

# Run the MCP lab from Phase 13

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

Key structural files to bookmark:

• README.md – High-level overview, phase map, and lesson table of contents
• phases/00-setup-and-tooling/README.md – Environment setup and tooling verification
• phases/14-agent-engineering/README.md – Core agent construction methodologies
• certifications/claude/README.md – Certification track onboarding

Summary

• The AI Engineering from Scratch curriculum organizes content into 20 phases and 511 lessons with strict folder conventions (code/, docs/, outputs/).
• Every lesson follows a six-step beat structure (MOTTO → PROBLEM → CONCEPT → BUILD IT → USE IT → SHIP IT) ensuring practical artifact creation.
• Learners enter via three personalized paths: the placement tutor (start-learning), the MCP protocol track, or the Agent-Skills track, each generating specific learning map files.
• Phase 19 contains capstone projects integrating earlier artifacts, while the certifications/claude/ directory provides exam-aligned lesson subsets.
• The repository structure allows skipping lower phases if you have prerequisite knowledge, while preserving logical dependencies that explain advanced concepts.

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 resides in a folder following the pattern phases/<NN>-<phase-name>/<NN>-<lesson-name>/ and includes code implementations, narrative documentation, and output artifacts.

What are the three learning paths available in the repository?

The repository offers entry through the placement tutor (start-learning skill), which diagnoses your level and creates a LEARNING.md file; the MCP path (learn-mcp), targeting Model-Context-Protocol development; and the Agent-Skills path (learn-agent-skills), focusing on autonomous agent construction. Each path filters the 511 lessons to relevant subsets.

What is the "five-beat" structure mentioned in the lessons?

The five-beat structure refers to the pedagogical sequence in every lesson: MOTTO (guiding principle), PROBLEM (challenge definition), CONCEPT (theory), BUILD IT (implementation), USE IT (application), and SHIP IT (deployment). This ensures learners produce production-ready artifacts rather than just theoretical knowledge.

Where are the capstone projects located?

Capstone projects reside in phases/19-capstone-projects/. This phase aggregates end-to-end systems that combine prompts, skills, agents, and MCP servers built in earlier phases, serving as the integration layer before certification or production deployment.

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