@edwordkaru: 那些天天在推特上卖几百U教人做AI Agent的博主，估计这波底裤都要被扒光了吧今天在Github刷到一个直接霸榜的硬核项目：ai-engineering-from-scratch 真不是我吹这玩意直接把市面上的付费镰刀全给撅了，40…

X AI KOLs Timeline 2026/05/25 12:42 工具

open-source ai-engineering tutorial multi-agent github free-resource

摘要

A comprehensive open-source AI engineering curriculum with 435 lessons and 20 phases covering from linear algebra to multi-agent systems, available for free on GitHub.

那些天天在推特上卖几百U教人做AI Agent的博主，估计这波底裤都要被扒光了吧今天在Github刷到一个直接霸榜的硬核项目：ai-engineering-from-scratch 真不是我吹这玩意直接把市面上的付费镰刀全给撅了，400多节课 + 20多个阶段，从基础的线性代数一路干到手搓多代理系统（Multi-Agent）最离谱的是纯开源！0付费！像咱们这种不是科班程序员，但又天天想着搞vibe coding，想自己弄几个Agent跑跑自动化脚本的，这套资源简直太对口了人家主打一个 “Learn it. Build it. Ship it” 里面的Python、TS、Rust代码全都是现成能跑的，不用在那边对着报错干瞪眼，纯纯的喂饭局！别管三七二十一先去点个Star防身吧！学不学另说白嫖顶级干货错过直接拍大腿。传送门： https://github.com/rohitg00/ai-engineering-from-scratch…

查看原文

查看缓存全文

缓存时间: 2026/05/26 19:13

那些天天在推特上卖几百U教人做AI Agent的博主，估计这波底裤都要被扒光了吧

今天在Github刷到一个直接霸榜的硬核项目：ai-engineering-from-scratch

真不是我吹这玩意直接把市面上的付费镰刀全给撅了，400多节课 + 20多个阶段，从基础的线性代数一路干到手搓多代理系统（Multi-Agent）

最离谱的是纯开源！0付费！

像咱们这种不是科班程序员，但又天天想着搞vibe coding，想自己弄几个Agent跑跑自动化脚本的，这套资源简直太对口了

人家主打一个 “Learn it. Build it. Ship it” 里面的Python、TS、Rust代码全都是现成能跑的，不用在那边对着报错干瞪眼，纯纯的喂饭局！

别管三七二十一先去点个Star防身吧！学不学另说白嫖顶级干货错过直接拍大腿。

传送门： https://github.com/rohitg00/ai-engineering-from-scratch…

rohitg00/ai-engineering-from-scratch

Source: https://github.com/rohitg00/ai-engineering-from-scratch

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

84% of students already use AI tools. Only 18% feel prepared to use them professionally. This curriculum closes that gap.

435 lessons. 20 phases. ~320 hours. Python, TypeScript, Rust, Julia. Every lesson ships a reusable artifact: a prompt, a skill, an agent, an MCP server. Free, open source, MIT.

You don’t just learn AI. You build it. End-to-end. By hand.

How this works

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. You ship a chatbot but can’t explain its loss curve. You hook a function to an agent but can’t say what attention does inside the model that’s calling it.

This curriculum is the spine. 20 phases, 435 lessons, four languages: Python, TypeScript, Rust, Julia. Linear algebra at one end, autonomous swarms at the other. Every algorithm gets built from raw math first. Backprop. Tokenizer. Attention. Agent loop. By the time PyTorch shows up, you already know what it’s doing under the hood.

Each lesson runs the same loop: read the problem, derive the math, write the code, run the test, keep the artifact. No five-minute videos, no copy-paste deploys, no hand-holding. Free, open source, and built to run on your own laptop.

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

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

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

The shape of a lesson

Each lesson lives in its own folder, with the same structure across the entire curriculum:

phases/<NN>-<phase-name>/<NN>-<lesson-name>/
├── code/      runnable implementations (Python, TypeScript, Rust, Julia)
├── docs/
│   └── en.md  lesson narrative
└── outputs/   prompts, skills, agents, or MCP servers this lesson produces

Every lesson follows six beats. The Build It / Use It split is the spine — you implement the algorithm from scratch first, then run the same thing through the production library. You understand what the framework is doing because you wrote the smaller version yourself.

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#fafaf5','primaryTextColor':'#1a1a1a','primaryBorderColor':'#3553ff','lineColor':'#3553ff','fontFamily':'JetBrains Mono','fontSize':'13px'}}}%%
flowchart LR
  M["MOTTO<br/><sub>one-line core idea</sub>"] --> Pr["PROBLEM<br/><sub>concrete pain</sub>"]
  Pr --> C["CONCEPT<br/><sub>diagrams &amp; intuition</sub>"]
  C --> B["BUILD IT<br/><sub>raw math, no frameworks</sub>"]
  B --> U["USE IT<br/><sub>same thing in PyTorch / sklearn</sub>"]
  U --> S["SHIP IT<br/><sub>prompt · skill · agent · MCP</sub>"]

Getting started

Three ways in. Pick one.

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

Option B — clone and run.

git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch
python phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

Option C — find your level (recommended). Skip ahead intelligently. Inside Claude, Cursor, Codex, OpenClaw, Hermes, or any agent with the curriculum skills installed:

/find-your-level

Ten questions. Maps your knowledge to a starting phase, builds a personalized path with hour estimates. After each phase:

/check-understanding 3        # quiz yourself on phase 3
ls phases/03-deep-learning-core/05-loss-functions/outputs/
# ├── prompt-loss-function-selector.md
# └── prompt-loss-debugger.md

Prerequisites

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

Built-in agent skills (Claude, Cursor, Codex, OpenClaw, Hermes)

Skill	What it does
`/find-your-level`	Ten-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.

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Every lesson ships something

Other curricula end with “congratulations, you learned X.” Each lesson here ends with a reusable tool you can install or paste into your daily workflow.

_{FIG_001 · A} PROMPTS	_{FIG_001 · B} SKILLS	_{FIG_001 · C} AGENTS	_{FIG_001 · D} MCP SERVERS
Paste into any AI assistant for expert-level help on a narrow task.	Drop into Claude, Cursor, Codex, OpenClaw, Hermes, or any agent that reads `SKILL.md`.	Deploy as autonomous workers — you wrote the loop yourself in Phase 14.	Plug into any MCP-compatible client. Built end-to-end in Phase 13.

Install the lot with python3 scripts/install_skills.py. Real tools, not homework. By the end of the curriculum, you have a portfolio of 435 artifacts you actually understand because you built them.

FIG_002 · A worked sample

