What Makes the AI Engineering from Scratch Curriculum Different from Standard AI/ML Courses

The AI Engineering from Scratch curriculum distinguishes itself through a rigorous "Build-It / Use-It" pedagogy spanning 20 phases and 503 lessons, delivering production-ready artifacts in four languages while requiring only standard libraries.

The rohitg00/ai-engineering-from-scratch repository redefines how engineers master artificial intelligence by treating the curriculum itself as a production codebase. Unlike conventional courses that rely on isolated notebooks or theoretical lectures, this open-source curriculum provides an end-to-end learning spine that transforms mathematical foundations into deployable tools. The AI Engineering from Scratch curriculum enforces strict structural standards across every lesson, ensuring that learners build both conceptual understanding and practical implementation skills simultaneously.

Build-It / Use-It Pedagogy

The curriculum employs a Build-It / Use-It split that enforces deep algorithmic understanding before introducing framework abstractions. Every lesson first implements the algorithm from raw mathematics (Build-It) and then executes the same logic through a production library (Use-It). This approach ensures you understand both the underlying theory and the framework behavior, as documented in README.md at lines 99-102.

Four-Language, Standard-Library-First Policy

Lessons are delivered in Python, TypeScript, Rust, and Julia, adhering to a strict standard-library-first policy defined in AGENTS.md (lines 35-43). This constraint keeps the focus on algorithmic thinking rather than API memorization, allowing learners to see how core concepts translate across language paradigms. The policy permits only a tiny allow-list of scientific dependencies, ensuring that all code remains portable and compiles without complex environment management.

Production-Ready Artifact Generation

Each lesson ships a reusable artifact—whether a prompt, skill, agent, or MCP server—that can be installed and used directly via scripts/install_skills.py. By the end of the curriculum, you possess a portfolio of 503 ready-to-plug-in tools stored in each lesson's outputs/ directory, as detailed in README.md (lines 61-66). This design transforms educational code into production infrastructure, bridging the gap between learning and shipping.

Progressive 20-Phase Architecture

The curriculum follows a strict prerequisite graph across 20 phases, from linear algebra and probability through transformers, LLMs, and multimodal agents. Lower phases serve as foundations for higher phases, with the dependency structure visualized in the README's mermaid diagram (lines 57-80). Later phases (13 and 14) specifically cover Model-Context Protocol (MCP), tool-calling, security, observability, and deployment patterns (lines 106-135), mirroring the complete workflow of a professional AI engineer.

Uniform Lesson Structure and Validation

Every lesson follows a predictable layout containing code/, docs/en.md, and outputs/ directories, making navigation and versioning trivial, as specified in README.md (lines 87-95). The repository includes scripts/audit_lessons.py, a CI utility that enforces uniform structure, validates that each lesson contains at least five unit tests in code/tests/, and verifies quiz.json schema compliance. This ensures that all 503 lessons maintain consistent quality and test coverage without hidden binaries or paid cloud dependencies.

Running Lessons and Installing Skills

The repository provides executable scripts to interact with the curriculum directly.

Run a single lesson to verify your local environment:

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

Install all generated skills into your local skill store:

python scripts/install_skills.py

Use the built-in lesson runner to execute any lesson's entry point and display test results:

python scripts/lesson_run.py 03-deep-learning-core/05-loss-functions

Execute an end-to-end agent loop from Phase 14:

python phases/14-agent-engineering/01-the-agent-loop/code/agent_loop.py

Summary

• Dual implementation approach: Every concept is built from scratch then implemented via production frameworks.
• Multi-language support: Algorithms implemented in Python, TypeScript, Rust, and Julia using only standard libraries.
• Portable artifacts: 503 lessons generate installable prompts, skills, and MCP servers via scripts/install_skills.py.
• Rigorous structure: Uniform lesson layout with automated auditing via scripts/audit_lessons.py ensures quality.
• Production scope: Coverage of MCP, observability, and deployment patterns in later phases prepares engineers for real-world systems.

Frequently Asked Questions

Do I need prior AI/ML experience to start the AI Engineering from Scratch curriculum?

No prior experience is required, though the curriculum discourages skipping phases. The 20-phase structure builds progressively from linear algebra and probability through advanced topics, ensuring that each concept rests on a solid mathematical foundation established in previous lessons.

Why does the curriculum implement algorithms in four different programming languages?

The four-language approach forces learners to focus on algorithmic logic rather than framework-specific APIs. By restricting implementations to standard libraries as defined in AGENTS.md, the curriculum ensures that skills transfer across technology stacks and that code remains portable across environments.

How does the "Build-It / Use-It" methodology improve learning outcomes compared to traditional courses?

The Build-It / Use-It split requires implementing algorithms from raw mathematics before using production libraries. This dual approach ensures that learners understand the theoretical foundations governing framework behavior, preventing the "black box" problem common in courses that only teach high-level API calls.

What production technologies does the curriculum cover beyond basic machine learning?

Phases 13 and 14 cover Model-Context Protocol (MCP), tool-calling architectures, security hardening, observability patterns, and deployment strategies. These topics transform the curriculum from an educational resource into a production pipeline, providing the infrastructure knowledge required to ship AI systems in production environments.

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