ai-engineering-from-scratch

rohitg00MIT活跃维护

从零手写实现 AI 工程核心组件的实战课程,覆盖智能体、大模型、计算机视觉与深度学习,边学边构建可交付的项目。

Learn AI Engineering! Learn it. Build it. Ship it for others.

v2026.11.2发布于 2026-11-09 19:13 UTC78,245star +1,018 / 7 天13,917fork同步于 2026-11-10 17:18 UTC

怎么上手

由 README 提炼,执行前请确认
python3 scripts/project_test.py retrieval-evaluation-lab --init learning-artifacts/retrieval-evaluation-lab
硬件要求按 README 说明

README 未说明

支持 Apple Silicon
下载:源码 zip·GitHub Releases(安装包)本站不镜像安装包

项目说明

由 README 自动翻译提炼

从零实现模型内部、检索管线与 Agent 运行时的开源 AI 工程课程,边写代码边验证

从零手写实现 AI 工程核心组件的实战课程,覆盖智能体、大模型、计算机视觉与深度学习,边学边构建可交付的项目。

核心能力

  • 542 节课、20 个阶段,覆盖 Python/TypeScript/Rust/Julia
  • 实现模型内部、检索管线与 Agent 运行时并保留评测结果
  • 三个带分阶段 starter 和本地 grader 的项目挑战
  • 提供梯度下降等可交互实验,可调学习率观察收敛
  • 支持在网站、编码 Agent 或本地代码三种方式学习

容易踩的坑

项目 starter 未实现各阶段前会一直测试失败,需按 stage 逐步实现;不同项目对运行时版本有要求,如 Python 3.10+、Node.js 22.18+、Rust;grader 需在仓库根目录执行,且部分项目还需 Python 3 配合。

内容由模型根据 README 生成,可能不完整或不准确,以官方文档为准。看原文 README

最近发版