Phase 14, lesson 1: the agent loop. ~120 lines of pure Python, no dependencies.

code/agent_loop.py _{build it}

def run(query, tools):
    history = [user(query)]
    for step in range(MAX_STEPS):
        msg = llm(history)
        if msg.tool_calls:
            for call in msg.tool_calls:
                result = tools[call.name](**call.args)
                history.append(tool_result(call.id, result))
            continue
        return msg.content
    raise StepLimitExceeded

outputs/skill-agent-loop.md _{ship it}

---
name: agent-loop
description: ReAct-style loop for any tool list
phase: 14
lesson: 01
---

Implement a minimal agent loop that...

outputs/prompt-debug-agent.md

You are an agent debugger. Given the trace
of an agent run, identify the step where
the agent went wrong and explain why...

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

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

Phase 0: Setup & Tooling `12 lessons`

Get your environment ready for everything that follows.

#	Lesson	Type	Lang
01	Dev Environment	Build	Python
02	Git & Collaboration	Learn	—
03	GPU Setup & Cloud	Build	Python
04	APIs & Keys	Build	Python
05	Jupyter Notebooks	Build	Python
06	Python Environments	Build	Shell
07	Docker for AI	Build	Docker
08	Editor Setup	Build	—
09	Data Management	Build	Python
10	Terminal & Shell	Learn	—
11	Linux for AI	Learn	—
12	Debugging & Profiling	Build	Python

Phase 1 — Math Foundations 22 lessons The intuition behind every AI algorithm, through code.

#	Lesson	Type	Lang
01	Linear Algebra Intuition	Learn	Python, Julia
02	Vectors, Matrices & Operations	Build	Python, Julia
03	Matrix Transformations & Eigenvalues	Build	Python, Julia
04	Calculus for ML: Derivatives & Gradients	Learn	Python
05	Chain Rule & Automatic Differentiation	Build	Python
06	Probability & Distributions	Learn	Python
07	Bayes’ Theorem & Statistical Thinking	Build	Python
08	Optimization: Gradient Descent Family	Build	Python
09	Information Theory: Entropy, KL Divergence	Learn	Python
10	Dimensionality Reduction: PCA, t-SNE, UMAP	Build	Python
11	Singular Value Decomposition	Build	Python, Julia
12	Tensor Operations	Build	Python
13	Numerical Stability	Build	Python
14	Norms & Distances	Build	Python
15	Statistics for ML	Build	Python
16	Sampling Methods	Build	Python
17	Linear Systems	Build	Python
18	Convex Optimization	Build	Python
19	Complex Numbers for AI	Learn	Python
20	The Fourier Transform	Build	Python
21	Graph Theory for ML	Build	Python
22	Stochastic Processes	Learn	Python

Phase 2 — ML Fundamentals 18 lessons Classical ML — still the backbone of most production AI.

#	Lesson	Type	Lang
01	What Is Machine Learning	Learn	Python
02	Linear Regression from Scratch	Build	Python
03	Logistic Regression & Classification	Build	Python
04	Decision Trees & Random Forests	Build	Python
05	Support Vector Machines	Build	Python
06	KNN & Distance Metrics	Build	Python
07	Unsupervised Learning: K-Means, DBSCAN	Build	Python
08	Feature Engineering & Selection	Build	Python
09	Model Evaluation: Metrics, Cross-Validation	Build	Python
10	Bias, Variance & the Learning Curve	Learn	Python
11	Ensemble Methods: Boosting, Bagging, Stacking	Build	Python
12	Hyperparameter Tuning	Build	Python
13	ML Pipelines & Experiment Tracking	Build	Python
14	Naive Bayes	Build	Python
15	Time Series Fundamentals	Build	Python
16	Anomaly Detection	Build	Python
17	Handling Imbalanced Data	Build	Python
18	Feature Selection	Build	Python

Phase 3 — Deep Learning Core 13 lessons Neural networks from first principles. No frameworks until you build one.

#	Lesson	Type	Lang
01	The Perceptron: Where It All Started	Build	Python
02	Multi-Layer Networks & Forward Pass	Build	Python
03	Backpropagation from Scratch	Build	Python
04	Activation Functions: ReLU, Sigmoid, GELU & Why	Build	Python
05	Loss Functions: MSE, Cross-Entropy, Contrastive	Build	Python
06	Optimizers: SGD, Momentum, Adam, AdamW	Build	Python
07	Regularization: Dropout, Weight Decay, BatchNorm	Build	Python
08	Weight Initialization & Training Stability	Build	Python
09	Learning Rate Schedules & Warmup	Build	Python
10	Build Your Own Mini Framework	Build	Python
11	Introduction to PyTorch	Build	Python
12	Introduction to JAX	Build	Python
13	Debugging Neural Networks	Build	Python

Phase 4 — Computer Vision 28 lessons From pixels to understanding — image, video, 3D, VLMs, and world models.

#	Lesson	Type	Lang
01	Image Fundamentals: Pixels, Channels, Color Spaces	Learn	Python
02	Convolutions from Scratch	Build	Python
03	CNNs: LeNet to ResNet	Build	Python
04	Image Classification	Build	Python
05	Transfer Learning & Fine-Tuning	Build	Python
06	Object Detection — YOLO from Scratch	Build	Python
07	Semantic Segmentation — U-Net	Build	Python
08	Instance Segmentation — Mask R-CNN	Build	Python
09	Image Generation — GANs	Build	Python
10	Image Generation — Diffusion Models	Build	Python
11	Stable Diffusion — Architecture & Fine-Tuning	Build	Python
12	Video Understanding — Temporal Modeling	Build	Python
13	3D Vision: Point Clouds, NeRFs	Build	Python
14	Vision Transformers (ViT)	Build	Python
15	Real-Time Vision: Edge Deployment	Build	Python
16	Build a Complete Vision Pipeline	Build	Python
17	Self-Supervised Vision — SimCLR, DINO, MAE	Build	Python
18	Open-Vocabulary Vision — CLIP	Build	Python
19	OCR & Document Understanding	Build	Python
20	Image Retrieval & Metric Learning	Build	Python
21	Keypoint Detection & Pose Estimation	Build	Python
22	3D Gaussian Splatting from Scratch	Build	Python
23	Diffusion Transformers & Rectified Flow	Build	Python
24	SAM 3 & Open-Vocabulary Segmentation	Build	Python
25	Vision-Language Models (ViT-MLP-LLM)	Build	Python
26	Monocular Depth & Geometry Estimation	Build	Python
27	Multi-Object Tracking & Video Memory	Build	Python
28	World Models & Video Diffusion	Build	Python

Phase 5 — NLP: Foundations to Advanced 29 lessons Language is the interface to intelligence.

