rohitg00/ai-engineering-from-scratch: a 511-lesson curriculum that ends in an artifact, not a certificate

The gap this curriculum claims, and the learner it actually fits

The README opens with a statistic: 84% of students already use AI tools, and only 18% feel prepared to use them professionally. The stated purpose is to close that gap. The scale is unusual for a repository of this kind: 511 lessons, 20 phases, roughly 329 hours, in Python, TypeScript, Rust and Julia. The README also states that every lesson ships a reusable artifact, described as a prompt, a skill, an agent or an MCP server.

That framing matters because it sets the audience. This is not a library you import into a service, and it is not a textbook you read once. The README tells readers to pick one goal rather than scan 511 lessons, and it provides a table mapping goals to starting points: complete foundation, math plus ML foundations, production LLM applications, agents, Model Context Protocol, Agent Skills, and Claude certification preparation. A placement tutor named start-learning exists for people who cannot pick.

The honest read is that the material assumes a learner with time and patience. 329 hours is a semester and a half of full-time study. Someone who wants to add retrieval to an existing service next week is not the target reader, and the repository does not pretend otherwise.

How the curriculum is laid out and how a lesson is meant to run

The repository root holds phases/, skills/, certifications/, learning-paths/, projects/, book/, site/, glossary/ and i18n/. Lessons live under phases/ with numeric prefixes, and each lesson directory carries a code/ subdirectory. The README gives the example path phases/00-setup-and-tooling/01-dev-environment/code/verify.py, so the convention is visible from the outside.

The README prescribes a five-step loop for every lesson: read docs/en.md and restate the core idea, type and build the important code rather than treating the code block as decoration, run the lesson command from the repository root, keep evidence (the command, working directory, exit code, meaningful output, and the artifact changed), and continue only when the output can be explained and a small change made without guessing. That last condition is the part most self-paced curricula omit. It turns a lesson into a checkpoint.

The interface is deliberately plain. Commands in lesson pages are paths from the repository root unless the lesson says to change directories, and when a lesson offers several languages, the reader runs the implementation for the language being learned. There is no framework to learn before the first lesson, which is a design choice worth noting: the curriculum spends its complexity budget on the lessons rather than on tooling around them.

Installing it and producing your first piece of evidence

Two paths exist. The tutor path needs Node.js, npx and a skill-capable coding agent, and does not require a clone. The README says to check local requirements first, then install the curriculum skills and answer the host and scope prompts.

node --version
npx --version
python3 --version

npx skills add rohitg00/ai-engineering-from-scratch

After installation, invocation syntax belongs to the host rather than to the portable SKILL.md format. The README's table lists Codex, Claude Code and other compatible hosts: Codex uses start-learning from /skills, Claude Code uses /start-learning, and other hosts take a plain instruction such as "Use start-learning to begin the course." Runnable focused-path labs need python3, and Agent Skills host labs also need a selected host and a writable user or project skill scope.

The second path is the clone, and it is the one that produces evidence. The README shows these two commands run from the repository root.

git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch
python3 phases/00-setup-and-tooling/01-dev-environment/code/verify.py --route beginner
python3 phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

The preflight separates requirements needed now from tools needed later, and the README states that every required failure includes the detected reason and a corrective command. The second command is described as dependency-free and ends by showing that a matrix times a vector is the operation inside a neural network layer. Save that terminal output; the README calls it your first evidence. Note that requirements.txt is a different thing from the preflight: it pins numpy, matplotlib, jupyter, torch, torchvision, torchaudio, transformers, datasets, tokenizers, accelerate, scikit-learn, pandas, pillow, librosa, soundfile, tiktoken, anthropic and openai, and installing all of it is not what the beginner route asks for.

Where the material is thin, and when this is the wrong tool

The README does not document rollback, and it does not describe how to uninstall the skills added by npx skills add. That is a real gap for anyone who installs into a shared agent environment and later wants a clean state.

The translation story is more clearly stated but has its own cost. The README says the translated landing pages are committed to the repository, English is canonical, and lesson pages are machine-translated on the translations branch, with docs/i18n.md as the reference. If you read in one of the twelve listed languages and precision matters, the English lesson page is the one that counts.

The wrong-tool cases are easy to name. If you need a stable API with deprecation guarantees, this is not it: it is a curriculum that changes with the field, and the releases are dated editions (v2026.08 on 2026-08-10, v2026.07 on 2026-07-25) rather than versioned interfaces. If you are looking for certification exam answers, the repository points at preparation material under certifications/ rather than promising a pass. And if you want a single book to read linearly, the book/ directory exists, but the README's own instruction is to pick a goal and follow one path, which is the opposite of reading everything in order.

How it differs from a framework's own tutorials

The obvious alternative is a vendor tutorial path, such as the guides published around a specific model provider's SDK. Those teach the provider's abstractions and stay current with that product line. This repository inverts the arrangement: it lists anthropic and openai in requirements.txt alongside torch, transformers and tiktoken, so provider SDKs are ingredients rather than the subject. The lesson on the agent loop sits in Phase 14 rather than in a vendor's quickstart, which means the loop is explained before any particular client library is used.

The second alternative is a conventional course platform, where progress is tracked by a dashboard and the work is graded. Here the grading is self-administered through the evidence step, and progress lives in your terminal history. That is cheaper and more portable, and it is also easier to abandon halfway, which is worth weighing before starting a 329-hour sequence.

The third comparison is to a reference manual. A manual answers a question in thirty seconds. This repository answers a question by making you build the thing, which is the right trade for a learner and the wrong one for someone debugging production at 2am.

Maintenance, editions, and what the MIT licence leaves you

The repository is not archived, and the last push was on 2026-08-10, which is recent enough that the curriculum is being extended rather than frozen. The two most recent releases are dated editions, v2026.08 and v2026.07, so the cadence looks monthly. The README's statistics block is generated from site/stats.json by build.js and carries its own timestamp, which is a useful signal: the numbers are a build artifact with a date attached, not a claim you have to take on faith.

The upgrade cost is low in the sense that matters. Cloning again gets you the new edition, and there is no dependency graph of your own to migrate. The cost that is not low is time: if you are midway through a phase and the edition moves, the lesson you were on may have changed. The repository does not document a migration path between editions.

The licence is MIT, which is permissive and places few conditions on reuse of the lesson code. That applies to the code in the repository. It does not settle the terms of the external services the lessons call: anthropic and openai appear in requirements.txt, and any API usage in a lesson is governed by those providers' terms, not by this repository's licence. That is a factual boundary rather than legal advice, and it is the boundary worth checking before shipping lesson-derived code.

Editorial conclusion

Adopt it if you are learning AI engineering on your own and want a fixed sequence with a runnable command at each step, and if you accept that the lesson pages are machine-translated on the translations branch while English stays canonical. Skip it if you need API reference material or a maintained library; this is a curriculum, and the last push was on 2026-08-10. Before committing, run python3 phases/00-setup-and-tooling/01-dev-environment/code/verify.py --route beginner and read the corrective commands it prints, then confirm the phase you care about is not still marked as planned in ROADMAP.md.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes