How AI Engineering from Scratch Differs from Traditional ML Courses: A Build-First Approach

The AI Engineering from Scratch curriculum replaces passive tutorial consumption with end-to-end construction, requiring learners to build every algorithm by hand before touching a production library.

Unlike conventional machine learning courses that treat AI as a collection of isolated papers and API wrappers, the rohitg00/ai-engineering-from-scratch repository structures 503 lessons into a single, coherent spine where you engineer every component yourself. This approach produces importable, production-grade artifacts rather than notebook exercises, fundamentally shifting the learner from consumer to builder.

Build-First Pedagogy vs. Tutorial Consumption

Traditional ML courses typically demonstrate a concept, then ask you to call sklearn.fit() or torch.nn.Module. In AI Engineering from Scratch, you implement the raw mathematics first, encounter the failure modes, and only then compare your implementation against battle-tested libraries.

End-to-End Artifact Construction

Every lesson culminates in a runnable artifact—whether a prompt, skill, agent, or MCP server—that you build before you ever import an existing library. As stated in the README.md at lines 25-26, the curriculum demands that you "don’t just learn AI. You build it. End‑to‑end. By hand". This means you are not following a video tutorial; you are writing the code that becomes the tutorial.

No Hand-Holding, No Copy-Paste

The repository explicitly rejects five-minute videos and ready-made notebooks. You are expected to run the code yourself, read the underlying math, and debug the failure modes. This design, documented in README.md lines 31-40, cultivates engineering intuition by forcing you to understand why a tensor operation fails rather than simply importing a working solution.

The "Build It / Use It" Learning Loop

The curriculum enforces a strict two-phase cycle for every concept: first derive the raw math with pure Python, then re-implement with production frameworks like PyTorch or JAX.

Raw Implementation First

In the "Build It" phase, you write the algorithm from scratch using only standard libraries. For example, in phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py, you construct vector operations manually to grasp the computational geometry before ever calling numpy.dot().

Production Library Integration

The "Use It" phase follows immediately after. You re-implement the same functionality using industry-standard libraries, making the underlying mechanics of frameworks explicit. This cycle, described in README.md lines 38-41, ensures you understand the abstraction layer you are relying on rather than treating PyTorch as a black box.

Unified 20-Phase Curriculum Architecture

Where traditional courses offer disconnected modules, this curriculum stitches 503 lessons into a unified roadmap spanning 20 phases, from linear algebra intuition to multimodal agent systems.

Single Spine Structure

The README.md at lines 57-66 visualizes the curriculum as a single stack rather than a loose set of topics. Lower-level mathematics in phases/01-math-foundations/ underpins higher-level agents in later phases, creating a dependency graph where each lesson builds upon the previous. This coherence prevents the "tutorial hell" of jumping between unrelated videos.

Reusable Skill Artifacts

Each lesson outputs a real, importable tool stored in lesson-specific outputs/ directories. For instance, phases/01-math-foundations/01-linear-algebra-intuition/outputs/skill-perceptron.md is not documentation—it is a shipped artifact you can drop into any AI assistant framework. This contrasts sharply with traditional courses that terminate with a "congratulations, you learned X" message.

From Lesson to Production: Real Code Examples

The repository provides executable workflows that demonstrate the build-first philosophy. Here are the commands to validate the approach from the repository root:

Clone the repository and run a foundational lesson:

git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch
python phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

Install generated skills as importable Python modules:

python3 scripts/install_skills.py

# After installation, import directly in your projects:

# from skills import agent_loop

Run the full lesson pipeline for a computer vision module:

cd phases/04-computer-vision/14-vision-transformers
python code/main.py          # Builds the ViT from scratch

python -m unittest discover  # Runs lesson-specific tests

cat outputs/skill-vit-patch-and-pos-embed-inspector.md   # Displays the shipped artifact

Summary

• AI Engineering from Scratch treats AI as a single coherent spine you construct piece-by-piece, not a collection of disconnected tutorials.
• The "Build It / Use It" loop mandates raw implementation before library usage, making framework mechanics explicit.
• Every lesson produces production-grade artifacts (e.g., skill-perceptron.md) that are importable into real systems, not just notebook outputs.
• The 20-phase structure spans 503 lessons with strict dependencies, ensuring mathematical foundations support advanced agent architectures.
• The no hand-holding policy requires you to debug failure modes and understand mathematical underpinnings, building engineering intuition rather than API familiarity.

Frequently Asked Questions

What is the "Build It / Use It" loop in AI Engineering from Scratch?

The "Build It / Use It" loop is a pedagogical cycle where you first implement an algorithm from scratch using pure Python and mathematics, then re-implement it using production libraries like PyTorch or JAX. This approach, documented in README.md lines 38-41, ensures you understand the underlying mechanics before relying on high-level abstractions.

How are the curriculum phases structured?

The curriculum organizes 503 lessons into 20 sequential phases that function as a single dependency stack. Lower-level phases in phases/01-math-foundations/ provide the mathematical primitives required by higher-level phases covering computer vision and agent systems, creating a coherent learning path rather than isolated modules.

What kind of artifacts does each lesson produce?

Each lesson generates a reusable skill artifact stored in the lesson's outputs/ directory. These are not just notes but importable tools (e.g., skill-vit-patch-and-pos-embed-inspector.md) that can be integrated into AI assistants or agent frameworks using the scripts/install_skills.py utility.

Is this curriculum suitable for beginners without a math background?

The curriculum is designed for learners willing to engage with mathematical fundamentals from day one, as evidenced by the phases/01-math-foundations/ structure. While it does not require advanced degrees, it demands that you "read the math" and debug raw implementations yourself, making it more intensive than high-level API tutorials.

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