#	Lesson	Type	Lang
01	Text Processing: Tokenization, Stemming, Lemmatization	Build	Python
02	Bag of Words, TF-IDF & Text Representation	Build	Python
03	Word Embeddings: Word2Vec from Scratch	Build	Python
04	GloVe, FastText & Subword Embeddings	Build	Python
05	Sentiment Analysis	Build	Python
06	Named Entity Recognition (NER)	Build	Python
07	POS Tagging & Syntactic Parsing	Build	Python
08	Text Classification — CNNs & RNNs for Text	Build	Python
09	Sequence-to-Sequence Models	Build	Python
10	Attention Mechanism — The Breakthrough	Build	Python
11	Machine Translation	Build	Python
12	Text Summarization	Build	Python
13	Question Answering Systems	Build	Python
14	Information Retrieval & Search	Build	Python
15	Topic Modeling: LDA, BERTopic	Build	Python
16	Text Generation	Build	Python
17	Chatbots: Rule-Based to Neural	Build	Python
18	Multilingual NLP	Build	Python
19	Subword Tokenization: BPE, WordPiece, Unigram, SentencePiece	Learn	Python
20	Structured Outputs & Constrained Decoding	Build	Python
21	NLI & Textual Entailment	Learn	Python
22	Embedding Models Deep Dive	Learn	Python
23	Chunking Strategies for RAG	Build	Python
24	Coreference Resolution	Learn	Python
25	Entity Linking & Disambiguation	Build	Python
26	Relation Extraction & Knowledge Graph Construction	Build	Python
27	LLM Evaluation: RAGAS, DeepEval, G-Eval	Build	Python
28	Long-Context Evaluation: NIAH, RULER, LongBench, MRCR	Learn	Python
29	Dialogue State Tracking	Build	Python

Phase 6 — Speech & Audio 17 lessons Hear, understand, speak.

#	Lesson	Type	Lang
01	Audio Fundamentals: Waveforms, Sampling, FFT	Learn	Python
02	Spectrograms, Mel Scale & Audio Features	Build	Python
03	Audio Classification	Build	Python
04	Speech Recognition (ASR)	Build	Python
05	Whisper: Architecture & Fine-Tuning	Build	Python
06	Speaker Recognition & Verification	Build	Python
07	Text-to-Speech (TTS)	Build	Python
08	Voice Cloning & Voice Conversion	Build	Python
09	Music Generation	Build	Python
10	Audio-Language Models	Build	Python
11	Real-Time Audio Processing	Build	Python
12	Build a Voice Assistant Pipeline	Build	Python
13	Neural Audio Codecs — EnCodec, SNAC, Mimi, DAC	Learn	Python
14	Voice Activity Detection & Turn-Taking	Build	Python
15	Streaming Speech-to-Speech — Moshi, Hibiki	Learn	Python
16	Voice Anti-Spoofing & Audio Watermarking	Build	Python
17	Audio Evaluation — WER, MOS, MMAU, Leaderboards	Learn	Python

Phase 7 — Transformers Deep Dive 14 lessons The architecture that changed everything.

#	Lesson	Type	Lang
01	Why Transformers: The Problems with RNNs	Learn	Python
02	Self-Attention from Scratch	Build	Python
03	Multi-Head Attention	Build	Python
04	Positional Encoding: Sinusoidal, RoPE, ALiBi	Build	Python
05	The Full Transformer: Encoder + Decoder	Build	Python
06	BERT — Masked Language Modeling	Build	Python
07	GPT — Causal Language Modeling	Build	Python
08	T5, BART — Encoder-Decoder Models	Learn	Python
09	Vision Transformers (ViT)	Build	Python
10	Audio Transformers — Whisper Architecture	Learn	Python
11	Mixture of Experts (MoE)	Build	Python
12	KV Cache, Flash Attention & Inference Optimization	Build	Python
13	Scaling Laws	Learn	Python
14	Build a Transformer from Scratch	Build	Python

Phase 8 — Generative AI 14 lessons Create images, video, audio, 3D, and more.

#	Lesson	Type	Lang
01	Generative Models: Taxonomy & History	Learn	Python
02	Autoencoders & VAE	Build	Python
03	GANs: Generator vs Discriminator	Build	Python
04	Conditional GANs & Pix2Pix	Build	Python
05	StyleGAN	Build	Python
06	Diffusion Models — DDPM from Scratch	Build	Python
07	Latent Diffusion & Stable Diffusion	Build	Python
08	ControlNet, LoRA & Conditioning	Build	Python
09	Inpainting, Outpainting & Editing	Build	Python
10	Video Generation	Build	Python
11	Audio Generation	Build	Python
12	3D Generation	Build	Python
13	Flow Matching & Rectified Flows	Build	Python
14	Evaluation: FID, CLIP Score	Build	Python

Phase 9 — Reinforcement Learning 12 lessons The foundation of RLHF and game-playing AI.

#	Lesson	Type	Lang
01	MDPs, States, Actions & Rewards	Learn	Python
02	Dynamic Programming	Build	Python
03	Monte Carlo Methods	Build	Python
04	Q-Learning, SARSA	Build	Python
05	Deep Q-Networks (DQN)	Build	Python
06	Policy Gradients — REINFORCE	Build	Python
07	Actor-Critic — A2C, A3C	Build	Python
08	PPO	Build	Python
09	Reward Modeling & RLHF	Build	Python
10	Multi-Agent RL	Build	Python
11	Sim-to-Real Transfer	Build	Python
12	RL for Games	Build	Python

Phase 10 — LLMs from Scratch 22 lessons Build, train, and understand large language models.

#	Lesson	Type	Lang
01	Tokenizers: BPE, WordPiece, SentencePiece	Build	Python, Rust
02	Building a Tokenizer from Scratch	Build	Python
03	Data Pipelines for Pre-Training	Build	Python
04	Pre-Training a Mini GPT (124M)	Build	Python
05	Distributed Training, FSDP, DeepSpeed	Build	Python
06	Instruction Tuning — SFT	Build	Python
07	RLHF — Reward Model + PPO	Build	Python
08	DPO — Direct Preference Optimization	Build	Python
09	Constitutional AI & Self-Improvement	Build	Python
10	Evaluation — Benchmarks, Evals	Build	Python
11	Quantization: INT8, GPTQ, AWQ, GGUF	Build	Python
12	Inference Optimization	Build	Python
13	Building a Complete LLM Pipeline	Build	Python
14	Open Models: Architecture Walkthroughs	Learn	Python
15	Speculative Decoding and EAGLE-3	Build	Python
16	Differential Attention (V2)	Build	Python
17	Native Sparse Attention (DeepSeek NSA)	Build	Python
18	Multi-Token Prediction (MTP)	Build	Python
19	DualPipe Parallelism	Learn	Python
20	DeepSeek-V3 Architecture Walkthrough	Learn	Python
21	Jamba — Hybrid SSM-Transformer	Learn	Python
22	Async and Hogwild! Inference	Build	Python

