Learn with the most advanced agent — the correct way to learn in the agent era.

◎ Modeled on Stanford CS336

Hand-build every piece of an LLM, along the 17-lecture skeleton of Stanford CS336

8 Labs · 25 sessions

• ✓Hand-implement BPE tokenization, embedding similarity, and a full gradient-descent training loop
• ✓Account for a model's FLOPs/memory and reason about architecture & hyperparameters (incl. MoE)
• ✓Explain how GPUs, kernels and parallelism determine training throughput

◎ Modeled on Berkeley’s LLM Agents course

Along the 12-lecture skeleton of Berkeley's LLM Agents course — reasoning, frameworks, applications and safety, all hands-on

5 Labs · 15 sessions

• ✓Explain what each LLM reasoning technique (CoT, self-consistency, least-to-most) solves and when it fails
• ✓Trace the lineage of ReAct and the agent paradigm; run the reason-act-observe loop yourself
• ✓Compare multi-agent frameworks and compound AI systems (conversational collaboration, declarative optimization)

◎ Modeled on Stanford CS329A (Self-Improving AI Agents)

Hand-build AI agents that make themselves better, along the skeleton of Stanford CS329A

5 Labs · 15 sessions

• ✓Explain the four levers of self-improvement — sampling, verifiers, tool feedback, training bootstrap — and when each applies
• ✓Run best-of-N with a verifier and explain why coverage scales log-linearly
• ✓Implement minimal critique→revise and multi-step planning loops, and tell when they help vs fail

◎ Modeled on MIT’s How to AI (Almost) Anything (multimodal)

Turn images, sound and text into tensors by hand — then build alignment, fusion, cross-modal retrieval and multimodal models piece by piece

7 Labs · 12 sessions

• ✓Turn images (pixel grids), audio (waveform/spectrum) and text (bag-of-words) into fixed-length vectors by hand, and explain heterogeneity vs a unified representation
• ✓Project paired (image, text) into one space, use contrastive learning to pull positives together and push negatives apart, and compute alignment similarity
• ✓Implement early / late / gated / attention fusion by hand and compare their robustness on a toy bimodal task

◎ Modeled on Princeton COS 511 (Theoretical ML)

Hand-derive PAC bounds, hand-build AdaBoost, hand-run regret curves — turn learning theory from formulas into experiments you run

7 Labs · 12 sessions

• ✓Verify PAC sample complexity with your own Monte-Carlo runs, and explain what (ε, δ) actually guarantees
• ✓Count a hypothesis class's shattering power, pin down its VC dimension, and read the VC generalization bound
• ✓Hand-build AdaBoost from scratch and watch training error decay exponentially while margins shift right

◎ Modeled on Stanford CS234 (Reinforcement Learning)

Prove convergence by hand, backprop a DQN from scratch, give policy gradient a critic — pure numpy, zero gym, zero GPU

9 Labs · 32 sessions

• ✓Cast sequential decision-making as an MDP, prove value iteration is a γ-contraction, and watch the error shrink by γ each sweep
• ✓Implement model-free MC, TD(0), TD(λ), SARSA and Q-learning, and explain the on/off-policy personality gap
• ✓Trigger the deadly triad's divergence with linear function approximation, then build a mini-DQN with hand-written backprop in pure numpy

◎ Modeled on CMU’s ML in Production (MLIP)

Turn a model that merely runs into a system that survives production

7 Labs · 12 sessions

• ✓Decompose an AI system and compute the system-level cost of one model under different decision thresholds
• ✓Hand-compute precision/recall from a confusion matrix, sweep thresholds by cost, and catch data leakage
• ✓Write behavioral tests for a model like software tests (MFT / invariance / directional / slice)

Write A* and alpha-beta pruning in a few dozen lines of stdlib — the bedrock under LLM planners and AGV obstacle avoidance

6 Labs · 11 sessions

• ✓Formalize any problem as (states, actions, goal, cost) and pick the right search algorithm
• ✓Hand-write BFS/DFS/IDS/UCS/A* and explain, with real node counts, why heuristics save search
• ✓Build admissible, consistent heuristics via problem relaxation — and show how an inadmissible one loses optimality

You call .fit() but never derived a gradient — hand-build linear & logistic regression and watch the decision boundary grow

6 Labs · 9 sessions

