A Number
523 lessons. 20 phases. About 342 hours. Four languages: Python, TypeScript, Rust, and Julia. Every lesson produces something reusable: a prompt, a skill, an agent, or an MCP server.
This is not a university syllabus; it is the README of rohitg00/ai-engineering-from-scratch. MIT license, completely free, open source.
The README cites a pair of statistics:
> 84% of students already use AI tools. Only 18% feel prepared to use them professionally.
The course exists to close that 66-percentage-point gap.
How It Differs from Other AI Courses
Most AI courses fall into three categories:
- Concept surveys. What is machine learning, deep learning, a Transformer. You can talk about it afterwards, but not build it. (Various "AI for Everyone" style courses.)
- Framework tutorials. How to run a model with PyTorch/TensorFlow/Hugging Face. You can run a demo, but don't know why it works, and you're lost in a new scenario. (Various "Learn PyTorch in 30 Days" courses.)
- Paper deep-dives. Line-by-line math and code from a paper. You understand that paper, but not where it fits in a full system. (Various "Implement Transformer from Scratch" courses.)
- Learn lessons: explain concepts with Python/Julia code examples
- Build lessons: implement something from scratch, producing reusable code
- Four languages. Python as the main line, TypeScript for frontend/full-stack, Rust for performance-critical code, Julia for mathematical computing. Not mastery of all four, but using the right tool in the right scenario.
- Math first. Phase 1 has 22 math lessons, from linear algebra to stochastic processes. Not the traditional "learn math before coding" route, but "understand math through code": every math lesson has a Python/Julia implementation. For example, lesson 5, "Chain Rule and Automatic Differentiation," doesn't derive formulas; it implements an autodiff engine from scratch.
- Every lesson produces output. This is the biggest difference from most courses. After a lesson, you don't gain notes; you gain a tool. The Phase 13 agent lessons produce a working agent; the Phase 16 MCP lessons produce a working MCP server. Finish 523 lessons and you own 523 tools.
- MIT license. All code can be used commercially. This is not "for learning only" toy code; it is production-ready.
This course aims for a fourth category: from math foundations to production deployment, with every lesson producing a reusable tool.
The 20 Phases
| Phase | Content | Lessons | |---|---|:---:| | Phase 0 | Environment setup and tooling | 12 | | Phase 1 | Math foundations (linear algebra, calculus, probability, information theory) | 22 | | Phase 2 | ML basics (regression, classification, clustering, SVM, KNN) | 18 | | Phase 3–5 | Deep learning (neural nets, CNNs, RNNs) | ~40 | | Phase 6–8 | NLP, CV, reinforcement learning | ~60 | | Phase 9–12 | LLMs, Transformers, attention | ~80 | | Phase 13–16 | Agents, RAG, tool calling, multimodal | ~80 | | Phase 17–19 | MLOps, deployment, productionization | ~60 |
Every lesson follows a uniform format:
The key design: code from each Build lesson is not a throwaway exercise but a reusable artifact. The first lesson of Phase 0 produces a dev environment setup script used by the other 522 lessons. Lesson 5 of Phase 1 produces an autodiff implementation that all subsequent deep learning lessons build on.
Interesting Design Choices
The Ambition
A line from the README:
> You don't just learn AI. You build it. End-to-end. By hand.
The goal is not "teaching you AI" but enabling you to build an AI system from scratch. The endpoint of 523 lessons is not a certificate but a complete AI engineering toolbox: math foundations, ML algorithms, deep learning models, NLP/CV/RL, LLM applications, agent frameworks, MCP servers, MLOps deployment, all implemented by hand at least once.
The scale of that ambition is visible in the numbers: 342 hours. At 2 hours a day, that's 171 days, nearly six months. And it is not 171 days of "watching videos"; it is 171 days of "writing code."
A Deeper Observation
The reason this course earned 828 stars in a single day is not just its volume. It hits a real pain point: AI tools are spreading far faster than AI engineering skills are being cultivated.
84% of students use AI tools, but only 18% feel prepared. That 66-point gap cannot be closed by watching a few GPT tutorials. It requires full engineering training, from mathematics to deployment.
Most existing courses are either too shallow (concept surveys), too narrow (framework tutorials), or too deep (paper deep-dives). Courses that manage to be both comprehensive and hands-on are rare.
Another notable aspect: the course binds "learning" to "output." Each lesson is measured not by what you learned but by what you built. That is a more honest form of assessment: if you claim you understand it, show me what you made.
523 lessons, 523 tools. Anyone who completes all of them will hold a more complete toolbox than most AI engineers.
---
*GitHub: rohitg00/ai-engineering-from-scratch · License: MIT · 523 lessons · 342 hours*