Phase 11 — LLM Engineering 17 lessons Put LLMs to work in production.

#	Lesson	Type	Lang
01	Prompt Engineering: Techniques & Patterns	Build	Python
02	Few-Shot, CoT, Tree-of-Thought	Build	Python
03	Structured Outputs	Build	Python
04	Embeddings & Vector Representations	Build	Python
05	Context Engineering	Build	Python
06	RAG: Retrieval-Augmented Generation	Build	Python
07	Advanced RAG: Chunking, Reranking	Build	Python
08	Fine-Tuning with LoRA & QLoRA	Build	Python
09	Function Calling & Tool Use	Build	Python
10	Evaluation & Testing	Build	Python
11	Caching, Rate Limiting & Cost	Build	Python
12	Guardrails & Safety	Build	Python
13	Building a Production LLM App	Build	Python
14	Model Context Protocol (MCP)	Build	Python
15	Prompt Caching & Context Caching	Build	Python
16	LangGraph: State Machines for Agents	Build	Python
17	Agent Framework Tradeoffs	Learn	Python

Phase 12 — Multimodal AI 25 lessons See, hear, read, and reason across modalities — from ViT patches to computer-use agents.

#	Lesson	Type	Lang
01	Vision Transformers and the Patch-Token Primitive	Learn	Python
02	CLIP and Contrastive Vision-Language Pretraining	Build	Python
03	BLIP-2 Q-Former as Modality Bridge	Build	Python
04	Flamingo and Gated Cross-Attention	Learn	Python
05	LLaVA and Visual Instruction Tuning	Build	Python
06	Any-Resolution Vision — Patch-n’-Pack and NaFlex	Build	Python
07	Open-Weight VLM Recipes: What Actually Matters	Learn	Python
08	LLaVA-OneVision: Single, Multi, Video	Build	Python
09	Qwen-VL Family and Dynamic-FPS Video	Learn	Python
10	InternVL3 Native Multimodal Pretraining	Learn	Python
11	Chameleon Early-Fusion Token-Only	Build	Python
12	Emu3 Next-Token Prediction for Generation	Learn	Python
13	Transfusion Autoregressive + Diffusion	Build	Python
14	Show-o Discrete-Diffusion Unified	Learn	Python
15	Janus-Pro Decoupled Encoders	Build	Python
16	MIO Any-to-Any Streaming	Learn	Python
17	Video-Language Temporal Grounding	Build	Python
18	Long-Video at Million-Token Context	Build	Python
19	Audio-Language Models: Whisper to AF3	Build	Python
20	Omni Models: Thinker-Talker Streaming	Build	Python
21	Embodied VLAs: RT-2, OpenVLA, π0, GR00T	Learn	Python
22	Document and Diagram Understanding	Build	Python
23	ColPali Vision-Native Document RAG	Build	Python
24	Multimodal RAG and Cross-Modal Retrieval	Build	Python
25	Multimodal Agents and Computer-Use (Capstone)	Build	Python

Phase 13 — Tools & Protocols 23 lessons The interfaces between AI and the real world.

#	Lesson	Type	Lang
01	The Tool Interface	Learn	Python
02	Function Calling Deep Dive	Build	Python
03	Parallel and Streaming Tool Calls	Build	Python
04	Structured Output	Build	Python
05	Tool Schema Design	Learn	Python
06	MCP Fundamentals	Learn	Python
07	Building an MCP Server	Build	Python
08	Building an MCP Client	Build	Python
09	MCP Transports	Learn	Python
10	MCP Resources and Prompts	Build	Python
11	MCP Sampling	Build	Python
12	MCP Roots and Elicitation	Build	Python
13	MCP Async Tasks	Build	Python
14	MCP Apps	Build	Python
15	MCP Security I — Tool Poisoning	Learn	Python
16	MCP Security II — OAuth 2.1	Build	Python
17	MCP Gateways and Registries	Learn	Python
18	MCP Auth in Production — DCR + JWKS on iii	Build	Python
19	A2A Protocol	Build	Python
20	OpenTelemetry GenAI	Build	Python
21	LLM Routing Layer	Learn	Python
22	Skills and Agent SDKs	Learn	Python
23	Capstone — Tool Ecosystem	Build	Python

Phase 14 — Agent Engineering 42 lessons Build agents from first principles — loop, memory, planning, frameworks, benchmarks, production, workbench.

#	Lesson	Type	Lang
01	The Agent Loop	Build	Python
02	ReWOO and Plan-and-Execute	Build	Python
03	Reflexion and Verbal Reinforcement Learning	Build	Python
04	Tree of Thoughts and LATS	Build	Python
05	Self-Refine and CRITIC	Build	Python
06	Tool Use and Function Calling	Build	Python
07	Memory — Virtual Context and MemGPT	Build	Python
08	Memory Blocks and Sleep-Time Compute	Build	Python
09	Hybrid Memory — Mem0 Vector + Graph + KV	Build	Python
10	Skill Libraries and Lifelong Learning — Voyager	Build	Python
11	Planning with HTN and Evolutionary Search	Build	Python
12	Anthropic’s Workflow Patterns	Build	Python
13	LangGraph — Stateful Graphs and Durable Execution	Build	Python
14	AutoGen v0.4 — Actor Model	Build	Python
15	CrewAI — Role-Based Crews and Flows	Build	Python
16	OpenAI Agents SDK — Handoffs, Guardrails, Tracing	Build	Python
17	Claude Agent SDK — Subagents and Session Store	Build	Python
18	Agno and Mastra — Production Runtimes	Learn	Python
19	Benchmarks — SWE-bench, GAIA, AgentBench	Learn	Python
20	Benchmarks — WebArena and OSWorld	Learn	Python
21	Computer Use — Claude, OpenAI CUA, Gemini	Build	Python
22	Voice Agents — Pipecat and LiveKit	Build	Python
23	OpenTelemetry GenAI Semantic Conventions	Build	Python
24	Agent Observability — Langfuse, Phoenix, Opik	Learn	Python
25	Multi-Agent Debate and Collaboration	Build	Python
26	Failure Modes — Why Agents Break	Build	Python
27	Prompt Injection and the PVE Defense	Build	Python
28	Orchestration Patterns — Supervisor, Swarm, Hierarchical	Build	Python
29	Production Runtimes — Queue, Event, Cron	Learn	Python
30	Eval-Driven Agent Development	Build	Python
31	Agent Workbench: Why Capable Models Still Fail	Learn	Python
32	The Minimal Agent Workbench	Build	Python
33	Agent Instructions as Executable Constraints	Build	Python
34	Repo Memory and Durable State	Build	Python
35	Initialization Scripts for Agents	Build	Python
36	Scope Contracts and Task Boundaries	Build	Python
37	Runtime Feedback Loops	Build	Python
38	Verification Gates	Build	Python
39	Reviewer Agent: Separate Builder from Marker	Build	Python
40	Multi-Session Handoff	Build	Python
41	The Workbench on a Real Repo	Build	Python
42	Capstone: Ship a Reusable Agent Workbench Pack	Build	Python

