Star 历史趋势
数据来源: GitHub API · 生成自 Stargazers.cn
README.md

AI Engineering from Scratch — reference manual banner

MIT License 428 lessons 20 phases GitHub stars Website

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

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

428 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, 428 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 & 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 & 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 & Protocols"] P13 --> P14["Phase 14 — Agent Engineering"] P14 --> P15["Phase 15 — Autonomous Systems"] P15 --> P16["Phase 16 — Multi-Agent & Swarms"] P14 --> P17["Phase 17 — Infrastructure & Production"] P15 --> P18["Phase 18 — Ethics & 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 Code:

/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 Claude Code skills

SkillWhat it does
/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.
░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

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 Code, Cursor, Codex, 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 SkillKit. Real tools, not homework. By the end of the curriculum, you have a portfolio of 428 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...
░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Contents

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

Phase 0: Setup & Tooling 12 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 EnvironmentsBuildPython
07Docker for AIBuildPython
08Editor SetupBuild
09Data ManagementBuildPython
10Terminal & ShellLearn
11Linux for AILearn
12Debugging & ProfilingBuildPython
Phase 1 — Math Foundations  22 lessons  The intuition behind every AI algorithm, through code.
#LessonTypeLang
01Linear Algebra IntuitionLearnPython, Julia
02Vectors, Matrices & OperationsBuildPython, Julia
03Matrix Transformations & EigenvaluesBuildPython, Julia
04Calculus for ML: Derivatives & GradientsLearnPython
05Chain Rule & Automatic DifferentiationBuildPython
06Probability & DistributionsLearnPython
07Bayes' Theorem & Statistical ThinkingBuildPython
08Optimization: Gradient Descent FamilyBuildPython
09Information Theory: Entropy, KL DivergenceLearnPython
10Dimensionality Reduction: PCA, t-SNE, UMAPBuildPython
11Singular Value DecompositionBuildPython, Julia
12Tensor OperationsBuildPython
13Numerical StabilityBuildPython
14Norms & DistancesBuildPython
15Statistics for MLBuildPython
16Sampling MethodsBuildPython
17Linear SystemsBuildPython
18Convex OptimizationBuildPython
19Complex Numbers for AILearnPython
20The Fourier TransformBuildPython
21Graph Theory for MLBuildPython
22Stochastic ProcessesLearnPython
Phase 2 — ML Fundamentals  18 lessons  Classical ML — still the backbone of most production AI.
#LessonTypeLang
01What Is Machine LearningLearnPython
02Linear Regression from ScratchBuildPython
03Logistic Regression & ClassificationBuildPython
04Decision Trees & Random ForestsBuildPython
05Support Vector MachinesBuildPython
06KNN & Distance MetricsBuildPython
07Unsupervised Learning: K-Means, DBSCANBuildPython
08Feature Engineering & SelectionBuildPython
09Model Evaluation: Metrics, Cross-ValidationBuildPython
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
Phase 3 — Deep Learning Core  13 lessons  Neural networks from first principles. No frameworks until you build one.
#LessonTypeLang
01The Perceptron: Where It All StartedBuildPython
02Multi-Layer Networks & Forward PassBuildPython
03Backpropagation from ScratchBuildPython
04Activation Functions: ReLU, Sigmoid, GELU & WhyBuildPython
05Loss Functions: MSE, Cross-Entropy, ContrastiveBuildPython
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
Phase 4 — Computer Vision  28 lessons  From pixels to understanding — image, video, 3D, VLMs, and world models.
#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
Phase 5 — NLP: Foundations to Advanced  29 lessons  Language is the interface to intelligence.
#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
20Structured Outputs & Constrained DecodingBuildPython
21NLI & Textual EntailmentLearnPython
22Embedding Models Deep DiveLearnPython
23Chunking Strategies for RAGBuildPython
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
Phase 6 — Speech & Audio  17 lessons  Hear, understand, speak.
#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
Phase 7 — Transformers Deep Dive  14 lessons  The architecture that changed everything.
#LessonTypeLang
01Why Transformers: The Problems with RNNsLearnPython
02Self-Attention from ScratchBuildPython
03Multi-Head AttentionBuildPython
04Positional Encoding: Sinusoidal, RoPE, ALiBiBuildPython
05The Full Transformer: Encoder + DecoderBuildPython
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
Phase 8 — Generative AI  14 lessons  Create images, video, audio, 3D, and more.
#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
Phase 9 — Reinforcement Learning  12 lessons  The foundation of RLHF and game-playing AI.
#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
Phase 10 — LLMs from Scratch  22 lessons  Build, train, and understand large language models.
#LessonTypeLang
01Tokenizers: BPE, WordPiece, SentencePieceBuildPython
02Building a Tokenizer from ScratchBuildPython
03Data Pipelines for Pre-TrainingBuildPython
04Pre-Training a Mini GPT (124M)BuildPython
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
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
Phase 11 — LLM Engineering  15 lessons  Put LLMs to work in production.
#LessonTypeLang
01Prompt Engineering: Techniques & PatternsBuildPython
02Few-Shot, CoT, Tree-of-ThoughtBuildPython
03Structured OutputsBuildPython, TypeScript
04Embeddings & Vector RepresentationsBuildPython
05Context EngineeringBuildPython, TypeScript
06RAG: Retrieval-Augmented GenerationBuildPython, TypeScript
07Advanced RAG: Chunking, RerankingBuildPython
08Fine-Tuning with LoRA & QLoRABuildPython
09Function Calling & Tool UseBuildPython
10Evaluation & TestingBuildPython
11Caching, Rate Limiting & CostBuildPython
12Guardrails & SafetyBuildPython
13Building a Production LLM AppBuildPython
14Model Context Protocol (MCP)BuildPython
15Prompt Caching & Context CachingBuildPython
Phase 12 — Multimodal AI  25 lessons  See, hear, read, and reason across modalities — from ViT patches to computer-use agents.
#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
Phase 13 — Tools & Protocols  23 lessons  The interfaces between AI and the real world.
#LessonTypeLang
01The Tool InterfaceLearnPython
02Function Calling Deep DiveBuildPython
03Parallel and Streaming Tool CallsBuildPython
04Structured OutputBuildPython
05Tool Schema DesignLearnPython
06MCP FundamentalsLearnPython
07Building an MCP ServerBuildPython
08Building an MCP ClientBuildPython
09MCP TransportsLearnPython
10MCP Resources and PromptsBuildPython
11MCP SamplingBuildPython
12MCP Roots and ElicitationBuildPython
13MCP Async TasksBuildPython
14MCP AppsBuildPython
15MCP Security I — Tool PoisoningLearnPython
16MCP Security II — OAuth 2.1BuildPython
17MCP Gateways and RegistriesLearnPython
18MCP Auth in Production — DCR + JWKS on iiiBuildPython
19A2A ProtocolBuildPython
20OpenTelemetry GenAIBuildPython
21LLM Routing LayerLearnPython
22Skills and Agent SDKsLearnPython
23Capstone — Tool EcosystemBuildPython
Phase 14 — Agent Engineering  42 lessons  Build agents from first principles — loop, memory, planning, frameworks, benchmarks, production, workbench.
#LessonTypeLang
01The Agent LoopBuildPython
02ReWOO and Plan-and-ExecuteBuildPython
03Reflexion and Verbal Reinforcement LearningBuildPython
04Tree of Thoughts and LATSBuildPython
05Self-Refine and CRITICBuildPython
06Tool Use and Function CallingBuildPython
07Memory — Virtual Context and MemGPTBuildPython
08Memory Blocks and Sleep-Time ComputeBuildPython
09Hybrid Memory — Mem0 Vector + Graph + KVBuildPython
10Skill Libraries and Lifelong Learning — VoyagerBuildPython
11Planning with HTN and Evolutionary SearchBuildPython
12Anthropic's Workflow PatternsBuildPython
13LangGraph — Stateful Graphs and Durable ExecutionBuildPython
14AutoGen v0.4 — Actor ModelBuildPython
15CrewAI — Role-Based Crews and FlowsBuildPython
16OpenAI Agents SDK — Handoffs, Guardrails, TracingBuildPython
17Claude Agent SDK — Subagents and Session StoreBuildPython
18Agno and Mastra — Production RuntimesLearnPython, TypeScript
19Benchmarks — SWE-bench, GAIA, AgentBenchLearnPython
20Benchmarks — WebArena and OSWorldLearnPython
21Computer Use — Claude, OpenAI CUA, GeminiBuildPython
22Voice Agents — Pipecat and LiveKitBuildPython
23OpenTelemetry GenAI Semantic ConventionsBuildPython
24Agent Observability — Langfuse, Phoenix, OpikLearnPython
25Multi-Agent Debate and CollaborationBuildPython
26Failure Modes — Why Agents BreakBuildPython
27Prompt Injection and the PVE DefenseBuildPython
28Orchestration Patterns — Supervisor, Swarm, HierarchicalBuildPython
29Production Runtimes — Queue, Event, CronLearnPython
30Eval-Driven Agent DevelopmentBuildPython
31Agent Workbench: Why Capable Models Still FailLearnPython
32The Minimal Agent WorkbenchBuildPython
33Agent Instructions as Executable ConstraintsBuildPython
34Repo Memory and Durable StateBuildPython
35Initialization Scripts for AgentsBuildPython
36Scope Contracts and Task BoundariesBuildPython
37Runtime Feedback LoopsBuildPython
38Verification GatesBuildPython
39Reviewer Agent: Separate Builder from MarkerBuildPython
40Multi-Session HandoffBuildPython
41The Workbench on a Real RepoBuildPython
42Capstone: Ship a Reusable Agent Workbench PackBuildPython
Phase 15 — Autonomous Systems  22 lessons  Long-horizon agents, self-improvement, and the 2026 safety stack.
#LessonTypeLang
01From Chatbots to Long-Horizon Agents (METR)LearnPython
02STaR, V-STaR, Quiet-STaR: Self-Taught ReasoningLearnPython
03AlphaEvolve: Evolutionary Coding AgentsLearnPython
04Darwin Gödel Machine: Self-Modifying AgentsLearnPython
05AI Scientist v2: Workshop-Level ResearchLearnPython
06Automated Alignment Research (Anthropic AAR)LearnPython
07Recursive Self-Improvement: Capability vs AlignmentLearnPython
08Bounded Self-Improvement DesignsLearnPython
09Autonomous Coding Agent Landscape (SWE-bench, CodeAct)LearnPython
10Claude Code Permission Modes and Auto ModeLearnPython
11Browser Agents and Indirect Prompt InjectionLearnPython
12Durable Execution for Long-Running AgentsLearnPython
13Action Budgets, Iteration Caps, Cost GovernorsLearnPython
14Kill Switches, Circuit Breakers, Canary TokensLearnPython
15HITL: Propose-Then-CommitLearnPython
16Checkpoints and RollbackLearnPython
17Constitutional AI and Rule OverridesLearnPython
18Llama Guard and Input/Output ClassificationLearnPython
19Anthropic Responsible Scaling Policy v3.0LearnPython
20OpenAI Preparedness Framework and DeepMind FSFLearnPython
21METR Time Horizons and External EvaluationLearnPython
22CAIS, CAISI, and Societal-Scale RiskLearnPython
Phase 16 — Multi-Agent & Swarms  25 lessons  Coordination, emergence, and collective intelligence.
#LessonTypeLang
01Why Multi-AgentLearnTypeScript
02FIPA-ACL Heritage and Speech ActsLearnPython
03Communication ProtocolsBuildTypeScript
04The Multi-Agent Primitive ModelLearnPython
05Supervisor / Orchestrator-Worker PatternBuildPython
06Hierarchical Architecture and Decomposition DriftLearnPython
07Society of Mind and Multi-Agent DebateBuildPython
08Role Specialization — Planner / Critic / Executor / VerifierBuildPython
09Parallel Swarm and Networked ArchitecturesBuildPython
10Group Chat and Speaker SelectionBuildPython
11Handoffs and Routines (Stateless Orchestration)BuildPython
12A2A — The Agent-to-Agent ProtocolBuildPython
13Shared Memory and Blackboard PatternsBuildPython
14Consensus and Byzantine Fault ToleranceBuildPython
15Voting, Self-Consistency, and Debate TopologyBuildPython
16Negotiation and BargainingBuildPython
17Generative Agents and Emergent SimulationBuildPython
18Theory of Mind and Emergent CoordinationBuildPython
19Swarm Optimization (PSO, ACO)BuildPython
20MARL — MADDPG, QMIX, MAPPOLearnPython
21Agent Economies, Token Incentives, ReputationLearnPython
22Production Scaling — Queues, Checkpoints, DurabilityBuildPython
23Failure Modes — MAST, Groupthink, MonocultureLearnPython
24Evaluation and Coordination BenchmarksLearnPython
25Case Studies and 2026 State of the ArtLearnPython
Phase 17 — Infrastructure & Production  28 lessons  Ship AI to the real world.
#LessonTypeLang
01Managed LLM Platforms — Bedrock, Azure OpenAI, Vertex AILearnPython
02Inference Platform Economics — Fireworks, Together, Baseten, ModalLearnPython
03GPU Autoscaling on Kubernetes — Karpenter, KAI SchedulerLearnPython
04vLLM Serving Internals — PagedAttention, Continuous Batching, Chunked PrefillLearnPython
05EAGLE-3 Speculative Decoding in ProductionLearnPython
06SGLang and RadixAttention for Prefix-Heavy WorkloadsLearnPython
07TensorRT-LLM on Blackwell with FP8 and NVFP4LearnPython
08Inference Metrics — TTFT, TPOT, ITL, Goodput, P99LearnPython
09Production Quantization — AWQ, GPTQ, GGUF, FP8, NVFP4LearnPython
10Cold Start Mitigation for Serverless LLMsLearnPython
11Multi-Region LLM Serving and KV Cache LocalityLearnPython
12Edge Inference — ANE, Hexagon, WebGPU, JetsonLearnPython
13LLM Observability Stack SelectionLearnPython
14Prompt Caching and Semantic Caching EconomicsLearnPython
15Batch APIs — the 50% Discount as Industry StandardLearnPython
16Model Routing as a Cost-Reduction PrimitiveLearnPython
17Disaggregated Prefill/Decode — NVIDIA Dynamo and llm-dLearnPython
18vLLM Production Stack with LMCache KV OffloadingLearnPython
19AI Gateways — LiteLLM, Portkey, Kong, BifrostLearnPython
20Shadow, Canary, and Progressive DeploymentLearnPython
21A/B Testing LLM Features — GrowthBook and StatsigLearnPython
22Load Testing LLM APIs — k6, LLMPerf, GenAI-PerfBuildPython
23SRE for AI — Multi-Agent Incident ResponseLearnPython
24Chaos Engineering for LLM ProductionLearnPython
25Security — Secrets, PII Scrubbing, Audit LogsLearnPython
26Compliance — SOC 2, HIPAA, GDPR, EU AI Act, ISO 42001LearnPython
27FinOps for LLMs — Unit Economics and Multi-Tenant AttributionLearnPython
28Self-Hosted Serving Selection — llama.cpp, Ollama, TGI, vLLM, SGLangLearnPython
Phase 18 — Ethics, Safety & Alignment  30 lessons  Build AI that helps humanity. Not optional.
#LessonTypeLang
01Instruction-Following as Alignment SignalLearnPython
02Reward Hacking & Goodhart's LawLearnPython
03Direct Preference Optimization FamilyLearnPython
04Sycophancy as RLHF AmplificationLearnPython
05Constitutional AI & RLAIFLearnPython
06Mesa-Optimization & Deceptive AlignmentLearnPython
07Sleeper Agents — Persistent DeceptionLearnPython
08In-Context Scheming in Frontier ModelsLearnPython
09Alignment FakingLearnPython
10AI Control — Safety Despite SubversionLearnPython
11Scalable Oversight & Weak-to-StrongLearnPython
12Red-Teaming: PAIR & Automated AttacksBuildPython
13Many-Shot JailbreakingLearnPython
14ASCII Art & Visual JailbreaksBuildPython
15Indirect Prompt InjectionBuildPython
16Red-Team Tooling: Garak, Llama Guard, PyRITBuildPython
17WMDP & Dual-Use Capability EvaluationLearnPython
18Frontier Safety Frameworks — RSP, PF, FSFLearn
19Model Welfare ResearchLearnPython
20Bias & Representational HarmBuildPython
21Fairness Criteria: Group, Individual, CounterfactualLearnPython
22Differential Privacy for LLMsBuildPython
23Watermarking: SynthID, Stable Signature, C2PABuildPython
24Regulatory Frameworks: EU, US, UK, KoreaLearn
25EchoLeak & CVEs for AILearnPython
26Model, System & Dataset CardsBuildPython
27Data Provenance & Training-Data GovernanceLearnPython
28Alignment Research Ecosystem: MATS, Redwood, Apollo, METRLearn
29Moderation Systems: OpenAI, Perspective, Llama GuardBuildPython
30Dual-Use Risk: Cyber, Bio, Chem, NuclearLearn
Phase 19 — Capstone Projects  17 projects  2026 end-to-end shippable products, 20-40 hours each.
#ProjectCombinesLang
01Terminal-Native Coding AgentP0 P5 P7 P10 P11 P13 P14 P15 P17 P18TypeScript, Python
02RAG over Codebase (Cross-Repo Semantic Search)P5 P7 P11 P13 P17Python, TypeScript
03Real-Time Voice Assistant (ASR → LLM → TTS)P6 P7 P11 P13 P14 P17Python, TypeScript
04Multimodal Document QA (Vision-First)P4 P5 P7 P11 P12 P17Python, TypeScript
05Autonomous Research Agent (AI-Scientist Class)P0 P2 P3 P7 P10 P14 P15 P16 P18Python
06DevOps Troubleshooting Agent for KubernetesP11 P13 P14 P15 P17 P18Python, TypeScript
07End-to-End Fine-Tuning PipelineP2 P3 P7 P10 P11 P17 P18Python
08Production RAG Chatbot (Regulated Vertical)P5 P7 P11 P12 P17 P18Python, TypeScript
09Code Migration Agent (Repo-Level Upgrade)P5 P7 P11 P13 P14 P15 P17Python, TypeScript
10Multi-Agent Software Engineering TeamP11 P13 P14 P15 P16 P17Python, TypeScript
11LLM Observability & Eval DashboardP11 P13 P17 P18TypeScript, Python
12Video Understanding Pipeline (Scene → QA)P4 P6 P7 P11 P12 P17Python, TypeScript
13MCP Server with Registry and GovernanceP11 P13 P14 P17 P18Python, TypeScript
14Speculative-Decoding Inference ServerP3 P7 P10 P17Python
15Constitutional Safety Harness + Red-Team RangeP10 P11 P13 P14 P18Python
16GitHub Issue-to-PR Autonomous AgentP11 P13 P14 P15 P17Python, TypeScript
17Personal AI Tutor (Adaptive, Multimodal)P5 P6 P11 P12 P14 P17 P18Python, TypeScript
░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

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
├── agents/       agent definitions ready to deploy
└── mcp-servers/  MCP servers built during the course

