Here’s the stat that stopped me: 84% of students already use AI tools, but only 18% feel prepared to use them professionally. That gap isn’t a minor oversight—it’s a systemic failure in how we teach AI. And this GitHub repo—ai-engineering-from-scratch by Rohit Ghumare—is the most honest, thorough fix I’ve seen in years.
I’ve been writing about developer tools and open-source projects for a while. I’ve seen hundreds of “learn AI” repos. Most are shallow tutorials with five-minute videos and copy-paste demos. You ship a chatbot but couldn’t explain its loss curve if your job depended on it. You hook a function to an agent but can’t tell me what attention actually does inside the model.
Then I stumbled on this thing. 503 lessons. 20 phases. ~320 hours of material. Python, TypeScript, Rust, Julia. Free, MIT-licensed. And the kicker? Every single lesson ships a reusable artifact—a prompt, a skill, an agent, an MCP server—that you can install into Claude, Cursor, or any agent that reads a SKILL.md.
It’s wild. And it deserves a real deep dive.
The Architecture: From Linear Algebra to Autonomous Swarms
Most AI curricula feel like a shuffled deck of cards. A paper on attention here, a fine-tuning post there, a flashy agent demo somewhere else. The pieces never line up. You end up with surface-level understanding and a folder full of unfinished notebooks.
This one has a spine. And it’s visible from orbit.
The entire curriculum is split into twenty phases that stack like building blocks. Math is the floor. Agents and production are the roof. You could skip ahead if you already know the lower layers—but the README is brutally honest: “don’t skip and then wonder why something at the top is breaking.”
Here’s the flow:
- Phase 0–2: Setup, math foundations (linear algebra, calculus, probability, optimization), ML fundamentals (regression, SVMs, random forests).
- Phase 3–9: Deep learning core (backprop from scratch, activations, optimizers), then vision, NLP, speech, transformers, GenAI, and even reinforcement learning.
- Phase 10–12: LLMs from scratch (tokenizers, GPT, RLHF, quantization), LLM engineering (RAG, fine-tuning, evaluation), and multimodal AI (CLIP, LLaVA, video-language models).
- Phase 13–16: Tools & protocols (MCP, A2A, function calling), agent engineering (with lessons on loops, memory, planning, and workbenches), autonomous systems (self-improvement, safety), multi-agent swarms.
- Phase 17–18: Production infrastructure (vLLM, SGLang, GPU autoscaling, SRE) and ethics/safety/alignment (red-teaming, constitutional AI, bias).
- Phase 19: Capstone projects—multiple end-to-end products and deep-build tracks where you build a terminal-native coding agent, a multimodal document QA pipeline, or an autonomous research agent.
That’s not a curriculum. That’s a flight plan for becoming the person who understands the stack, not just the person who can prompt it.
What a Single Lesson Looks Like (Spoiler: It Hurts, in a Good Way)
I picked a random lesson to test the vibe—Phase 14, Lesson 1: The Agent Loop. ~120 lines of pure Python, no dependencies. You write run(query, tools) from scratch. No LangChain, no AutoGen, no OpenAI SDK. Just a ReAct-style loop with MAX_STEPS and a llm() call.
Here’s the pattern every lesson follows:
- MOTTO – One-line core idea that sticks in your head.
- PROBLEM – Concrete pain: “Your agent gets stuck in infinite loops and never returns useful results.”
- CONCEPT – Diagrams, math, intuition. No hand-waving.
- BUILD IT – Pure math, no frameworks. You implement the algorithm on raw numbers.
- USE IT – Then you run the same logic through PyTorch, or sklearn, or whatever production library matches.
- SHIP IT – You produce an artifact: a prompt file, a
SKILL.mdto drop into Claude, an MCP server, or an agent template.
The beauty? By the time you “Use It,” you already know what the framework is doing because you wrote the infernal version yourself. I cannot overstate how rare this is. Most courses either hand you a framework and say “trust me” or make you implement everything from scratch and never show you how it maps to real tools. This one does both—and then makes you ship something actually useful.
Each lesson folder has a clean structure: code/, docs/, outputs/. The outputs/ folder is where the artifacts live. By the end of the course, you have 503 real tools in your back pocket. And they’re all yours because you understand how each one works down to the last gradient update.
Why This Matters Right Now
“The hottest new programming language is English.” — Andrej Karpathy, 2023.
“Software engineering is being remade in front of our eyes.” — Boris Cherny, creator of Claude Code, 2025.
I’ve heard those quotes a hundred times. But what does it actually mean to learn that new language? It’s not about memorizing API docs. It’s about understanding the primitives: attention, backprop, embeddings, tool calling, agent loops. Those are the new syntax.
And that’s exactly what this curriculum teaches. It’s not a “learn AI in 5 days” promise. It’s a “commit 320 hours and you’ll never be confused by an agent pipeline again” offer.
The repo’s companion site already has 150,000 readers and 240,000 page views in a month. That’s not hype. That’s a signal that the market is starving for substance.
I’ll admit: I’m biased toward anything that builds things by hand. But even with that bias, I’m genuinely impressed by the breadth and depth here. Phase 18 covers ethics, safety, and alignment with three focused lessons: safety & alignment, fairness & bias, privacy & security. That’s not just “responsible AI” lip service. It’s real content, written for people who can code.
And the whole thing is free. MIT licensed. No account required. You can start on the web at aiengineeringfromscratch.com without cloning anything.
How to Start (Without Getting Overwhelmed)
The repo gives you three on-ramps:
- Read online – Open any completed lesson on the website. No setup.
- Clone and run –
git clonethe repo, thenpython phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py. That’s it. - Find your level – Use the built-in agent skill
/find-your-level. Ten questions map your knowledge to a starting phase. It even estimates hours.
I tried the third option inside Claude Code. It asked about my comfort with linear algebra, probability, Python, and neural networks. In under a minute, it told me I could start at Phase 10 (LLMs from Scratch) and save about 200 hours. Then I could quiz myself with /check-understanding 10 after each phase.
That’s the kind of practical, human-centered design that makes me forgive the occasional ASCII-art in the README. The author—Rohit Ghumare, maintainer of Agent Memory—obviously lives in this world. He built the curriculum for himself first, and it shows.
One more thing: if you use any agent tool (Claude, Cursor, Codex, OpenClaw, Hermes), you can install the skills with a single command:
python3 scripts/install_skills.py
That drops a .claude/skills/ directory with expert-level instructions for prompt engineering, debugging agents, and evaluating models. You get a second brain that actually knows the subject matter.
The Real Test: Would You Give This to a Junior Developer?
I asked myself that question halfway through the README. And my honest answer: yes—but only if they’re willing to code every single lesson. This isn’t passive learning. You can’t watch a video and call it done. You have to write the backprop, debug the gradient explosion, and ship the MCP server yourself.
That’s exactly what makes it valuable. The job market in 2026 doesn’t reward people who can talk about AI. It rewards people who can build it. And this curriculum is a factory for exactly that kind of engineer.
If you’re a senior engineer wanting to understand agents deeply, jump to Phase 14. If you’re a math student wanting to see theory in practice, start at Phase 1. If you’re a student who just used ChatGPT for homework and felt guilty, start at Phase 0 and commit to 306 hours.
The repo also has a contribution guide, a forking guide, and even a quiz.json validation script. The author is clearly serious about quality. And the curriculum is still actively maintained—Rohit Ghumare and the community keep adding content. Phase 19 alone contains multiple capstone projects. That’s a whole second course inside the course.
I’m not going to pretend it’s perfect. Some of the deeper topics (like Phase 17’s infrastructure lessons on vLLM internals and SGLang) assume solid DevOps knowledge. And 320 hours is a serious commitment—about two months of full-time work. But the modular design lets you pick your battles.
Look, there are easier ways to get a job in AI. Bootcamps exist. Certificates exist. But if you actually want to understand what you’re building—if you want to be the person who can debug a trillion-parameter model without panicking—this is the path.
I suspect this repo will only gain more traction as word spreads. Star it now so you can tell your friends you were there before the explosion.
Start here: https://github.com/rohitg00/ai-engineering-from-scratch