Each Phase 14 workbench lesson (31-42) ships a mission.md briefing the agent before it opens the full lesson docs.

Phase 15 — Autonomous Systems 22 lessons Long-horizon agents, self-improvement, and the 2026 safety stack.

#	Lesson	Type	Lang
01	From Chatbots to Long-Horizon Agents (METR)	Learn	Python
02	STaR, V-STaR, Quiet-STaR: Self-Taught Reasoning	Learn	Python
03	AlphaEvolve: Evolutionary Coding Agents	Learn	Python
04	Darwin Gödel Machine: Self-Modifying Agents	Learn	Python
05	AI Scientist v2: Workshop-Level Research	Learn	Python
06	Automated Alignment Research (Anthropic AAR)	Learn	Python
07	Recursive Self-Improvement: Capability vs Alignment	Learn	Python
08	Bounded Self-Improvement Designs	Learn	Python
09	Autonomous Coding Agent Landscape (SWE-bench, CodeAct)	Learn	Python
10	Claude Code Permission Modes and Auto Mode	Learn	Python
11	Browser Agents and Indirect Prompt Injection	Learn	Python
12	Durable Execution for Long-Running Agents	Learn	Python
13	Action Budgets, Iteration Caps, Cost Governors	Learn	Python
14	Kill Switches, Circuit Breakers, Canary Tokens	Learn	Python
15	HITL: Propose-Then-Commit	Learn	Python
16	Checkpoints and Rollback	Learn	Python
17	Constitutional AI and Rule Overrides	Learn	Python
18	Llama Guard and Input/Output Classification	Learn	Python
19	Anthropic Responsible Scaling Policy v3.0	Learn	Python
20	OpenAI Preparedness Framework and DeepMind FSF	Learn	Python
21	METR Time Horizons and External Evaluation	Learn	Python
22	CAIS, CAISI, and Societal-Scale Risk	Learn	Python

Phase 16 — Multi-Agent & Swarms 25 lessons Coordination, emergence, and collective intelligence.

#	Lesson	Type	Lang
01	Why Multi-Agent	Learn	TypeScript
02	FIPA-ACL Heritage and Speech Acts	Learn	Python
03	Communication Protocols	Build	TypeScript
04	The Multi-Agent Primitive Model	Learn	Python
05	Supervisor / Orchestrator-Worker Pattern	Build	Python
06	Hierarchical Architecture and Decomposition Drift	Learn	Python
07	Society of Mind and Multi-Agent Debate	Build	Python
08	Role Specialization — Planner / Critic / Executor / Verifier	Build	Python
09	Parallel Swarm and Networked Architectures	Build	Python
10	Group Chat and Speaker Selection	Build	Python
11	Handoffs and Routines (Stateless Orchestration)	Build	Python
12	A2A — The Agent-to-Agent Protocol	Build	Python
13	Shared Memory and Blackboard Patterns	Build	Python
14	Consensus and Byzantine Fault Tolerance	Build	Python
15	Voting, Self-Consistency, and Debate Topology	Build	Python
16	Negotiation and Bargaining	Build	Python
17	Generative Agents and Emergent Simulation	Build	Python
18	Theory of Mind and Emergent Coordination	Build	Python
19	Swarm Optimization (PSO, ACO)	Build	Python
20	MARL — MADDPG, QMIX, MAPPO	Learn	Python
21	Agent Economies, Token Incentives, Reputation	Learn	Python
22	Production Scaling — Queues, Checkpoints, Durability	Build	Python
23	Failure Modes — MAST, Groupthink, Monoculture	Learn	Python
24	Evaluation and Coordination Benchmarks	Learn	Python
25	Case Studies and 2026 State of the Art	Learn	Python

Phase 17 — Infrastructure & Production 28 lessons Ship AI to the real world.

#	Lesson	Type	Lang
01	Managed LLM Platforms — Bedrock, Azure OpenAI, Vertex AI	Learn	Python
02	Inference Platform Economics — Fireworks, Together, Baseten, Modal	Learn	Python
03	GPU Autoscaling on Kubernetes — Karpenter, KAI Scheduler	Learn	Python
04	vLLM Serving Internals — PagedAttention, Continuous Batching, Chunked Prefill	Learn	Python
05	EAGLE-3 Speculative Decoding in Production	Learn	Python
06	SGLang and RadixAttention for Prefix-Heavy Workloads	Learn	Python
07	TensorRT-LLM on Blackwell with FP8 and NVFP4	Learn	Python
08	Inference Metrics — TTFT, TPOT, ITL, Goodput, P99	Learn	Python
09	Production Quantization — AWQ, GPTQ, GGUF, FP8, NVFP4	Learn	Python
10	Cold Start Mitigation for Serverless LLMs	Learn	Python
11	Multi-Region LLM Serving and KV Cache Locality	Learn	Python
12	Edge Inference — ANE, Hexagon, WebGPU, Jetson	Learn	Python
13	LLM Observability Stack Selection	Learn	Python
14	Prompt Caching and Semantic Caching Economics	Learn	Python
15	Batch APIs — the 50% Discount as Industry Standard	Learn	Python
16	Model Routing as a Cost-Reduction Primitive	Learn	Python
17	Disaggregated Prefill/Decode — NVIDIA Dynamo and llm-d	Learn	Python
18	vLLM Production Stack with LMCache KV Offloading	Learn	Python
19	AI Gateways — LiteLLM, Portkey, Kong, Bifrost	Learn	Python
20	Shadow, Canary, and Progressive Deployment	Learn	Python
21	A/B Testing LLM Features — GrowthBook and Statsig	Learn	Python
22	Load Testing LLM APIs — k6, LLMPerf, GenAI-Perf	Build	Python
23	SRE for AI — Multi-Agent Incident Response	Learn	Python
24	Chaos Engineering for LLM Production	Learn	Python
25	Security — Secrets, PII Scrubbing, Audit Logs	Learn	Python
26	Compliance — SOC 2, HIPAA, GDPR, EU AI Act, ISO 42001	Learn	Python
27	FinOps for LLMs — Unit Economics and Multi-Tenant Attribution	Learn	Python
28	Self-Hosted Serving Selection — llama.cpp, Ollama, TGI, vLLM, SGLang	Learn	Python

