What Makes the AI Engineering from Scratch Curriculum Different from Other AI Courses

The AI Engineering from Scratch curriculum stands apart by enforcing a 20-phase, build-it-first learning path where you implement algorithms from raw math before touching frameworks, ships every lesson as a reusable artifact, and teaches across Python, TypeScript, Rust, and Julia.

The rohitg00/ai-engineering-from-scratch repository treats AI education as an engineering product rather than a passive video syllabus. As implemented in rohitg00/ai-engineering-from-scratch, this MIT-licensed, open-source curriculum organizes knowledge into atomic, phase-stacked lessons that mirror how production AI systems are actually built.

Structured, Phase-Stacked Roadmap

The entire learning journey is defined in README.md as 20 sequential phases that move from environment setup and math foundations through deep learning, transformers, LLMs, agents, and production deployment. This guarantees you cannot skip prerequisite knowledge: lower-level concepts are always mastered before they are abstracted away in higher-level modules.

The repository enforces physical structure through the phases/<NN>-<phase>/<MM>-<lesson>/ naming convention. Every lesson folder contains its own docs/, code/, and outputs/ directories, keeping each teaching unit atomic and permitting focused study. This granularity is codified directly in the README under sections describing the shape of a lesson and the shape of a curriculum.

Build-It First, Use-It Second Pedagogy

Every lesson in the AI Engineering from Scratch curriculum follows a strict build-it / use-it split. You first construct the algorithm from raw mathematical primitives, then apply the same logic inside a production-grade library. This rhythm prevents the "black-box" mindset common in framework-first courses.

For example, in phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py, you implement a Vector class entirely from Python builtins:

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

from math import acos, degrees

class Vector:
    def __init__(self, components):
        self.components = list(components)

    def __add__(self, other):
        return Vector([a + b for a, b in zip(self.components, other.components)])

    def dot(self, other):
        return sum(a * b for a, b in zip(self.components, other.components))

    def magnitude(self):
        return sum(x ** 2 for x in self.components) ** 0.5

    def angle_between(self, other):
        cos_theta = self.dot(other) / (self.magnitude() * other.magnitude())
        cos_theta = max(-1.0, min(1.0, cos_theta))
        return degrees(acos(cos_theta))

if __name__ == "__main__":
    a = Vector([1, 0])
    b = Vector([0, 1])
    print("Angle:", a.angle_between(b))   # → 90.0

You can run this foundational implementation directly:

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

Only after writing the raw version do you switch to the framework equivalent. The same vector math using NumPy looks like this:

import numpy as np

a = np.array([1, 0])
b = np.array([0, 1])
angle = np.degrees(np.arccos(np.clip(
    np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)), -1, 1)))
print("Angle (NumPy):", angle)   # → 90.0

Because you wrote the dot, magnitude, and angle_between logic yourself first, you understand exactly which operations NumPy is vectorizing and where numerical clamping is necessary.

Multi-Language and Cross-Modal Exposure

The curriculum does not lock you into a single ecosystem. According to the README.md source code, lessons are implemented in Python, TypeScript, Rust, and Julia via the language column of the phase table. This forces you to focus on algorithmic thinking rather than syntax memorization.

The content arc also mirrors the historical evolution of AI systems. The roadmap moves from pure mathematics into computer vision, then natural language, then multimodal models, and finally autonomous agents. This incremental, cross-modal exposure prevents siloed understanding and prepares you for integrated, production-grade pipelines.

Agent-First, Artifact-Centric Delivery

A defining feature of the AI Engineering from Scratch curriculum is that every lesson ships something. Each lesson folder includes an outputs/ directory containing a prompt, skill, agent definition, or MCP server that can be plugged directly into real projects.

For instance, after completing a lesson you might own an artifact such as outputs/skill-agent-loop.md. These outputs transform learning material into a tangible toolbox rather than disposable notebooks.

The repository also demonstrates a meta-learning philosophy through its Claude skills. Core utilities like /find-your-level and /check-understanding are stored as structured markdown manifests under .claude/skills/…/SKILL.md. You can install the entire skill set with a single script:

python scripts/install_skills.py

After installation, running /find-your-level loads /.claude/skills/find-your-level/SKILL.md and executes a ten-question placement assessment, mapping you to the correct starting phase. This treats AI as both the subject and the medium of instruction, a loop absent in most static curricula.

Production-Grade Open Source Governance

The project is released under the MIT license, so all code, assets, and documentation are freely available without vendor lock-in. More importantly, the curriculum is maintained with the same rigor as a shipping software product.

The AGENTS.md file enforces a strict contribution workflow: one commit per lesson, conventional commit messages, and traceable change history. This guarantees that the curriculum grows like a production codebase rather than an unstructured collection of scripts.

The public-facing website at aiengineeringfromscratch.com is generated by site/build.js, which renders the Markdown source into a synced UI. This ensures that any update to the repository immediately propagates to the published learning experience.

Summary

• Phase-stacked roadmap: 20 sequential phases from math to production agents, defined in README.md, guarantee concept mastery before abstraction.
• Build-it / use-it split: Lessons like phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py force you to implement raw math before using NumPy or PyTorch.
• Multi-language support: Python, TypeScript, Rust, and Julia implementations reinforce algorithmic thinking over framework dependence.
• Artifact-centric outputs: Every lesson ships reusable prompts, skills, or MCP servers into outputs/, installable via scripts/install_skills.py.
• Production workflow: MIT licensing, AGENTS.md conventions, one-commit-per-lesson policies, and site/build.js treat the syllabus as a maintained engineering product.

Frequently Asked Questions

Does the AI Engineering from Scratch curriculum require prior machine learning experience?

No. The README.md defines a self-contained path that begins with environment setup and math foundations. The /find-your-level skill in .claude/skills/find-your-level/SKILL.md further assists newcomers by asking ten placement questions and recommending an appropriate starting phase, ensuring you enter the pipeline at the correct depth.

What programming languages does the AI Engineering from Scratch curriculum teach?

The curriculum implements concepts across Python, TypeScript, Rust, and Julia, as shown in the language column of the phase table. You are encouraged to study the same algorithm in multiple languages, which decouples your understanding from any single framework or runtime.

How does the build-it-first approach improve learning compared to using frameworks immediately?

By writing classes like Vector in phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py before importing NumPy, you see every scalar operation that a library later hides. This demystifies backpropagation, attention mechanisms, and autograd because you have already implemented the underlying linear algebra, vector calculus, or probability primitives by hand.

Can the lesson artifacts be reused outside of the course?

Yes. Every lesson produces a tangible output—such as a prompt template, a Claude skill, or an MCP server—inside its outputs/ folder. Running python scripts/install_skills.py copies these artifacts into your local environment, allowing you to import them directly into production projects or personal AI workflows without rewriting anything.

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