# How the AI Engineering Curriculum Ensures Understanding Beyond Framework Usage

> Master AI algorithms from scratch with rohitg00/ai-engineering-from-scratch. Our curriculum builds understanding beyond frameworks by enforcing first principles implementation before high-level tool usage.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: deep-dive
- Published: 2026-08-27

---

**The curriculum enforces a strict Build-It / Use-It architecture that requires learners to implement core AI algorithms from first principles using only standard libraries before ever touching high-level frameworks like PyTorch.**

The `rohitg00/ai-engineering-from-scratch` repository is a comprehensive 511-lesson curriculum spanning 20 phases, explicitly designed to cultivate **understanding beyond framework usage**. Unlike conventional tutorials that begin with library imports, this program forces students to derive mathematical foundations and build minimal, dependency-free implementations before comparing their work to production frameworks. This methodology ensures learners internalize *why* frameworks behave a certain way, not merely *how* to call their APIs.

## The Build-It / Use-It Pedagogical Architecture

At the heart of the curriculum lies a rigid six-beat lesson flow defined in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) and visualized in [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md): **MOTTO → PROBLEM → CONCEPT → BUILD IT → USE IT → SHIP IT**. This structure legally separates the implementation phase from the library consumption phase, ensuring that **understanding beyond framework usage** is not optional but mandatory. Learners must first construct algorithms using nothing but the language's standard library, manually managing computational graphs, gradient flow, and memory allocation that production frameworks typically abstract away.

### Deriving Mathematics Before Code

Each lesson begins with a *Concept* section that requires learners to derive the underlying mathematics themselves. For example, in the backpropagation lesson located at [`phases/03-deep-learning-core/03-backpropagation/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/03-deep-learning-core/03-backpropagation/docs/en.md), students manually work through the chain rule and partial derivatives before writing a single line of executable code. This theoretical foundation prevents the "copy-paste" antipattern and establishes the mental models necessary for debugging complex neural networks when automatic differentiation fails silently in production systems.

## Concrete Implementation: Backpropagation from Scratch

The curriculum demonstrates its philosophy through explicit, runnable contrasts. In [`phases/03-deep-learning-core/03-backpropagation/code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/03-deep-learning-core/03-backpropagation/code/main.py), learners first construct a minimal autograd engine using pure Python:

```python

# ---- Build It: Minimal autograd engine (pure Python) ----

class Value:
    def __init__(self, data, children=(), op=''):
        self.data = data
        self.grad = 0.0
        self._backward = lambda: None
        self._children = set(children)
        self._op = op

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), '+')
        def _backward():
            self.grad += out.grad
            other.grad += out.grad
        out._backward = _backward
        return out

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data * other.data, (self, other), '*')
        def _backward():
            self.grad += other.data * out.grad
            other.grad += self.data * out.grad
        out._backward = _backward
        return out

    def sigmoid(self):
        x = max(-500, min(500, self.data))
        s = 1.0 / (1.0 + math.exp(-x))
        out = Value(s, (self,), 'sigmoid')
        def _backward():
            self.grad += (s * (1 - s)) * out.grad
        out._backward = _backward
        return out

    def backward(self):
        topo, visited = [], set()
        def build(v):
            if v not in visited:
                visited.add(v)
                for child in v._children:
                    build(child)
                topo.append(v)
        build(self)
        self.grad = 1.0
        for v in reversed(topo):
            v._backward()

```

Only after implementing the topological sort and manual gradient accumulation in the `backward()` method does the learner proceed to the *Use It* phase. Here, they implement the identical computation using PyTorch:

```python

# ---- Use It: Same computation with PyTorch ----

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(2, 4),
    nn.Sigmoid(),
    nn.Linear(4, 1),
    nn.Sigmoid()
)
optimizer = torch.optim.SGD(model.parameters(), lr=1.0)
criterion = nn.MSELoss()

pred = model(torch.tensor([[0.,1.]]))
loss = criterion(pred, torch.tensor([[1.]]))
optimizer.zero_grad()
loss.backward()
optimizer.step()

```

### Mapping Manual Gradients to Framework Abstractions