Phase 18 — Ethics, Safety & Alignment 30 lessons Build AI that helps humanity. Not optional.

#	Lesson	Type	Lang
01	Instruction-Following as Alignment Signal	Learn	Python
02	Reward Hacking & Goodhart’s Law	Learn	Python
03	Direct Preference Optimization Family	Learn	Python
04	Sycophancy as RLHF Amplification	Learn	Python
05	Constitutional AI & RLAIF	Learn	Python
06	Mesa-Optimization & Deceptive Alignment	Learn	Python
07	Sleeper Agents — Persistent Deception	Learn	Python
08	In-Context Scheming in Frontier Models	Learn	Python
09	Alignment Faking	Learn	Python
10	AI Control — Safety Despite Subversion	Learn	Python
11	Scalable Oversight & Weak-to-Strong	Learn	Python
12	Red-Teaming: PAIR & Automated Attacks	Build	Python
13	Many-Shot Jailbreaking	Learn	Python
14	ASCII Art & Visual Jailbreaks	Build	Python
15	Indirect Prompt Injection	Build	Python
16	Red-Team Tooling: Garak, Llama Guard, PyRIT	Build	Python
17	WMDP & Dual-Use Capability Evaluation	Learn	Python
18	Frontier Safety Frameworks — RSP, PF, FSF	Learn	Python
19	Model Welfare Research	Learn	Python
20	Bias & Representational Harm	Build	Python
21	Fairness Criteria: Group, Individual, Counterfactual	Learn	Python
22	Differential Privacy for LLMs	Build	Python
23	Watermarking: SynthID, Stable Signature, C2PA	Build	Python
24	Regulatory Frameworks: EU, US, UK, Korea	Learn	Python
25	EchoLeak & CVEs for AI	Learn	Python
26	Model, System & Dataset Cards	Build	Python
27	Data Provenance & Training-Data Governance	Learn	Python
28	Alignment Research Ecosystem: MATS, Redwood, Apollo, METR	Learn	Python
29	Moderation Systems: OpenAI, Perspective, Llama Guard	Build	Python
30	Dual-Use Risk: Cyber, Bio, Chem, Nuclear	Learn	Python

Phase 19 — Capstone Projects 17 projects 2026 end-to-end shippable products, 20-40 hours each.

#	Project	Combines	Lang
01	Terminal-Native Coding Agent	P0 P5 P7 P10 P11 P13 P14 P15 P17 P18	Python
02	RAG over Codebase (Cross-Repo Semantic Search)	P5 P7 P11 P13 P17	Python
03	Real-Time Voice Assistant (ASR → LLM → TTS)	P6 P7 P11 P13 P14 P17	Python
04	Multimodal Document QA (Vision-First)	P4 P5 P7 P11 P12 P17	Python
05	Autonomous Research Agent (AI-Scientist Class)	P0 P2 P3 P7 P10 P14 P15 P16 P18	Python
06	DevOps Troubleshooting Agent for Kubernetes	P11 P13 P14 P15 P17 P18	Python
07	End-to-End Fine-Tuning Pipeline	P2 P3 P7 P10 P11 P17 P18	Python
08	Production RAG Chatbot (Regulated Vertical)	P5 P7 P11 P12 P17 P18	Python
09	Code Migration Agent (Repo-Level Upgrade)	P5 P7 P11 P13 P14 P15 P17	Python
10	Multi-Agent Software Engineering Team	P11 P13 P14 P15 P16 P17	Python
11	LLM Observability & Eval Dashboard	P11 P13 P17 P18	Python
12	Video Understanding Pipeline (Scene → QA)	P4 P6 P7 P11 P12 P17	Python
13	MCP Server with Registry and Governance	P11 P13 P14 P17 P18	Python
14	Speculative-Decoding Inference Server	P3 P7 P10 P17	Python
15	Constitutional Safety Harness + Red-Team Range	P10 P11 P13 P14 P18	Python
16	GitHub Issue-to-PR Autonomous Agent	P11 P13 P14 P15 P17	Python
17	Personal AI Tutor (Adaptive, Multimodal)	P5 P6 P11 P12 P14 P17 P18	Python

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

The toolkit

Every lesson produces a reusable artifact. By the end you have:

outputs/
├── prompts/      prompt templates for every AI task
└── skills/       SKILL.md files for AI coding agents

Install them with npx skills add. Plug them into Claude, Cursor, Codex, OpenClaw, Hermes, or any agent that reads a SKILL.md / AGENTS.md directory. Real tools, not homework.

Install every course skill into your agent

The repo ships 378 skills and 99 prompts under phases/**/outputs/.

Recommended: install via skills.sh. No clone, no Python, detects your agent’s skills directory automatically:

npx skills add rohitg00/ai-engineering-from-scratch                       # every skill
npx skills add rohitg00/ai-engineering-from-scratch --skill agent-loop    # one skill
npx skills add rohitg00/ai-engineering-from-scratch --phase 14            # one phase

skills writes to whichever directory your agent picks up: .claude/skills/, .cursor/skills/, .codex/skills/, OpenClaw’s skills folder, Hermes’s bundle path, or any SKILL.md-aware tool. One command, every agent.

Advanced: offline / custom layout via scripts/install_skills.py. Requires cloning the repo. Useful when you need tag filters, dry-runs, or a non-default layout:

python3 scripts/install_skills.py <target>                                 # every skill, default --layout skills (nested)
python3 scripts/install_skills.py <target> --layout skills                 # same as above, explicit
python3 scripts/install_skills.py <target> --type all                      # skills + prompts + agents
python3 scripts/install_skills.py <target> --phase 14                      # one phase only
python3 scripts/install_skills.py <target> --tag rag                       # filter by tag
python3 scripts/install_skills.py <target> --layout flat                   # flat files
python3 scripts/install_skills.py <target> --dry-run                       # preview without writing
python3 scripts/install_skills.py <target> --force                         # overwrite existing files

<target> is the skills directory for your agent (examples: ~/.claude/skills/, ~/.cursor/skills/, ~/.config/openclaw/skills/, .skills/, or any path your agent reads).

