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

> Explore the AI Engineering from Scratch curriculum's unique 20-phase approach. Learn by building algorithms from math before frameworks across Python, TypeScript, Rust, and Julia.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: architecture
- Published: 2026-06-07

---

**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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py), you implement a `Vector` class entirely from Python builtins:

```python

# 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:

```bash
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:

```python
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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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:

```bash
python scripts/install_skills.py

```

After installation, running `/find-your-level` loads [`/.claude/skills/find-your-level/SKILL.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main//.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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py).
- **Production workflow**: MIT licensing, [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) conventions, one-commit-per-lesson policies, and [`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/.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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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.