• ✓Derive the gradients of MSE and cross-entropy from scratch and hand-write batch gradient descent
• ✓Verify first-hand that iterative and closed-form solutions (normal equation, Newton's method) meet at the same optimum
• ✓Manufacture an overfit on purpose, then rescue it with ridge regularization and cross-validation

An image is just a numpy array — hand-write conv kernels for edge detection, then train a classifier that reads digits

6 Labs · 11 sessions

• ✓Treat images as numpy tensors, hand-write 2D convolution and build blur/sharpen/Sobel edge filters
• ✓Hand-implement histogram equalization, bilinear-interpolated affine warps and Gaussian pyramids
• ✓Hand-write simplified Canny and Harris to detect edges & corners, and match two images with mini-HOG descriptors

To understand RLHF/RLVR, first understand Q-learning — zero gym, a world you build in pure numpy

6 Labs · 8 sessions

• ✓Hand-implement epsilon-greedy and UCB, and quantify the explore-for-long-term-gain trade-off
• ✓Derive value iteration from the Bellman equation and watch V-values converge and policy arrows form on a grid
• ✓Implement model-free Q-learning and SARSA, and explain the on-policy vs off-policy personalities at the cliff edge

Write every line behind loss.backward() yourself — PyTorch stops being a black box

6 Labs · 9 sessions

• ✓Hand-implement a graph-recording Value class and a topological-sort backward() — every line behind loss.backward()
• ✓Audit analytic gradients against finite differences op by op, proving your backprop correct and catching a planted derivative bug
• ✓Upgrade the scalar engine into a numpy tensor autograd: derive and implement backprop through broadcasting and matmul's two transpose rules

Your multi-agent system IS a distributed system — elect a leader on a deterministic simulated network

6 Labs · 9 sessions

• ✓Hand-write a deterministic discrete-event simulated network with injectable delay, loss and partitions
• ✓Implement the follower/candidate/leader state machine, randomized timeouts and majority elections
• ✓Implement log replication, conflict backtracking and the current-term-only commit rule

Everyone builds RAG but never opens the retrieval core — hand-write an inverted index and BM25, and finally know why your retrieval misses

6 Labs · 10 sessions

• ✓Hand-write an inverted index + boolean queries — millisecond term-to-document retrieval
• ✓Implement TF-IDF and BM25 scoring; understand term-frequency saturation and length normalization
• ✓Watch first-hand why keyword stuffing fools TF-IDF but not BM25

You use Stable Diffusion but don't get why — on a 2D toy distribution, turn data into noise and back, by hand

6 Labs · 8 sessions

• ✓Hand-implement the closed-form forward marginal, derive ᾱ_t, and watch a 2D cloud diffuse into a Gaussian
• ✓Train a tiny-MLP velocity field and sample via Euler/Heun integration, flowing noise back onto the data manifold
• ✓Derive the conditional flow matching loss and explain why regressing conditional velocities learns the marginal field

Scanner → Pratt parser → tree-walk evaluator — see how the language you use every day actually runs

6 Labs · 10 sessions

• ✓Hand-write a scanner that turns source text into tokens — multi-digit numbers, two-char operators, string literals
• ✓Tame operator precedence and associativity with Pratt parsing (binding power) and print the resulting AST
• ✓Build a tree-walk evaluator with an environment chain: bindings, nested scopes, branches and loops

No quantum hardware needed — entangle qubits in a browser and turn mystical gates into visible matrix multiplications

6 Labs · 9 sessions

• ✓Represent n-qubit states as numpy complex vectors and write X/H/Z/CNOT as visible matrix multiplications
• ✓Implement measurement & collapse by sampling |amplitude|², and watch 10,000 shots hug the theoretical probabilities
• ✓Construct Bell and GHZ states, and capture entanglement red-handed in a joint-measurement histogram showing only 00/11

You use HTTPS/JWT daily but never opened the box — from frequency-analysis cracking to a toy RSA you write yourself

6 Labs · 10 sessions

• ✓Auto-crack single-byte and repeating-key XOR with frequency analysis, and see why a small key space always falls
• ✓Implement a toy RSA from scratch (fast modular exponentiation + extended Euclid modular inverse) and reproduce the e=3 cube-root attack
• ✓Hand-build a Diffie-Hellman handshake, then stage a man-in-the-middle attack to see why authentication is mandatory

◎ Modeled on Princeton’s Bitcoin and Cryptocurrency Technologies + Nakamoto’s whitepaper

Hash-pointer chains, Merkle proofs, PoW nonce search, the whitepaper's own attack probability — all in stdlib hashlib, offline and deterministic

8 Labs · 13 sessions

◎ Modeled on the University of Michigan’s Model Thinking (Scott Page)

Schelling segregation, percolation phase transitions, Solow steady states, replicator dynamics — simulate and prove every model yourself in pure numpy

10 Labs · 20 sessions

Ten short chapters to grok every word of the agent era: LLMs, foundation models, multimodality, tokens, hallucination, agents, MCP, skills

8 Labs · 10 sessions

• ✓Explain, in plain language, what LLMs, foundation models and multimodal models are, and how they relate
• ✓Explain how tokens and the context window decide what an AI can read, how it's billed, and what it forgets
• ✓Explain why AI confidently makes things up, and when to doubt it

The non-CS path to AI-coding mastery — not how to write code, but the 20% the agent can't do that decides everything

7 Labs · 31 sessions

• ✓Specify a task for an agent: goal, constraints, acceptance criteria, examples, and what not to touch
• ✓Verify an agent's output: run it, read the diff, demand a test that can fail — never trust 'done'
• ✓Make things run in a real terminal: paths, dependencies, env vars, secrets (and why secrets never enter git)