By default the script refuses to overwrite an existing destination and exits with code 1 after listing every colliding path. Use --dry-run to preview collisions or --force to overwrite. Every non-dry-run run writes a manifest.json in the target with the full inventory grouped by type and phase. Pick the layout your agent reads:

`--layout`	Path written
`skills`	`<target>/<name>/SKILL.md` (nested convention, supported by Claude / Cursor / Codex / OpenClaw / Hermes)
`by-phase`	`<target>/phase-NN/<name>.md`
`flat`	`<target>/<name>.md`

Drop the agent workbench into your own repo

The Phase 14 capstone ships a reusable Agent Workbench pack (AGENTS.md, schemas, init / verify / handoff scripts). Scaffold it into any repo with:

python3 scripts/scaffold_workbench.py path/to/your-repo            # full pack + seeds
python3 scripts/scaffold_workbench.py path/to/your-repo --minimal  # skip docs/
python3 scripts/scaffold_workbench.py path/to/your-repo --dry-run  # preview only
python3 scripts/scaffold_workbench.py path/to/your-repo --force    # overwrite

You get the seven workbench surfaces wired up, a starter task_board.json, and a fresh agent_state.json at schema_version: 1. From there: edit the task, edit AGENTS.md, run scripts/init_agent.py, hand the contract to your agent. The pack source lives at phases/14-agent-engineering/42-agent-workbench-capstone/outputs/agent-workbench-pack/.

Browse the entire course as JSON

scripts/build_catalog.py walks every phase, every lesson, every artifact on disk and writes catalog.json at the repo root. One file, every course truth.

python3 scripts/build_catalog.py               # writes <repo>/catalog.json
python3 scripts/build_catalog.py --stdout      # to stdout, do not touch repo
python3 scripts/build_catalog.py --out path/to/file.json

The catalog is filesystem-derived, not README-derived, so counts always match what is actually on disk. Use it for site builds, downstream tooling, or to verify the README counts have not drifted. Schema is documented at the top of the script.

A GitHub Action (.github/workflows/curriculum.yml) rebuilds catalog.json on every PR and fails the build if the committed file is stale. After editing any lesson, run python3 scripts/build_catalog.py and commit the result, or CI will reject the PR. The same workflow runs audit_lessons.py in warn-only mode (so existing drift does not block contributors).

Smoke-check every lesson’s Python code

scripts/lesson_run.py byte-compiles every .py file under each lesson’s code/ directory. Default mode is syntax-check only — no execution, no API keys, no heavy ML deps required. Catches the regressions contributors introduce most often (bad indentation, broken f-strings, stray edits).

python3 scripts/lesson_run.py                  # syntax-check the whole curriculum
python3 scripts/lesson_run.py --phase 14       # one phase only
python3 scripts/lesson_run.py --json           # JSON report on stdout
python3 scripts/lesson_run.py --strict         # exit 1 if any lesson fails
python3 scripts/lesson_run.py --execute        # actually run, 10s timeout per lesson

--execute runs each lesson’s code/main.py (or the first .py file) with a 10-second timeout. Lessons whose entry file starts with a # requires: pkg1, pkg2 comment listing non-stdlib deps are skipped with reason needs <deps>. The script is opt-in and not wired into CI.

Stdlib only, Python 3.10+. Set LINK_CHECK_SKIP=domain1,domain2 to override the default skip-list (twitter.com, x.com, linkedin.com, instagram.com, medium.com — domains that aggressively block automated HEAD/GET).

Where to start

Background	Start at	Estimated time
New to programming and AI	Phase 0 — Setup	~306 hours
Know Python, new to ML	Phase 1 — Math Foundations	~270 hours
Know ML, new to deep learning	Phase 3 — Deep Learning Core	~200 hours
Know deep learning, want LLMs and agents	Phase 10 — LLMs from Scratch	~100 hours
Senior engineer, only want agent engineering	Phase 14 — Agent Engineering	~60 hours

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Why this matters now

_{FIG_003 · A} THE INDUSTRY SIGNAL	_{FIG_003 · B} FOUNDATIONAL PAPERS COVERED
“The hottest new programming language is English.” — Andrej Karpathy (tweet) “Software engineering is being remade in front of our eyes.” — Boris Cherny, creator of Claude Code “Models will keep getting better. The skill that compounds is knowing what to build.” — Industry consensus, 2026	Attention Is All You Need — Vaswani et al., 2017 → Phase 7 Language Models are Few-Shot Learners (GPT-3) → Phase 10 Denoising Diffusion Probabilistic Models → Phase 8 InstructGPT / RLHF → Phase 10 Direct Preference Optimization → Phase 10 Chain-of-Thought Prompting → Phase 11 ReAct: Reasoning + Acting in LLMs → Phase 14 Model Context Protocol — Anthropic → Phase 13

_{FIG_003 · A}
THE INDUSTRY SIGNAL

_{FIG_003 · B}
FOUNDATIONAL PAPERS COVERED

“The hottest new programming language is English.”
— Andrej Karpathy (tweet)

“Software engineering is being remade in front of our eyes.”
— Boris Cherny, creator of Claude Code

“Models will keep getting better. The skill that compounds is knowing what to build.”
— Industry consensus, 2026

Attention Is All You Need — Vaswani et al., 2017 → Phase 7
Language Models are Few-Shot Learners (GPT-3) → Phase 10
Denoising Diffusion Probabilistic Models → Phase 8
InstructGPT / RLHF → Phase 10
Direct Preference Optimization → Phase 10
Chain-of-Thought Prompting → Phase 11
ReAct: Reasoning + Acting in LLMs → Phase 14
Model Context Protocol — Anthropic → Phase 13

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Contributing

Goal	Read
Contribute a lesson or fix	CONTRIBUTING.md
Fork for your team or school	FORKING.md
Lesson template	LESSON_TEMPLATE.md
Track progress	ROADMAP.md
Glossary	glossary/terms.md
Code of conduct	CODE_OF_CONDUCT.md

Before submitting a lesson, run the invariant check:

python3 scripts/audit_lessons.py           # full curriculum
python3 scripts/audit_lessons.py --phase 14  # single phase
python3 scripts/audit_lessons.py --json    # CI-friendly output

