GitHub repo turns AI theory into 435 build lessons

This repo gives you a build-first AI curriculum you can copy into your own workflow.

I've been using AI learning materials for a while now, and most of them leave me irritated. They either stop at theory, or they jump straight into a shiny demo and pretend the messy middle doesn't matter. I can watch a tokenizer explanation, sure. I can also paste a notebook cell and get a result. But when I ask myself, “Could I rebuild this from scratch tomorrow?” the answer is usually a grim little no.

That’s why rohitg00/ai-engineering-from-scratch got my attention. It doesn’t sell itself as a course with vibes. It’s a giant, opinionated curriculum that wants you to derive the math, write the code, run the test, and keep the artifact. That’s a much better deal. It’s also a bit rude in the best way: if you skip the lower layers, it basically tells you not to whine when the top breaks.

The repo frames itself around a gap that feels real: lots of students already use AI tools, but far fewer feel ready to use them professionally. The project says it closes that gap with 435 lessons, 20 phases, and about 320 hours of work. I’m not going to pretend those numbers are tiny. They’re not. But they do signal something important: this is a curriculum built like a spine, not a pile of blog posts.

What I like most is that every lesson ends with something reusable. Not “you learned the concept,” but a prompt, a skill, an agent, or an MCP server you can actually install or paste somewhere useful.

It stops pretending AI is a set of isolated tricks

“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.”

What this actually means is that the repo is trying to fix the classic self-taught AI mess: you know enough to imitate, not enough to build. I’ve hit this wall myself. I could talk about embeddings in one tab, then copy an agent loop in another, and still feel like I was stitching together strangers’ code with hope and caffeine.

This curriculum says that’s the wrong shape. It wants the pieces connected in order, so the later stuff has something to stand on. That matters because AI engineering is full of hidden dependencies. If you don’t understand gradients, backprop looks like magic. If you don’t understand tokenization, LLM behavior looks random. If you don’t understand tool calls, agents look like a slot machine with a nicer UI.

How to apply it: stop building your learning path as a bookmarks folder. Build it as a dependency graph. If a topic relies on math, do the math. If a feature relies on a smaller implementation, write the smaller implementation first. That sounds obvious, but most learning plans are just playlists with better branding.

The repo’s phase structure makes that dependency graph visible. It starts with setup and tooling, moves through math and ML fundamentals, then deep learning, then transformers, then LLMs, then tools, agents, production, ethics, and capstones. That order is not decorative. It’s the whole argument.

I also appreciate the honesty in the “skip ahead if you already know the lower layers” note. That’s a real developer move. It doesn’t force everyone through the same tunnel, but it also doesn’t let people pretend the tunnel doesn’t exist.

• Use the phase order as a diagnostic, not a syllabus you worship.
• When something breaks later, trace backward to the phase that should have made it obvious.
• Keep a running list of “I can use it, but I can’t explain it yet” topics.

The build-first loop is the whole point

“Each lesson runs the same loop: read the problem, derive the math, write the code, run the test, keep the artifact.”

What this actually means is that the curriculum is trying to force muscle memory, not just recognition. I’ve seen too many AI lessons where the learner nods along, runs the notebook, and then immediately forgets everything because they never had to produce the thing themselves.

This repo repeats a six-beat lesson pattern: motto, problem, concept, build it, use it, ship it. That is a much better loop than “watch, copy, move on.” The build-it step makes you confront the mechanics. The use-it step shows you the production version. The ship-it step gives you a deliverable that escapes the notebook and enters the real world.

I ran into this exact gap when I was first trying to understand attention. I could recite the idea. I could even explain why it mattered. But until I wrote a tiny version by hand, I didn’t really understand the shape of the computation. The implementation exposed the tradeoffs the explanation politely hid.

How to apply it: for any AI topic you’re studying, force yourself to create three things. First, a bare-bones implementation with no framework magic. Second, the same thing with the actual library you’d use at work. Third, a small artifact you’d hand to someone else. If you can’t produce all three, you probably don’t own the concept yet.

