AI Engineer Full-Stack Roadmap: From Math to LLMs to Agents, All Covered

There’s no shortage of AI tutorials online—but they’re all scattered: a fine-tuning post here, an agent demo there, and everywhere you look it’s “Build a RAG in 5 minutes” fast food. A coherent system that connects math → LLMs → agents is almost impossible to find.

I want to share an open-source project that fills this gap: rohitg00/ai-engineering-from-scratch. It’s a full-stack AI engineer learning path that goes from math fundamentals to LLMs to agents. 9.7k stars, completely free.

https://github.com/rohitg00/ai-engineering-from-scratch

The curriculum is laid out in 20 linear phases. Phase 0 – Tools & Environment, Phase 1 – Math Foundations… all the way to Phase 10 – Build an LLM from Scratch, Phase 14 – Agent Engineering, Phase 19 – Capstone Project. No jumping around—each layer is solid before moving up. 435 lessons, ~320 hours, 4 languages (Python / TypeScript / Rust / Julia), MIT-licensed, runs on your own laptop—no paid API needed.

Key features:

• Complete roadmap – Math → Deep Learning → Transformer → GenAI → LLM → Agent → Multi-Agent Systems, one straight line, no skipped chapters.
• Four languages – Every concept is implemented in Python, TypeScript, Rust, and Julia. You don’t stay in the Python comfort zone.
• Build it from scratch first – Each lesson starts with pure math / raw code, then validates with PyTorch. No skipping derivations to jump straight to library calls.
• Every lesson ships a reusable artifact – Not “learn and forget.” You produce prompts, skills, agents, MCP servers that go straight into your toolchain.
• Companion SkillKit – Use /find-your-level (10 questions to find which phase to start from) and /check-understanding (per-phase quiz). Works with Claude, Cursor, Codex, and other agents.

Getting started is simple: git clone then run the first lesson’s vectors.py. If you don’t want to clone, read online at http://aiengineeringfromscratch.com.

Perfect for anyone systematically building AI engineering skills, from math all the way to agents. Bookmark it.

rohitg00/ai-engineering-from-scratch

Source: https://github.com/rohitg00/ai-engineering-from-scratch

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

84% of students already use AI tools. Only 18% feel prepared to use them professionally. This curriculum closes that gap.

435 lessons. 20 phases. ~320 hours. Python, TypeScript, Rust, Julia. Every lesson ships a reusable artifact: a prompt, a skill, an agent, an MCP server. Free, open source, MIT.

You don’t just learn AI. You build it. End-to-end. By hand.

How this works

Most AI material teaches in scattered pieces. A paper here, a fine-tuning post there, a flashy agent demo somewhere else. The pieces rarely line up. You ship a chatbot but can’t explain its loss curve. You hook a function to an agent but can’t say what attention does inside the model that’s calling it.

This curriculum is the spine. 20 phases, 435 lessons, four languages: Python, TypeScript, Rust, Julia. Linear algebra at one end, autonomous swarms at the other. Every algorithm gets built from raw math first. Backprop. Tokenizer. Attention. Agent loop. By the time PyTorch shows up, you already know what it’s doing under the hood.

Each lesson runs the same loop: read the problem, derive the math, write the code, run the test, keep the artifact. No five-minute videos, no copy-paste deploys, no hand-holding.

Free, open source, and built to run on your own laptop.

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

The shape of the curriculum

Twenty phases stack on top of each other. Math is the floor. Agents and production are the roof. Skip ahead if you already know the lower layers, but don’t skip and then wonder why something at the top is breaking.

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#fafaf5','primaryTextColor':'#1a1a1a','primaryBorderColor':'#3553ff','lineColor':'#3553ff','fontFamily':'JetBrains Mono','fontSize':'12px'}}}%%
flowchart TB
    P0["Phase 0 — Setup & Tooling"] --> P1["Phase 1 — Math Foundations"]
    P1 --> P2["Phase 2 — ML Fundamentals"]
    P2 --> P3["Phase 3 — Deep Learning Core"]
    P3 --> P4["Phase 4 — Vision"]
    P3 --> P5["Phase 5 — NLP"]
    P3 --> P6["Phase 6 — Speech & Audio"]
    P3 --> P9["Phase 9 — RL"]
    P5 --> P7["Phase 7 — Transformers"]
    P7 --> P8["Phase 8 — GenAI"]
    P7 --> P10["Phase 10 — LLMs from Scratch"]
    P10 --> P11["Phase 11 — LLM Engineering"]
    P10 --> P12["Phase 12 — Multimodal"]
    P11 --> P13["Phase 13 — Tools & Protocols"]
    P13 --> P14["Phase 14 — Agent Engineering"]
    P14 --> P15["Phase 15 — Autonomous Systems"]
    P15 --> P16["Phase 16 — Multi-Agent & Swarms"]
    P14 --> P17["Phase 17 — Infrastructure & Production"]
    P15 --> P18["Phase 18 — Ethics & Alignment"]
    P16 --> P19["Phase 19 — Capstone Projects"]
    P17 --> P19
    P18 --> P19

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