Exit code is non-zero when any rule fails. Rules (L001–L010) validate directory shape, docs/en.md presence + H1, code/ non-emptiness, quiz.json schema (rejects the legacy q/choices/answer keys that caused issue #102), and relative links inside lesson docs.

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Sponsor the work

Free, MIT-licensed, 435 lessons. The curriculum is maintained on sponsorship alone. Cash only.

Reach (verified 2026-05-14): 55,593 monthly visitors · 90,709 page views · 7.5K stars · Twitter/X is the #1 acquisition channel.

Current sponsors: CodeRabbit · iii

Tier	$/mo	What you get
Backer	$25	Name in BACKERS.md
Bronze	$250	Text-only row in README sponsor block + launch-day tweet
Silver	$750	Small logo in README + listed as one supported provider in API lessons
Gold	$2,000	Medium logo in README + sponsor page + quarterly X / LinkedIn co-feature
Platinum	$5,000	Hero logo above the fold + one dedicated integration lesson, max 1 partner

Full rate card, hard rules, pricing anchors, and reach data: SPONSORS.md. Sign up via GitHub Sponsors.

░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Star history

If this manual helped you, star the repo. It keeps the project alive.

License

MIT. Use it however you want — fork it, teach it, sell it, ship it. Attribution appreciated, not required.

Maintained by Rohit Ghumare and the community.

_{@ghumare64 ·
aiengineeringfromscratch.com ·
Report / Suggest}

相似文章

@IndieDevHailey: 这可能是全网最硬核的 AI 工程开源课 GitHub 爆火项目：ai-engineering-from-scratch 已经拿下 17.4k+ Stars 它不是那种教你调 API的 AI 教程，而是真正带你从 0 手搓 AI 系统。 …

X AI KOLs Timeline

介绍 GitHub 上爆火的 AI 工程开源课程项目 ai-engineering-from-scratch，已获 17.4k+ Stars，提供 435 节课、20 个阶段，从数学原理到手写 AI 系统，支持多语言，旨在帮助学习者深入理解 AI 底层原理。

@0x404page: 卧槽！兄弟们！ AI时代已经杀到眼前了！想想就可怕…… 99%的人还在996卷死卷活，而真正聪明的人，已经用AI做副业赚钱、快速提升自己了！白嫖党福音直接砸脸！！！我直接在GitHub上给你挖到5个顶级优质项目，全都是免费开源的实操…

X AI KOLs Timeline

该推文分享了5个免费开源的GitHub项目，涵盖AI副业赚钱、程序副业、被动收入等实操资源，鼓励用户利用AI时代快速提升自己。

@FakeMaidenMaker: AI 工程师全栈路线：带你从零基础开始从数学到大模型到 Agent 全部搞懂网上 AI 资料一堆，但都是碎片——这里一篇微调、那里一个 agent demo、随便一搜全是"5 分钟搭一个 RAG"的快餐，真正从数学到 LLM 到 age…

X AI KOLs Timeline

A free, open-source AI engineering curriculum that covers math, LLMs, and agents across 20 phases and 435 lessons in Python, TypeScript, Rust, and Julia, designed to fill gaps in fragmented AI tutorials.

@Xudong07452910: 开源高质量教程推荐：ai-engineering-from-scratch —— 从零到生产级 AI 工程的全栈课程这是一套系统性的 AI 工程从零构建课程（Learn it. Build it. Ship it for others.…

X AI KOLs Timeline

这篇文章推荐了一个名为“ai-engineering-from-scratch”的开源全栈AI工程课程，包含503节课，覆盖从数学基础到生产部署，已获33.6k星。

@FakeMaidenMaker: 兄弟们，又挖到一个 AI 工程实战宝藏，叫 Hands-On-AI-Engineering 刚开源就冲了 2.3K star，一个仓库塞了 50 多个能直接跑起来的真实 AI 项目。它最实用的地方是不讲空泛理论，每个项目都是一个完整的小…

X AI KOLs Timeline

推荐了一个刚开源就获得2.3K star的GitHub仓库Hands-On-AI-Engineering，内含50多个可直接运行的AI项目，涵盖RAG、AI agent、OCR等类别，每个项目都提供完整代码和说明，适合实战学习。

rohitg00/ai-engineering-from-scratch

How this works

The shape of the curriculum

The shape of a lesson

Getting started

Prerequisites

Built-in agent skills (Claude, Cursor, Codex, OpenClaw, Hermes)

Every lesson ships something

FIG_002 · A worked sample

Contents

Phase 0: Setup & Tooling 12 lessons

The toolkit

Install every course skill into your agent

Drop the agent workbench into your own repo

Browse the entire course as JSON

Smoke-check every lesson’s Python code

Where to start

Why this matters now

Contributing

Sponsor the work

Star history

License

相似文章

@IndieDevHailey: 这可能是全网最硬核的 AI 工程开源课 GitHub 爆火项目：ai-engineering-from-scratch 已经拿下 17.4k+ Stars 它不是那种教你调 API的 AI 教程， 而是真正带你从 0 手搓 AI 系统。 …

@FakeMaidenMaker: AI 工程师全栈路线：带你从零基础开始从数学到大模型到 Agent 全部搞懂 网上 AI 资料一堆，但都是碎片——这里一篇微调、那里一个 agent demo、随便一搜全是"5 分钟搭一个 RAG"的快餐，真正从数学到 LLM 到 age…

@Xudong07452910: 开源高质量教程推荐：ai-engineering-from-scratch —— 从零到生产级 AI 工程的全栈课程 这是一套系统性的 AI 工程从零构建课程（Learn it. Build it. Ship it for others.…

@FakeMaidenMaker: 兄弟们，又挖到一个 AI 工程实战宝藏，叫 Hands-On-AI-Engineering 刚开源就冲了 2.3K star，一个仓库塞了 50 多个能直接跑起来的真实 AI 项目。 它最实用的地方是不讲空泛理论，每个项目都是一个完整的小…

提交意见反馈

Phase 0: Setup & Tooling `12 lessons`

@IndieDevHailey: 这可能是全网最硬核的 AI 工程开源课 GitHub 爆火项目：ai-engineering-from-scratch 已经拿下 17.4k+ Stars 它不是那种教你调 API的 AI 教程，而是真正带你从 0 手搓 AI 系统。 …

@FakeMaidenMaker: AI 工程师全栈路线：带你从零基础开始从数学到大模型到 Agent 全部搞懂网上 AI 资料一堆，但都是碎片——这里一篇微调、那里一个 agent demo、随便一搜全是"5 分钟搭一个 RAG"的快餐，真正从数学到 LLM 到 age…

@Xudong07452910: 开源高质量教程推荐：ai-engineering-from-scratch —— 从零到生产级 AI 工程的全栈课程这是一套系统性的 AI 工程从零构建课程（Learn it. Build it. Ship it for others.…

@FakeMaidenMaker: 兄弟们，又挖到一个 AI 工程实战宝藏，叫 Hands-On-AI-Engineering 刚开源就冲了 2.3K star，一个仓库塞了 50 多个能直接跑起来的真实 AI 项目。它最实用的地方是不讲空泛理论，每个项目都是一个完整的小…