5 个版本v2026.11.2
  1. v2026.11.2Edition 2026.11.2: Lessons in Five Languages最新正式版2026-11-09 · 2026-11-09 19:13 UTC

    Read each lesson in the language you use at work. This edition adds TypeScript ports to most lessons, and Rust, Julia and Go ports to the lessons where each of those languages is the right tool.

    Start learning · Catalog · Interviews

    Lessons in five languages

    LanguageLessonsWhere
    Python534Every lesson with code
    TypeScript397Most lessons, from math foundations to the capstones
    Rust46Tokenizers, retrieval, constrained decoding, serving schedulers, KV cache, binary analysis
    Julia45Numerical math, statistics, signal processing, small networks
    Go16MCP and A2A servers, gateways, auth, worker pools, durable execution, telemetry
    • Every port uses only the standard library of its language and keeps the functions and demos of the Python file.
    • A lesson gets a Rust, Julia or Go port only when a practitioner would pick that language for the problem. Reinforcement learning, classical ML and torch-based lessons stay in Python.
    • The language chips on each lesson page and the Lang column in the README show which ports a lesson has.
    • CI compiles and runs every port on each pull request: tsc --strict, rustc -D warnings, Julia, and gofmt, go vet and go run.
    • Review of the ports also found and fixed bugs in the Python files, for example the tokenizer fallback for non-Latin text, out-of-range reads in the ELF and PE readers, and the code runner status in the capstone.

    Site

    • Lesson code blocks are rendered once at build time with Shiki.
    • Search now indexes the body text of each lesson, not only the titles.
    • Level-4 headings render as headings and show in the table of contents.
    • Tabs, overlays and failed requests no longer leave the site in a broken state.
    • llms.txt has one discovery section after the summary.
    • Mermaid diagrams in the README are readable in dark mode.

    Lessons and interviews

    • The interview bank is now built by a generator on main.
    • Lesson claims that the interview reviews found wrong are corrected.
    • Better quiz distractors in phase 10 lessons 06 and 07.
    • Phase 13 lesson 45 treats a clang that does not match the fixture the same as a missing clang.

    Thanks to @eshitakundu and @viwe-monai for their contributions in this edition.

    Full changelog: https://github.com/rohitg00/ai-engineering-from-scratch/compare/v2026.11.1...v2026.11.2

  2. v2026.11.1Edition 2026.11.1: Interview Bank and Incident Scenarios2026-11-03 · 2026-11-03 18:16 UTC
    查看更新说明

    Practise for AI engineering interviews against the course itself. This edition adds an interview bank of 482 questions and 60 measured incident scenarios, a mock interview skill, and code blocks rendered at build time.

    Interviews · Scenarios · Skills · Start learning

    Browsing the interview bank

    Interview bank

    • 482 questions in 23 cards, from math and classical ML to inference serving, agents, protocols, sandboxes and system design.
    • Each question shows the prompt first and folds the answer, so you answer before you read. A short answer, a full answer, follow-ups from L1 to L4, and the wrong answers that interviewers hear.
    • Every answer links to the lesson or manual section that teaches it. Every number in an answer comes from a file in the repository.
    • 7 role paths pick the cards for a role, such as inference engineer or applied AI engineer.

    Incident scenarios

    • 60 scenarios built from real runs on the L4 and the GB10 in the SGLang, vLLM and Miles manuals.
    • Each one gives the situation and the evidence, step by step: logs, metrics and configs, byte for byte from the run. Then the walkthrough, the resolution, and the wrong turns people take.

    Mock interviews with an agent

    The new interview-prep skill runs a mock interview in your coding agent.

    • It asks one question or one scenario and waits for your answer. It never shows part of the answer first.
    • It grades your answer against the bank, asks follow-ups one at a time, and sends each gap to the lesson that teaches it.
    • It keeps a record of your sessions in INTERVIEW-LEARNING.md.

    Site

    • Code blocks on practice pages, cheat sheets and manuals are rendered once at build time with Shiki. Terminal blocks copy only the commands, and output blocks have no Copy button.
    • New Miles RL cheat sheet.

    Fixes

    • Review fixes across the interview answers, checked against their lessons: optimizer and schedule edge cases, attention and tokenizer code, cache pricing, eval statistics, and protocol and sandbox details.
    • The generated interview indexes are now built on main after each merge, so contributions to the bank no longer conflict with each other.

    Full changelog: https://github.com/rohitg00/ai-engineering-from-scratch/compare/v2026.10.5...v2026.11.1

  3. v2026.10.5Edition 2026.10.5: Lesson Screen, vLLM 101, and Miles 1012026-10-29 · 2026-10-29 15:07 UTC
    查看更新说明

    Learn beside your terminal, read two new hardware manuals, and practise every lesson. This edition adds the lesson screen for agent tutors, vLLM 101 and Miles 101, 47 practice tasks, and two new inside-the-machine pages.

    Start learning · Skills · Manuals · Practice

    Lesson screen for agent tutors

    The new lesson-screen skill opens a browser tab next to the terminal while a tutor teaches.

    • It shows the lesson's own interactive figures, code traces with values from a real run, and clickable predictions.
    • The tutor can build a figure for the lesson while it teaches: a blueprint, a mechanism, an isometric machine, or a 3D model. It checks each build with screenshots before it shows it.
    • After the tutor's quiz, a practice page gives a brief with key-term cards, a timed drill, spaced review at 1, 3, 7, and 16 days, and links to go deeper.
    • Clicks are hints for the tutor. They never count as quiz answers or evidence. The certification tutors use the screen in Lesson mode only.

    All six lesson tutors offer it. Without a local browser, they give the lesson page instead.

    Manuals

    • vLLM 101 and Miles 101 are published, next to SGLang 101, with measured, clock-locked GPU results and hardware-specific cover plates.
    • SGLang 101 has 168 audited claims checked and corrected, research caveats, and new sweep configs.
    • Manuals use their own words instead of quotes, pin evidence links to the built commit, and are easier for search engines and AI agents to find.

    Practice and machines

    • 47 practice tasks across implement, research, train, and lab kinds.
    • Inside a Decompiler and Inside an LLM serving GPU machines, graded reverse-engineering labs, and step-synced lesson machines.

    Site

    • The navbar has a System, Light, and Dark theme menu in place of the old N/D switch. System follows your OS live.
    • The catalog shows lesson numbers and done checkboxes.
    • Quizzes are placed once per lesson. Highlights and read-aloud controls no longer overlap on phones and tablets.

    Fixes

    • Source errors corrected across phases 00 to 19, with phase 12 cheat sheets synced.
    • Apple Silicon (MPS) device support across lessons. Thanks @Jayantkhandebharad.
    • Stale translations repaired, and reviewed translations protected.
    • Tutor skill lesson counts match the catalog.

    Full changelog: https://github.com/rohitg00/ai-engineering-from-scratch/compare/v2026.10.4...v2026.10.5

  4. v2026.10.4Edition 2026.10.4: Highlights, Cheat Sheets, and SGLang2026-10-19 · 2026-10-19 08:42 UTC
    查看更新说明

    Highlight what matters, keep notes beside the text, and carry a compact reference into your next build. This edition adds a reading workspace, 154 cheat sheets, and the ready edition of SGLang 101.

    Start learning · Cheat sheets · SGLang 101

    Highlights and notes

    Select text in a lesson or manual, choose one of four colors, and add a note. Open My Highlights to search, filter, jump back to a passage, or manage several highlights together.

    • Export Markdown for your notes or JSON for backup and import.
    • Move highlights between devices with a sync file or share link.
    • Review uncertain matches when a passage changes.
    • Use the same tools on mobile, in light and dark themes, and with forced colors.

    Highlights stay in your browser. Use an export or share link to move them elsewhere.

    Highlight colors and notes in a lesson

    Adding a note in light theme

    Highlights with forced colors enabled

    154 cheat sheets

    Find commands, formulas, diagrams, defaults, and troubleshooting notes across all 542 lessons, four manuals, and 78 projects. Browse 12 tracks or search by topic, task, command, or term. Follow a source link when you need the full explanation.

    The complete collection is attached as aiefs-cheatsheets.pdf.

    Transformers and attention cheat sheet

    Agent harness engineering cheat sheet

    SGLang 101 is ready

    Serve a model, size its KV cache, measure the concurrency knee, and decide when to split work across GPUs. The manual covers SGLang 0.5.22 in 28 sections plus six reference sections, with 63 figures and a cover plate.

    The examples distinguish measured results from code defaults and reported claims. This edition includes Apple Silicon, GB10, cooled L4, and Miles rollout evidence, including CUDA graphs, attention backends, and three training seeds.

    Read it online or download aiefs-manual-sglang-101.pdf below.

    More in this edition

    • A beginner guide and 142 exercise hints across 34 lessons in Phases 0 and 1.
    • Project selection by role and lesson search inside phase dialogs.
    • Reverse Engineering 101 updated for rea 6.7.0.
    • Improved article navigation on smaller screens and a clean roadmap URL.
    • Fixes for links containing parentheses, PDF math rendering, and deployment bundles.

    Downloads

    All six English books are included in PDF and EPUB. The four manual PDFs cover A2A, Docker Sandboxes, Reverse Engineering, and SGLang. The complete cheat-sheet PDF and six preview images are also attached.

    Thanks to our contributors

    Thank you to @Abhishek-1337 for lesson search in phase dialogs, @AkshayKathiriya and @dajiaohuang for fixes to links containing parentheses, and @ALANDVO for adding lesson summary cheat-sheet support. Thanks also to everyone who reported problems, reviewed changes, and helped improve the course.

    [Full changelog](https://github.com/rohitg00/ai-engineering-from-scratch/compare/v2026.10.3...v2026

  5. v2026.10.3Edition 2026.10.32026-10-15 · 2026-10-15 04:29 UTC
    查看更新说明

    Edition 2026.10.3 adds a reverse engineering track, a third manual, and LaTeX math in the lessons. The curriculum grows from 523 to 542 lessons across 20 phases.

    Learn reverse engineering

    Fourteen new Phase 13 lessons teach how to read a compiled program you built yourself, from file bytes to evidence-backed pseudocode (#597).

    • The lessons cover program anatomy (ELF, Mach-O, PE), disassembly and control-flow graphs, lifting to IR and SSA, calling conventions on System V, Windows x64 and AArch64, compiler idioms, linking and stripped binaries, data and type recovery, dynamic analysis, bytecode formats (Python, JVM, .NET, WebAssembly), binary diffing and symbolic execution, and a ground-truth scorecard for AI-assisted analysis.
    • Each lesson runs real tools on its own fixtures: llvm-objdump, Ghidra, radare2, rizin, angr, lldb, LIEF, javap and wasm-objdump, among others.
    • Two graded projects: binary-inspector (6 stages, 91 tests) and mini-decompiler (8 stages, 105 tests), from an ELF loader to structured C that recompiles and compares equal.
    • A focused learning path and the learn-reverse-engineering tutor skill take a learner through the 14 lessons in order.

    Read Reverse Engineering 101

    Reverse Engineering 101 teaches rea (rea-agents 6.5.0) with the Ghidra 12.1.4 provider, from the first rea doctor to an agent that keeps an evidence ledger over MCP. It has 26 sections in 8 parts, six reference sections, and 37 figures. The PDF is attached below as aiefs-manual-reverse-engineering-101.pdf (#601).

    • Every listing comes from a recorded run of the real CLI and MCP server. capture/run.py --check captures again and compares 65 files.
    • Every target is a fixture program written for the manual.

    Read the math

    • Lesson formulas render with LaTeX through KaTeX on the site, and as math on GitHub (#598). Formulas use only macros that GitHub allows, and CI checks that (#599).

    New lessons and projects

    • Five lessons fill gaps in the curriculum, and broken links are repaired (#584).
    • Half the project roadmap is complete, with two new validated projects (#565).
    • The architecture calculator in lesson 10/14 reads head_dim, tied heads, and sliding-window layers (#511).

    Site

    • Lessons and their translations are rendered on the server, so crawlers and readers without JavaScript get the full text (#570).
    • Glossary terms have their own pages, and each phase has a hub page (#574).
    • Every page has its own social card (#576) and a crawlable favicon (#581).
    • Inside an AI Agent is an interactive machine that shows each step of an agent run (#590).
    • A /skills page lists the course skills, with five new figure and manual skills (#593).
    • On wide screens, the lesson breadcrumb stays below the lesson (#600).

    Contributors

    Thank you to everyone who contributed to this edition:

    • @FenjuFu fixed the architecture calculator in lesson 10/14 (#511)

    Sponsors

    Thank you to SerpApi for supporting the curriculum. SerpApi provides a Web Search API for AI apps, available in Markdown and JSON.

    Books and manuals

    All six English volumes are rebuilt as EPUB and PDF files from this edition's source and attached below, with the A2A 101, Docker Sandboxes and Docker Agent 101, and Reverse Engineering 101 manuals beside them. Interactive figures, graded quizzes, and runnable labs remain accessible through each chapter's online links. The website and README book links continue to use the latest release assets.

    Full changes since Edition 2026.10.2

用户点评

登录用户的真实使用记录,可按版本和硬件筛选
共 0 条

    还没有人点评。第一个说出真实体验的人最有价值。

    README 原文

    未翻译

    Implement model internals, retrieval pipelines, and agent runtimes. Test them, inspect failures, and keep the code and evaluation results.

    Start learning · Choose a path · Try a lab · Build a project · Browse the curriculum

    Free, open source, MIT. Learn on the website, with a coding agent, or by running local code.

    542 lessons. 20 phases. Python, TypeScript, Rust, Julia.

    Sponsors

    Learning paths

    RouteStarting lesson
    Model foundationsSetup and tooling
    LLM systemsPrompt engineering
    Agents and deliveryThe agent loop

    Compare career paths · Prerequisites and study time

    Gradient descent

    Twenty starting points follow gradient descent on a quadratic loss. The graph shows their positions and mean loss after each update.

    Adjust the learning rate in the lesson · Compare GD, momentum, and Adam in code

    Projects

    Three projects with staged starters, reference implementations, and local graders. Run commands from the repository root after setup. Starters fail until you implement the stages.

    A candidate improves mean NDCG while one query ranks its most relevant evidence lower. Build a query-by-query comparison that reports the regression and can fail a release check.

    Use Python 3.10+. Review RAG and model evaluation. Implement ranking validation, precision and recall, rank-sensitive metrics, then system comparison.

    python3 scripts/project_test.py retrieval-evaluation-lab \
      --init learning-artifacts/retrieval-evaluation-lab
    python3 scripts/project_test.py retrieval-evaluation-lab \
      --stage 1 --path learning-artifacts/retrieval-evaluation-lab --strict
    python3 scripts/project_test.py retrieval-evaluation-lab \
      --all --path learning-artifacts/retrieval-evaluation-lab --strict
    

    Keep: a reproducible comparison with per-query deltas and the judgments used to score them. Metrics describe those judgments; they do not establish answer correctness.

    Start the project · Inspect the reference · Run on your own inputs

    A supplied trace still takes 100 ms, but total token usage rises by 200 and one span starts failing. Separate overlapping child work from parent execution time, then produce a report that exposes the change.

    Use Node.js 22.18+ and Python 3 for the grader. Implement JSONL parsing, parent validation, interval arithmetic, then an inspectable timeline.

    python3 scripts/project_test.py agent-trace-debugger \
      --init learning-artifacts/agent-trace-debugger
    python3 scripts/project_test.py agent-trace-debugger \
      --stage 1 --path learning-artifacts/agent-trace-debugger --strict
    python3 scripts/project_test.py agent-trace-debugger \
      --all --path learning-artifacts/agent-trace-debugger --strict
    

    Keep: the input trace, an HTML timeline, and a JSON regression report. Preserve exclusive per-span token counts so parent and child usage are not counted twice.

    Start the project · Inspect the reference · Explore timing interactively

    A write changes after review, or an approval is replayed. Validate the call envelope, check the caller's role and path, then consume an approval bound to the exact request and content.

    Use Rust and Python 3.10+. Review tool schema design and security boundaries. The caller application supplies identity; the model proposes an operation.

    python3 scripts/project_test.py tool-call-firewall \
      --init learning-artifacts/tool-call-firewall
    python3 scripts/project_test.py tool-call-firewall \
      --stage 1 --path learning-artifacts/tool-call-firewall --strict
    python3 scripts/project_test.py tool-call-firewall \
      --all --path learning-artifacts/tool-call-firewall --strict
    

    Keep: an audit receipt showing the requested operation and the policy decision. Approvals are single-use within one invocation; this project does not provide persistent authorization or an operating-system sandbox.

    Start the project · Inspect the reference · Explore approval boundaries

    Browse all projects · Career practice guide

    Choose how to learn

    On the website

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

    With an AI tutor

    If Node.js, npx, and a skill-capable coding agent are already installed, your coding agent can become your tutor. A repository clone is not needed to install or read the tutor. Runnable focused-path labs need python3. Agent Skills host labs also need a selected host and a writable user or project skill scope.

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

    Choose the host and scope when the installer asks. Use start-learning in Codex, /start-learning in Claude Code, or ask your host to use the skill by name.

    Check the local requirements first:

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

    skills writes to the host and scope selected during installation, such as .claude/skills/, .cursor/skills/, .codex/skills/, or another supported skills folder. Verify that the selected host discovers that exact destination.

    Invocation syntax belongs to the host, not to the portable SKILL.md format:

    HostStart the courseStart Model Context Protocol (MCP)Start Agent SkillsRun a phase quiz
    Codexstart-learning, or choose it from /skillslearn-mcp, or choose it from /skillslearn-agent-skills, or choose it from /skillscheck-understanding 13, or choose it from /skills
    Claude Code/start-learning/learn-mcp/learn-agent-skills/check-understanding 13
    Other compatible hostsUse start-learning to begin the course.Use learn-mcp to start the Model Context Protocol (MCP) path.Use learn-agent-skills to start the Agent Skills Engineering path.Use check-understanding to quiz me on Phase 13.

    A ten-question placement quiz maps what you already know to a starting phase and saves a personalized study plan to LEARNING.md. From there, the learn skill teaches one lesson per session: concept, math, code, quiz. It streams lessons straight from this repo, and the course-guide skill jumps you to the exact lesson that covers anything you are stuck on. In Codex, invoke these skills with learn and course-guide; in Claude Code, use /learn and /course-guide; in other compatible hosts, ask to use the skill by name.

    Only want Model Context Protocol (MCP)? Use the MCP invocation for your host. It creates MCP-LEARNING.md and follows one 17-lesson route through stateless requests, transports, bidirectional work, security, reliability, registry governance, and conformance evidence. The exact order and checkpoints live in the Model Context Protocol (MCP) manifest.

    Only want Agent Skills? Use the Agent Skills invocation for your host. It creates AGENT-SKILLS-LEARNING.md and follows one coherent five-lesson route: contract, discovery, invocation, sandbox boundaries, then release evals and real-host portability. Start on the web with the Agent Skills path.

    The installer lists the hosts it can configure and asks where to install. If you do not have Node.js, npx, python3, a supported host, or a writable scope yet, use the website or read docs/en.md manually. That path teaches the concepts, but real-host discovery, invocation, script, and uninstall evidence remains pending until the preflight is available. Read the lessons at aiengineeringfromscratch.com.

    The learning skills

    SkillWhat it does
    start-learningOne-time onboarding: why you're learning, placement quiz, personalized plan saved to LEARNING.md.
    learnThe tutor loop. Warm-up recall, then the next lesson taught interactively, then its quiz; records progress and a review queue.
    course-guideTopic router. "Where do I learn attention?" or "my loss is NaN" → the exact lessons, with links.
    learn-mcpFocused Model Context Protocol (MCP) tutor. Creates MCP-LEARNING.md, follows the 17-lesson manifest, and records wire, security, reliability, and conformance evidence.
    learn-agent-skillsFocused Agent Skills tutor. Creates AGENT-SKILLS-LEARNING.md, teaches lessons 22, 24, 25, 26, and 27, and records real-host evidence.
    learn-reverse-engineeringFocused Reverse Engineering tutor. Creates REVERSE-ENGINEERING-LEARNING.md, teaches Phase 13 lessons 32 to 45 on programs you build yourself, and records lab evidence.
    claude-certificationCertification tutor. Chooses CCAO-F, CCDV-F, CCAR-F, or CCAR-P; teaches each lesson; runs labs; reviews artifacts; administers diagnostics and mocks; saves progress.
    mcpa-certificationMCPA tutor. Follows the 34-lesson mcpa-f route on the 2026-07-28 protocol; teaches each lesson; runs labs and the wire checker; administers the diagnostic and three mocks; saves progress.
    find-your-levelTen-question placement quiz. Maps your knowledge to a starting phase and produces a personalized path with hour estimates.
    check-understanding <phase>Per-phase quiz, eight questions, with feedback and specific lessons to review. Use the Codex, Claude Code, or natural-language form in the invocation table above.

    Run local code

    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. Every required failure includes the detected reason and a corrective command. The vectors.py command is a dependency-free lesson and ends by showing that a matrix times a vector is the operation inside a neural network layer. Save that terminal output as your first evidence.

    Use every lesson the same way

    1. Read docs/en.md and explain the core idea in your own words.
    2. Type and build the important code instead of treating the code block as decoration.
    3. Run the lesson command from the repository root, the directory containing README.md and phases/.
    4. Keep evidence: the command, working directory, exit code, meaningful output, and the artifact you changed or produced.
    5. Continue only when you can explain the output and make one small change without guessing.

    Commands in lesson pages are paths from the repository root unless the lesson explicitly says to change directories. If a lesson offers several languages, run the implementation for the language you are learning.

    Choose a learning path

    You do not need to scan 542 lessons before beginning. Pick one goal. Each link opens the same curriculum on GitHub or the website, and both versions use the same lesson code.

    Your goalLearn on GitHubLearn on the website
    I am new and want the complete foundationPhase 0: Setup and ToolingDev Environment
    I know Python and want math plus ML foundationsPhase 1: Math FoundationsLinear Algebra Intuition
    I want to build production LLM applicationsPhase 11: LLM EngineeringPrompt Engineering
    I want to build agentsPhase 14: Agent EngineeringThe Agent Loop
    I want to use coding agents on real repositoriesAgent-Assisted Engineering pathAgent-Assisted Engineering
    I want to shape the right build before implementationProduct Judgment and Delivery pathProduct Judgment and Delivery

    Not sure where you fit? Use the start-learning placement tutor or the website prerequisites guide.

    Compare four core domains and six career routes in the AI Engineering Learning Paths.

    Your goalLearn on GitHubLearn on the website
    I want to build with Model Context Protocol (MCP)Model Context Protocol (MCP) routeModel Context Protocol (MCP) path
    I want to write and ship Agent SkillsFocused Agent Skills routeAgent Skills path
    I want to read compiled programsReverse Engineering routeReverse Engineering path

    Prerequisites

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

    Where to start

    BackgroundStart atEstimated time
    New to programming and AIPhase 0 — Setup~306 hours
    Know Python, new to MLPhase 1 — Math Foundations~270 hours
    Know ML, new to deep learningPhase 3 — Deep Learning Core~200 hours
    Know deep learning, want LLMs and agentsPhase 10 — LLMs from Scratch~100 hours
    Senior engineer, only want agent engineeringPhase 14 — Agent Engineering~60 hours
    Only want to build production MCP systemsModel Context Protocol (MCP) path~23 hours 15 min
    Only want to build production Agent SkillsAgent Skills Engineering path~9.5 hours
    Only want to learn reverse engineeringReverse Engineering path~32.5 hours

    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 &amp; 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 &amp; 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 &amp; Protocols"]
      P13 --> P14["Phase 14 — Agent Engineering"]
      P14 --> P15["Phase 15 — Autonomous Systems"]
      P15 --> P16["Phase 16 — Multi-Agent &amp; Swarms"]
      P14 --> P17["Phase 17 — Infrastructure &amp; Production"]
      P15 --> P18["Phase 18 — Ethics &amp; Alignment"]
      P16 --> P19["Phase 19 — Capstone Projects"]
      P17 --> P19
      P18 --> P19
      classDef phase fill:#fafaf5,stroke:#3553ff,color:#1a1a1a
      class P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19 phase
    

    Contents

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

    Phase 0: Setup & Tooling 13 lessons

    Get your environment ready for everything that follows.

    #LessonTypeLang
    01Dev EnvironmentBuildPython, TypeScript, Rust
    02Git & CollaborationLearn—
    03GPU Setup & CloudBuildPython
    04APIs & KeysBuildPython, TypeScript
    05Jupyter NotebooksBuildPython
    06Python EnvironmentsBuildShell
    07Docker for AIBuildDocker
    08Editor SetupBuild—
    09Data ManagementBuildPython
    10Terminal & ShellLearn—
    11Linux for AILearn—
    12Debugging & ProfilingBuildPython
    13Python for AI EngineeringBuildPython
    #LessonTypeLang
    01Linear Algebra IntuitionLearnPython, Julia
    02Vectors, Matrices & OperationsBuildPython, Julia
    03Matrix Transformations & EigenvaluesBuildPython, Julia
    04Calculus for ML: Derivatives & GradientsLearnPython, Julia
    05Chain Rule & Automatic DifferentiationBuildPython, Julia
    06Probability & DistributionsLearnPython, Julia
    07Bayes' Theorem & Statistical ThinkingBuildPython, TypeScript
    08Optimization: Gradient Descent FamilyBuildPython, Julia
    09Information Theory: Entropy, KL DivergenceLearnPython, TypeScript
    10Dimensionality Reduction: PCA, t-SNE, UMAPBuildPython, TypeScript
    11Singular Value DecompositionBuildPython, Julia
    12Tensor OperationsBuildPython, TypeScript
    13Numerical StabilityBuildPython, TypeScript
    14Norms & DistancesBuildPython, TypeScript
    15Statistics for MLBuildPython, TypeScript
    16Sampling MethodsBuildPython, TypeScript
    17Linear SystemsBuildPython, TypeScript
    18Convex OptimizationBuildPython, TypeScript
    19Complex Numbers for AILearnPython
    20The Fourier TransformBuildPython, TypeScript
    21Graph Theory for MLBuildPython, TypeScript
    22Stochastic ProcessesLearnPython
    #LessonTypeLang
    01What Is Machine LearningLearnPython
    02Linear Regression from ScratchBuildPython, Rust, Julia
    03Logistic Regression & ClassificationBuildPython, Rust, Julia
    04Decision Trees & Random ForestsBuildPython
    05Support Vector MachinesBuildPython, Julia
    06KNN & Distance MetricsBuildPython
    07Unsupervised Learning: K-Means, DBSCANBuildPython
    08Feature Engineering & SelectionBuildPython
    09Model Evaluation: Metrics, Cross-ValidationBuildPython, Julia
    10Bias, Variance & the Learning CurveLearnPython
    11Ensemble Methods: Boosting, Bagging, StackingBuildPython
    12Hyperparameter TuningBuildPython
    13ML Pipelines & Experiment TrackingBuildPython
    14Naive BayesBuildPython
    15Time Series FundamentalsBuildPython
    16Anomaly DetectionBuildPython
    17Handling Imbalanced DataBuildPython
    18Feature SelectionBuildPython
    19ML System Design — From Problem to Deployed ModelBuildPython
    20Monitoring Models in Production — Data Drift and Concept DriftBuildPython
    21Feature Stores and Training-Serving SkewBuildPython
    #LessonTypeLang
    01The Perceptron: Where It All StartedBuildPython, Rust, Julia
    02Multi-Layer Networks & Forward PassBuildPython
    03Backpropagation from ScratchBuildPython, Rust, Julia
    04Activation Functions: ReLU, Sigmoid, GELU & WhyBuildPython, Julia
    05Loss Functions: MSE, Cross-Entropy, ContrastiveBuildPython, Julia
    06Optimizers: SGD, Momentum, Adam, AdamWBuildPython
    07Regularization: Dropout, Weight Decay, BatchNormBuildPython
    08Weight Initialization & Training StabilityBuildPython
    09Learning Rate Schedules & WarmupBuildPython
    10Build Your Own Mini FrameworkBuildPython
    11Introduction to PyTorchBuildPython
    12Introduction to JAXBuildPython
    13Debugging Neural NetworksBuildPython
    #LessonTypeLang
    01Image Fundamentals: Pixels, Channels, Color SpacesLearnPython
    02Convolutions from ScratchBuildPython
    03CNNs: LeNet to ResNetBuildPython
    04Image ClassificationBuildPython
    05Transfer Learning & Fine-TuningBuildPython
    06Object Detection — YOLO from ScratchBuildPython
    07Semantic Segmentation — U-NetBuildPython
    08Instance Segmentation — Mask R-CNNBuildPython
    09Image Generation — GANsBuildPython
    10Image Generation — Diffusion ModelsBuildPython
    11Stable Diffusion — Architecture & Fine-TuningBuildPython
    12Video Understanding — Temporal ModelingBuildPython
    133D Vision: Point Clouds, NeRFsBuildPython
    14Vision Transformers (ViT)BuildPython
    15Real-Time Vision: Edge DeploymentBuildPython, Rust
    16Build a Complete Vision PipelineBuildPython
    17Self-Supervised Vision — SimCLR, DINO, MAEBuildPython
    18Open-Vocabulary Vision — CLIPBuildPython
    19OCR & Document UnderstandingBuildPython
    20Image Retrieval & Metric LearningBuildPython
    21Keypoint Detection & Pose EstimationBuildPython
    223D Gaussian Splatting from ScratchBuildPython
    23Diffusion Transformers & Rectified FlowBuildPython
    24SAM 3 & Open-Vocabulary SegmentationBuildPython
    25Vision-Language Models (ViT-MLP-LLM)BuildPython
    26Monocular Depth & Geometry EstimationBuildPython
    27Multi-Object Tracking & Video MemoryBuildPython
    28World Models & Video DiffusionBuildPython
    #LessonTypeLang
    01Text Processing: Tokenization, Stemming, LemmatizationBuildPython
    02Bag of Words, TF-IDF & Text RepresentationBuildPython
    03Word Embeddings: Word2Vec from ScratchBuildPython
    04GloVe, FastText & Subword EmbeddingsBuildPython
    05Sentiment AnalysisBuildPython
    06Named Entity Recognition (NER)BuildPython
    07POS Tagging & Syntactic ParsingBuildPython
    08Text Classification — CNNs & RNNs for TextBuildPython
    09Sequence-to-Sequence ModelsBuildPython
    10Attention Mechanism — The BreakthroughBuildPython
    11Machine TranslationBuildPython
    12Text SummarizationBuildPython
    13Question Answering SystemsBuildPython
    14Information Retrieval & SearchBuildPython
    15Topic Modeling: LDA, BERTopicBuildPython
    16Text GenerationBuildPython
    17Chatbots: Rule-Based to NeuralBuildPython
    18Multilingual NLPBuildPython
    19Subword Tokenization: BPE, WordPiece, Unigram, SentencePieceLearnPython, TypeScript
    20Structured Outputs & Constrained DecodingBuildPython
    21NLI & Textual EntailmentLearnPython
    22Embedding Models Deep DiveLearnPython
    23Chunking Strategies for RAGBuildPython, TypeScript
    24Coreference ResolutionLearnPython
    25Entity Linking & DisambiguationBuildPython
    26Relation Extraction & Knowledge Graph ConstructionBuildPython
    27LLM Evaluation: RAGAS, DeepEval, G-EvalBuildPython
    28Long-Context Evaluation: NIAH, RULER, LongBench, MRCRLearnPython
    29Dialogue State TrackingBuildPython
    #LessonTypeLang
    01Audio Fundamentals: Waveforms, Sampling, FFTLearnPython
    02Spectrograms, Mel Scale & Audio FeaturesBuildPython
    03Audio ClassificationBuildPython
    04Speech Recognition (ASR)BuildPython
    05Whisper: Architecture & Fine-TuningBuildPython
    06Speaker Recognition & VerificationBuildPython
    07Text-to-Speech (TTS)BuildPython
    08Voice Cloning & Voice ConversionBuildPython
    09Music GenerationBuildPython
    10Audio-Language ModelsBuildPython
    11Real-Time Audio ProcessingBuildPython, Rust
    12Build a Voice Assistant PipelineBuildPython
    13Neural Audio Codecs — EnCodec, SNAC, Mimi, DACLearnPython
    14Voice Activity Detection & Turn-TakingBuildPython
    15Streaming Speech-to-Speech — Moshi, HibikiLearnPython
    16Voice Anti-Spoofing & Audio WatermarkingBuildPython
    17Audio Evaluation — WER, MOS, MMAU, LeaderboardsLearnPython
    #LessonTypeLang
    01Why Transformers: The Problems with RNNsLearnPython, Julia
    02Self-Attention from ScratchBuildPython, Rust, Julia
    03Multi-Head AttentionBuildPython, Rust
    04Positional Encoding: Sinusoidal, RoPE, ALiBiBuildPython, Rust, Julia
    05The Full Transformer: Encoder + DecoderBuildPython, Julia
    06BERT — Masked Language ModelingBuildPython
    07GPT — Causal Language ModelingBuildPython
    08T5, BART — Encoder-Decoder ModelsLearnPython
    09Vision Transformers (ViT)BuildPython
    10Audio Transformers — Whisper ArchitectureLearnPython
    11Mixture of Experts (MoE)BuildPython
    12KV Cache, Flash Attention & Inference OptimizationBuildPython
    13Scaling LawsLearnPython
    14Build a Transformer from ScratchBuildPython
    15Attention Variants — Sliding Window, Sparse, DifferentialBuildPython
    16Speculative Decoding — Draft, Verify, RepeatBuildPython
    #LessonTypeLang
    01Generative Models: Taxonomy & HistoryLearnPython
    02Autoencoders & VAEBuildPython
    03GANs: Generator vs DiscriminatorBuildPython
    04Conditional GANs & Pix2PixBuildPython
    05StyleGANBuildPython
    06Diffusion Models — DDPM from ScratchBuildPython
    07Latent Diffusion & Stable DiffusionBuildPython
    08ControlNet, LoRA & ConditioningBuildPython
    09Inpainting, Outpainting & EditingBuildPython
    10Video GenerationBuildPython
    11Audio GenerationBuildPython
    123D GenerationBuildPython
    13Flow Matching & Rectified FlowsBuildPython
    14Evaluation: FID, CLIP ScoreBuildPython
    19Visual Autoregressive Modeling (VAR): Next-Scale PredictionBuildPython
    #LessonTypeLang
    01MDPs, States, Actions & RewardsLearnPython
    02Dynamic ProgrammingBuildPython
    03Monte Carlo MethodsBuildPython
    04Q-Learning, SARSABuildPython
    05Deep Q-Networks (DQN)BuildPython
    06Policy Gradients — REINFORCEBuildPython
    07Actor-Critic — A2C, A3CBuildPython
    08PPOBuildPython
    09Reward Modeling & RLHFBuildPython
    10Multi-Agent RLBuildPython
    11Sim-to-Real TransferBuildPython
    12RL for GamesBuildPython
    #LessonTypeLang
    01Tokenizers: BPE, WordPiece, SentencePieceBuildPython, Rust
    02Building a Tokenizer from ScratchBuildPython
    03Data Pipelines for Pre-TrainingBuildPython
    04Pre-Training a Mini GPT (124M)BuildPython, Rust
    05Distributed Training, FSDP, DeepSpeedBuildPython
    06Instruction Tuning — SFTBuildPython
    07RLHF — Reward Model + PPOBuildPython
    08DPO — Direct Preference OptimizationBuildPython
    09Constitutional AI & Self-ImprovementBuildPython
    10Evaluation — Benchmarks, EvalsBuildPython
    11Quantization: INT8, GPTQ, AWQ, GGUFBuildPython, Rust
    12Inference OptimizationBuildPython, Rust
    13Building a Complete LLM PipelineBuildPython
    14Open Models: Architecture WalkthroughsLearnPython
    15Speculative Decoding and EAGLE-3BuildPython
    16Differential Attention (V2)BuildPython
    17Native Sparse Attention (DeepSeek NSA)BuildPython
    18Multi-Token Prediction (MTP)BuildPython
    19DualPipe ParallelismLearnPython
    20DeepSeek-V3 Architecture WalkthroughLearnPython
    21Jamba — Hybrid SSM-TransformerLearnPython
    22Async and Hogwild! InferenceBuildPython
    25Speculative Decoding and EAGLEBuildPython
    34Gradient Checkpointing and Activation RecomputationBuildPython
    #LessonTypeLang
    01Prompt Engineering: Techniques & PatternsBuildPython, TypeScript
    02Few-Shot, CoT, Tree-of-ThoughtBuildPython
    03Structured OutputsBuildPython, TypeScript
    04Embeddings & Vector RepresentationsBuildPython, TypeScript
    05Context EngineeringBuildPython, TypeScript
    06RAG: Retrieval-Augmented GenerationBuildPython, TypeScript
    07Advanced RAG: Chunking, RerankingBuildPython
    08Fine-Tuning with LoRA & QLoRABuildPython
    09Function Calling & Tool UseBuildPython, TypeScript
    10Evaluation & TestingBuildPython
    11Caching, Rate Limiting & CostBuildPython
    12Guardrails & SafetyBuildPython, TypeScript
    13Building a Production LLM AppBuildPython
    14Model Context Protocol (MCP)BuildPython
    15Prompt Caching & Context CachingBuildPython
    16Agent State Machines — Graphs, Nodes, CheckpointsBuildPython
    17Agent Framework TradeoffsLearnPython
    #LessonTypeLang
    01Vision Transformers and the Patch-Token PrimitiveLearnPython
    02CLIP and Contrastive Vision-Language PretrainingBuildPython
    03BLIP-2 Q-Former as Modality BridgeBuildPython
    04Flamingo and Gated Cross-AttentionLearnPython
    05LLaVA and Visual Instruction TuningBuildPython
    06Any-Resolution Vision — Patch-n'-Pack and NaFlexBuildPython
    07Open-Weight VLM Recipes: What Actually MattersLearnPython
    08LLaVA-OneVision: Single, Multi, VideoBuildPython
    09Qwen-VL Family and Dynamic-FPS VideoLearnPython
    10InternVL3 Native Multimodal PretrainingLearnPython
    11Chameleon Early-Fusion Token-OnlyBuildPython
    12Emu3 Next-Token Prediction for GenerationLearnPython
    13Transfusion Autoregressive + DiffusionBuildPython
    14Show-o Discrete-Diffusion UnifiedLearnPython
    15Janus-Pro Decoupled EncodersBuildPython
    16MIO Any-to-Any StreamingLearnPython
    17Video-Language Temporal GroundingBuildPython
    18Long-Video at Million-Token ContextBuildPython
    19Audio-Language Models: Whisper to AF3BuildPython
    20Omni Models: Thinker-Talker StreamingBuildPython
    21Embodied VLAs: RT-2, OpenVLA, π0, GR00TLearnPython
    22Document and Diagram UnderstandingBuildPython
    23ColPali Vision-Native Document RAGBuildPython
    24Multimodal RAG and Cross-Modal RetrievalBuildPython
    25Multimodal Agents and Computer-Use (Capstone)BuildPython
    #LessonTypeLang
    01The Tool InterfaceLearnPython, TypeScript
    02Function Calling Deep DiveBuildPython
    03Parallel and Streaming Tool CallsBuildPython
    04Structured OutputBuildPython
    05Tool Schema DesignLearnPython
    06MCP Fundamentals: Stateless Requests and JSON-RPCLearnPython
    07Building an MCP Server: Stateless Python and TypeScriptBuildPython, TypeScript
    08Building an MCP Client: Discovery, Routing, and Dual-Era FallbackBuildPython
    09MCP Transports: stdio and Stateless Streamable HTTPLearnPython
    10MCP Resources and Prompts: Addressable Context for Stateless ServersBuildPython
    11MCP Model Input: Sampling Migration and Stateless MRTRBuildPython
    12Explicit Scope and Stateless ElicitationBuildPython
    13MCP Tasks Extension: Durable Work on a Stateless CoreBuildPython
    14MCP Apps on the Stateless ProtocolBuildPython
    15[MCP Security: Poisoned Metadata, Routing, and MRTR S