The repo’s lesson structure makes that repeatable. That’s the useful part. Not the branding, not the giant phase count, not the nice diagrams. The repeatable loop.

• Build a toy implementation before touching the library version.
• Write a short note that explains the difference between the two.
• Export something reusable at the end: a prompt, skill, agent, or server.

The curriculum is organized like a dependency stack, not a playlist

“Math is the floor. Agents and production are the roof.”

What this actually means is that the repo treats AI engineering like software architecture. You do not start with the roof and then act surprised when the foundation cracks. The curriculum explicitly says every upper layer depends on the lower ones, and I think that’s one of its strongest choices.

The phase map is blunt about this. Setup and tooling come first. Then math foundations. Then ML fundamentals. Then deep learning core. After that, the curriculum branches into vision, NLP, speech and audio, RL, transformers, GenAI, LLMs from scratch, LLM engineering, multimodal, tools and protocols, agent engineering, autonomous systems, multi-agent swarms, infrastructure and production, ethics and alignment, and capstone projects.

That’s not random breadth. It’s a ladder. And ladders are useful because they tell you what you can safely skip and what you really shouldn’t.

I like the fact that the repo doesn’t pretend every learner needs the same entry point. There’s a “find your level” path with a ten-question placement quiz and a personalized path with hour estimates. That’s practical. If you already know the basics, you don’t need to waste a week proving you can add vectors. If you don’t know the basics, skipping ahead is just self-sabotage with better typography.

How to apply it: map your own AI knowledge into layers. Put math, classical ML, deep learning, transformers, agents, infra, and ethics into separate buckets. Then mark each bucket as “can explain,” “can implement,” or “can only use.” That gives you an honest starting point. No cosplay.

If you’re training a team, this structure is even more useful. It gives you a shared language for onboarding. Instead of saying “learn AI,” you can say “finish Phase 1 and Phase 3, then we’ll talk about agents.” That’s a conversation you can actually manage.

The lesson folders are built to be reused, not admired

“Every lesson lives in its own folder, with the same structure across the entire curriculum.”

What this actually means is that the repo is trying to make knowledge portable. A lesson isn’t just prose. It’s code, docs, and outputs sitting together in a predictable layout. That’s boring in the best possible way. Boring structure is what makes large projects survivable.

The folder pattern is straightforward: code for runnable implementations, docs for the lesson narrative, outputs for the thing the lesson produces. I’m a sucker for this kind of layout because it respects future-you. You don’t have to hunt for the artifact in a markdown appendix or a half-forgotten notebook directory.

I’ve lost count of how many times I’ve seen a learning repo where the “final result” is buried in a notebook cell with no obvious way to reuse it. Then three weeks later, nobody knows what was learned, what was generated, or what was safe to copy into a project. This repo avoids that mess by design.

How to apply it: if you’re building your own internal AI training material, copy this folder model. Separate explanation, implementation, and output. Make the output something someone can actually install, paste, or run. If the lesson doesn’t produce an artifact, it’s probably still just a note.

The repo also shows a nice pattern with the built-in skills like /find-your-level and /check-understanding. Those are not side quests. They’re part of the learning system. I like that because it turns the curriculum into a workflow, not just a reading list.

The artifact-first ending is what makes it useful at work

“Every lesson ships something.”

What this actually means is that the curriculum is trying to create outputs you can reuse inside actual developer workflows. That might be a prompt for a narrow task, a skill file for an AI assistant, an agent loop, or an MCP server. In other words, the lesson doesn’t end when you understand it. It ends when you can hand it to another system.

That’s a big deal. A lot of AI education stops at comprehension. But comprehension without packaging is fragile. If I can explain a tool but not deploy or paste it anywhere, I don’t really own it. I just recognize it.

The repo even gives a worked sample around the agent loop. It shows a minimal Python implementation and then a ship-it artifact in a markdown-style skill. That’s exactly the kind of bridge I want when I’m learning something new. Show me the toy. Show me the real thing. Show me the thing I can reuse on Monday.

How to apply it: after every lesson or internal workshop, force a shipping step. It can be tiny. A prompt file. A helper script. A reusable checklist. A minimal agent. An MCP server if you’re going that far. The key is that it should leave the notebook.