Install them with SkillKit. Plug them into Claude Code, Cursor, or any MCP-compatible agent. Real tools, not homework.

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
░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

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 ModelsPhase 8
  • InstructGPT / RLHFPhase 10
  • Direct Preference OptimizationPhase 10
  • Chain-of-Thought PromptingPhase 11
  • ReAct: Reasoning + Acting in LLMsPhase 14
  • Model Context Protocol — Anthropic → Phase 13
░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Contributing

GoalRead
Contribute a lesson or fixCONTRIBUTING.md
Fork for your team or schoolFORKING.md
Lesson templateLESSON_TEMPLATE.md
Track progressROADMAP.md
Glossaryglossary/terms.md
Code of conductCODE_OF_CONDUCT.md
░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒░░░▒▒▒

Star history

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

关于 About

Learn it. Build it. Ship it for others.
agentsaiai-agentsai-engineeringcomputer-visioncoursedeep-learningfrom-scratchgenerative-aillmmachine-learningmcpnlppythonreinforcement-learningrustswarm-intelligencetransformerstutorialtypescript

语言 Languages

Python86.1%
HTML5.8%
JavaScript5.5%
Julia0.8%
TypeScript0.8%
CSS0.6%
Shell0.4%
Rust0.1%
Dockerfile0.0%

提交活跃度 Commit Activity

代码提交热力图
过去 52 周的开发活跃度
943
Total Commits
峰值: 586次/周
Less
More

核心贡献者 Contributors