The shape of a lesson

Each lesson lives in its own folder, with the same structure across the entire curriculum:

phases/<phase-num>/<lesson-num>/
├── code/               runnable implementations (Python, TypeScript, Rust, Julia)
├── docs/
│   └── en.md           lesson narrative
└── outputs/            prompts, skills, agents, or MCP servers this lesson produces

Every lesson follows six beats. The Build It / Use It split is the spine — you implement the algorithm from scratch first, then run the same thing through the production library. You understand what the framework is doing because you wrote the smaller version yourself.

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#fafaf5','primaryTextColor':'#1a1a1a','primaryBorderColor':'#3553ff','lineColor':'#3553ff','fontFamily':'JetBrains Mono','fontSize':'13px'}}}%%
flowchart LR
    M["MOTTO<br/>one-line core idea"] --> Pr["PROBLEM<br/>concrete pain"]
    Pr --> C["CONCEPT<br/>diagrams & intuition"]
    C --> B["BUILD IT<br/>raw math, no frameworks"]
    B --> U["USE IT<br/>same thing in PyTorch / sklearn"]
    U --> S["SHIP IT<br/>prompt · skill · agent · MCP"]

Getting started

Three ways in. Pick one.

Option A — read.
Open any completed lesson on aiengineeringfromscratch.com or expand a phase under Contents. No setup, no cloning.

Option B — clone and run.

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

Option C — find your level (recommended).
Skip ahead intelligently. Inside Claude, Cursor, Codex, OpenClaw, Hermes, or any agent with the curriculum skills installed:

/find-your-level

Ten questions. Maps your knowledge to a starting phase, builds a personalized path with hour estimates.

After each phase:

/check-understanding 3   # quiz yourself on phase 3
ls phases/03-deep-learning-core/05-loss-functions/outputs/
# ├── prompt-loss-function-selector.md
# └── prompt-loss-debugger.md

Prerequisites

• You can write code (any language; Python helps).
• You want to understand how AI actually works, not just call APIs.

Built-in agent skills (Claude, Cursor, Codex, OpenClaw, Hermes)

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Every lesson ships something

Other curricula end with “congratulations, you learned X.” Each lesson here ends with a reusable tool you can install or paste into your daily workflow.

Install the lot with python3 scripts/install_skills.py. Real tools, not homework. By the end of the curriculum, you have a portfolio of 435 artifacts you actually understand because you built them.

FIG_002 · A worked sample

Phase 14, lesson 1: the agent loop. ~120 lines of pure Python, no dependencies.

code/agent_loop.py build it

def run(query, tools):
    history = [user(query)]
    for step in range(MAX_STEPS):
        msg = llm(history)
        if msg.tool_calls:
            for call in msg.tool_calls:
                result = tools[call.name](**call.args)
                history.append(tool_result(call.id, result))
            continue
        return msg.content
    raise StepLimitExceeded

outputs/skill-agent-loop.md ship it

---
name: agent-loop
description: ReAct-style loop for any tool list
phase: 14
lesson: 01
---
Implement a minimal agent loop that...

outputs/prompt-debug-agent.md

You are an agent debugger. Given the trace of an agent run, identify the step where the agent went wrong and explain why...

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Contents

Twenty phases. Click any phase to expand its lesson list.

Phase 0: Setup & Tooling 12 lessons

Get your environment ready for everything that follows.

Phase 1 — Math Foundations 22 lessons

The intuition behind every AI algorithm, through code.

Phase 2 — ML Fundamentals 18 lessons

Classical ML — still the backbone of most production AI.

Phase 3 — Deep Learning Core 13 lessons

Neural networks from first principles. No frameworks until you build one.