The contrast between these implementations is explicit and educational. The hand-crafted `Value` class stores gradients in `self.grad` with custom `_backward` closures, while PyTorch hides this machinery behind `loss.backward()`. By handwriting the topological sort algorithm that orders node visits during backpropagation, learners see exactly what PyTorch's autograd engine automates. This side-by-side comparison in [`phases/03-deep-learning-core/03-backpropagation/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/03-deep-learning-core/03-backpropagation/docs/en.md) cements **understanding beyond framework usage** by revealing the graph traversal that high-level libraries perform invisibly.

## Enforcement Mechanisms That Guarantee Depth

The repository structure enforces rigor through strict rules documented in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md). The **one-commit-per-lesson** policy prevents partial or borrowed solutions, while the prohibition against hidden code ensures every tensor operation remains visible and auditable. During the *Build It* phase, learners cannot import NumPy, PyTorch, or TensorFlow; they must implement matrix multiplication, activation functions, and optimizers using pure Python data structures. These constraints guarantee that when students finally reach the *Use It* phase, they comprehend the computational graph traversing and gradient accumulation that `torch.optim.SGD` abstracts.

### Shipping Reusable Artifacts

Every lesson culminates in a *Ship It* phase requiring learners to produce tangible deliverables such as prompts, skills, agents, or MCP servers. For instance, the file [`phases/03-deep-learning-core/03-backpropagation/outputs/prompt-gradient-debugger.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/03-deep-learning-core/03-backpropagation/outputs/prompt-gradient-debugger.md) serves as a reusable debugging artifact that graduates can deploy in production workflows. This requirement proves the learner can translate theoretical **understanding beyond framework usage** into practical engineering tools that solve real problems.

## Summary

- The **Build-It / Use-It** split forces implementation from first principles using only standard libraries before introducing frameworks like PyTorch.
- The six-beat lesson structure (**MOTTO → PROBLEM → CONCEPT → BUILD IT → USE IT → SHIP IT**) is enforced across 20 phases and 511 lessons via [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md).
- Strict repository rules (one-commit-per-lesson, no hidden code, original implementations) prevent shortcuts that bypass algorithmic comprehension.
- Concrete implementations like the `Value` autograd engine in [`phases/03-deep-learning-core/03-backpropagation/code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/03-deep-learning-core/03-backpropagation/code/main.py) demonstrate exactly what frameworks abstract away.
- Reusable artifacts such as [`prompt-gradient-debugger.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/prompt-gradient-debugger.md) prove learners can operationalize theory into production-ready engineering assets.

## Frequently Asked Questions

### What is the six-beat lesson structure in this curriculum?

The six-beat flow consists of **MOTTO → PROBLEM → CONCEPT → BUILD IT → USE IT → SHIP IT**. This pattern appears in every lesson across all 20 phases, ensuring consistent **understanding beyond framework usage** by separating theoretical derivation, manual implementation, and library application into distinct, mandatory cognitive steps.

### Why must learners build algorithms before using PyTorch?

By implementing algorithms like backpropagation with pure Python standard libraries first, students construct a concrete mental model of gradient flow, computational graphs, and tensor operations. When they later use PyTorch in the *Use It* phase, they understand the internal mechanics that `torch.autograd` automates, enabling them to debug convergence failures and optimize memory usage rather than simply invoking high-level APIs.

### How does the repository enforce original implementations?

The [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) file acts as an operating manual that mandates one-commit-per-lesson, strictly prohibits hidden code, and bans external dependencies during the *Build It* phase. These rules ensure learners cannot copy-paste solutions from Stack Overflow or rely on framework shortcuts, forcing genuine comprehension of underlying mathematics and algorithmic flow.

### What artifacts demonstrate mastery in this curriculum?

Each lesson ends with a *Ship It* phase requiring learners to produce deployable assets. For example, [`phases/03-deep-learning-core/03-backpropagation/outputs/prompt-gradient-debugger.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/03-deep-learning-core/03-backpropagation/outputs/prompt-gradient-debugger.md) is a reusable debugging prompt that graduates can integrate into AI workflows. These deliverables serve as proof that the learner has converted theoretical **understanding beyond framework usage** into practical engineering capability.