This is also where the repo’s language mix matters. Python is obvious here, but the inclusion of TypeScript, Rust, and Julia tells me the curriculum isn’t married to one stack. That’s good. AI work touches different layers, and sometimes the right tool is not the default one everyone repeats on social media.

• Turn each lesson into a reusable file, not a dead notebook.
• Keep outputs under version control so they can evolve with the lesson.
• Make the artifact small enough to copy, but real enough to use.

The repo is opinionated about how you should learn, and I think that helps

“No five-minute videos, no copy-paste deploys, no hand-holding.”

What this actually means is that the project is not trying to be friendly in the shallow sense. It’s trying to be effective. There’s a difference, and I wish more learning material understood that. Friendly content often optimizes for comfort. Effective content optimizes for transfer.

I don’t love every hard-edged learning design I run into, because some of them are just gatekeeping in a nicer font. This one feels different. The repo is explicit about what it expects: know how to code, want to understand how AI works, and be willing to do the work. That’s fair. It’s not pretending to be beginner magic.

How to apply it: if you’re building a team curriculum, be honest about the contract. Say what level of coding fluency is required. Say what the learner will be able to build by the end. Say whether the goal is literacy, implementation, or production readiness. Most training fails because it hides the contract until everyone is already annoyed.

The repo also gives you a practical way to self-correct with quizzes and phase checks. That matters because memory is a liar. I’ve finished lessons before and felt smart for exactly twelve minutes. Then I tried to explain the thing and found out I had only memorized the shape of the page. A check-understanding step is a good antidote to that kind of fake progress.

The template you can copy

# AI engineering from scratch curriculum template

## Goal
Build AI understanding in layers, then ship a reusable artifact after each lesson.

## Phase order
1. Setup & Tooling
2. Math Foundations
3. ML Fundamentals
4. Deep Learning Core
5. Domain modules: Vision, NLP, Speech, RL
6. Transformers
7. GenAI
8. LLMs from Scratch
9. LLM Engineering
10. Multimodal
11. Tools & Protocols
12. Agent Engineering
13. Autonomous Systems
14. Multi-Agent & Swarms
15. Infrastructure & Production
16. Ethics & Alignment
17. Capstone Projects

## Lesson format
Each lesson should follow this loop:
- Motto: one-line core idea
- Problem: the pain point or failure mode
- Concept: diagrams, intuition, and definitions
- Build It: implement the mechanism from scratch
- Use It: repeat with the production library
- Ship It: export a reusable artifact

## Lesson folder structure
phases/
  phase-name/
    lesson-name/
      code/      # runnable implementations
      docs/      # lesson narrative
      outputs/   # prompt, skill, agent, MCP server, or checklist

## Reusable artifact rule
Every lesson must end with one of these:
- a prompt for a narrow task
- a skill file for an AI assistant
- a minimal agent loop
- an MCP server
- a checklist or debugging guide

## Self-check rule
After each phase, answer:
- What can I explain now?
- What can I implement from scratch?
- What can I ship as a reusable artifact?
- What still feels magical?

## Personal rule
If I can only use it, but I cannot rebuild it, I do not own it yet.

## Team rule
Do not skip lower layers just because the top layer looks useful.
If the foundation is missing, the roof will lie to you.

## Copy-this lesson loop
1. Read the problem.
2. Derive the math.
3. Write the code.
4. Run the test.
5. Keep the artifact.
6. Review what broke.
7. Move the reusable piece into version control.

## Minimal lesson deliverable checklist
- [ ] One from-scratch implementation
- [ ] One library-backed implementation
- [ ] One reusable output file
- [ ] One self-check quiz
- [ ] One note on what I still don't understand

The original source is the GitHub repository at https://github.com/rohitg00/ai-engineering-from-scratch. I’ve rewritten the explanation and shaped the template for developers, but the curriculum structure, lesson flow, and artifact idea come from that repo.

For the related tools and concepts mentioned above, I’d also point you to GitHub Copilot, Claude Code, Cursor, and the Model Context Protocol docs.