AI you play, in order.
61 AI and engineering concepts rebuilt as little games, arranged as 14 play-order ladders. You drive the idea and lose to your own instincts, then meet the method that never does. The order is the point: you draw a decision boundary by hand three rungs before you are allowed to walk downhill, because played the other way round the walk is a demo rather than a discovery.
How machines learn
Draw the boundary yourself, then watch the maths find it. Everything a model does later is this loop, run a few billion more times.
Training a network
Seven labs in one line: draw a boundary by hand, bend it, see the terrain it lives on, walk downhill, work out who to blame, race the walkers — then swap the loss for human preference and do it again.
- PerceptronThe Line-Drawer Start here Don't read about the perceptron — watch it draw the line.
- Activation FunctionsThe BendDon't read about activations — bend the curve yourself.
- The Loss LandscapeDon't read about local minima — drop a ball and watch.
- The DescentGradient DescentKey labDon't read about gradient descent — play it.
- BackpropagationThe Blame MachineDon't read about backpropagation — run it.
- The Optimizer RaceDon't read about optimizers — race them down the same hill.
- RLHF & DPOThe Taste TrainerDon't read about RLHF — do the aligning.
Judging a model
The three labs that stop you believing a number. Drag a threshold and watch precision trade against recall, cause overfitting on purpose, then find out how much your single score could have been.
Structure, and making new things
Find the shape in the data — features, clusters, meaning as geometry, a search over that geometry — then sample from it and generate something that was never in the set.
- ConvolutionThe Sliding Stencil Start here Don't read about convolution — slide the stencil yourself.
- K-MeansThe Gravity WellsDon't read about k-means — watch the clusters form.
- EmbeddingsThe Meaning MapDon't read about embeddings — explore the map.
- HNSWThe Skip-List of SpaceDon't read about approximate nearest-neighbor search — navigate it.
- The Latent WalkDon't read about latent space — walk through it.
- DiffusionOut of the StaticDon't read about diffusion — watch the picture climb out of the static.
Inside a language model
Open the thing up: what a token is, what attention actually attends to, what each trick buys you on the bill, and what an agent does with it all.
Driving the model
What you actually control from the outside: how the text is cut up, which die the sampler rolls, whether you ask it to think first, and what happens when you overfill the window.
- The Tokenizer Start here A language model can't read words — it reads tokens.
- SamplingThe Dice LoaderDon't read about temperature, top-k, and top-p — drive them.
- Chain-of-Thought vs DirectDon't read about chain-of-thought — watch it rescue a wrong answer.
- Context RotThe Crowded DeskDon't read about context rot — cause it.
The transformer, opened up
Attention as a spotlight, then the same pass in full, then the three things production models change about it — rotary position, a routed mixture of experts, and sparsity once the context is a million tokens.
- AttentionThe Spotlight Start here Don't read about attention — shine the spotlight yourself.
- Self-AttentionInside a TransformerDon't read about attention — compute it, token by token.
- Position by RotationRoPEDon't read about rotary position embeddings — rotate the vectors yourself.
- Mixture of ExpertsThe SwitchboardDon't read about mixture-of-experts — route the tokens yourself.
- The Million-Token Bill — Sparse AttentionDon't read about long-context attention — run the numbers.
Fast, and cheap
Five levers on the inference bill, each played until it breaks: the cache you pay for in memory, the batch that trades latency for throughput, the rounding, the understudy that drafts ahead, and the decoder that gives up on left-to-right entirely.
- KV-Cache VisualizerThe Memory Tax Start here Don't read about the KV cache — fill it.
- Batching & ThroughputThe Assembly LineDon't read about batching — run the GPU.
- QuantizationThe Rounding RoomDon't read about quantization — round some weights yourself.
- Speculative DecodingThe UnderstudyDon't read about speculative decoding — run it.
- All At Once — Text Diffusion DecodingDon't read about diffusion LLMs — run one.
Agents, and what breaks them
Run the inner loop, design the outer one, plug in a real tool over MCP — then be the attacker and find out how little it takes to turn all of it against itself.
- Agent Loop SimulatorThe Loop Start here Don't read about the agent loop — run it.
- Outer LoopsThe Loop DesignerKey labDon't read about loop engineering — break a loop, then fix it.
- The MCP PlaygroundDon't read about MCP — watch a model use tools through it.
- Prompt InjectionThe Break-InDon't read about prompt injection — try to pull one off.
Distributed systems, played
Kill a node and watch the election. Turn the quorum dial until reads go stale. The failure is the lesson, so you have to be allowed to cause it.
Agreement between machines
Start by electing a leader and killing it. Then the three ways to live without one — a quorum you can dial into staleness, clocks that only order what actually caused what, and structures that cannot conflict by construction.
- The ElectionRaft Start here Don't read about Raft — run the cluster.
- The Quorum DialDon't read about quorums — dial them.
- Who Caused WhatVector ClocksDon't read about vector clocks — trace them.
- No ConflictCRDT MergeDon't read about CRDTs — merge them.
- GossipThe Rumor MillDon't read about gossip protocols — start a rumor.
Down the wire
One request, followed all the way: find the address, open the connection and watch it back off, prove who you are talking to, then get spread across a fleet.
- The DNS Journey Start here Don't read about DNS — watch a name resolve.
- The TCP SawtoothDon't read about TCP congestion control — watch the sawtooth form.
- The TLS HandshakeDon't read about TLS — watch two strangers agree on a secret while everyone is listening.
- The Load BalancerDon't read about load balancing — distribute the traffic.
Storage, caching and backpressure
Where the data sits and what happens when more arrives than you can take: two storage engines raced head to head, a planner choosing between them, an eviction policy that picks the wrong victim, and a queue that has to say no.
- B-Tree vs LSM-Tree Start here Don't read about storage engines — race them.
- The Query PlannerDon't guess why your query is slow — watch the planner choose.
- LRU vs LFUThe Eviction RaceDon't read about cache eviction — race the policies.
- The Bounded QueueBackpressureDon't read about backpressure — feel the queue fill.
How your tools actually work
Two everyday tools with a data structure hiding inside. Both are much simpler than their reputation once you can click through the graph.
Forward deployed, simulated
The parts of the job that are judgement rather than code — scoping, mapping, rollout, the security review, the interview rounds — with the consequences of a wrong call played out.
The engagement, played
One deployment in the order it happens: scope it, learn their domain under time pressure, map their data to yours, harden the integration, choose where it runs, and pick a rollout you can reverse.
- The Scoping Simulator Start here Don't read about scoping — cut it under a deadline.
- Domain Ramp SprintThe FDE meta-skill, drilled on three real verticals — insurance claims, hospital revenue cycle, or legal discovery.
- The Data Mapping LabDon't read about data mapping — do it, and watch rows pass or fail.
- The Integration Reliability LabDon't read about reliable integrations — watch a flaky endpoint drop and duplicate events, then fix it.
- The Deployment Target ChooserDon't guess where a customer solution should run — answer the constraints and watch the recommendation fall out.
- The Rollout Strategy LabDon't read about rollout strategies — ship a bug and watch the blast radius.
Client-grade work
The three things that decide whether a working prototype becomes a deployment: a defensible eval, a security review you can survive, and the stakeholder who was never in the room.
The interview rounds, simulated
Three FDE rounds run as live simulations rather than written prep — decompose an ambiguous problem, learn a domain cold in front of the interviewer, then hold a room full of a customer’s objections.
- The Decomposition Round, Simulated Start here Don't read about the FDE decomposition round — sit it.
- The Learning Round, SimulatedLearn a library that does not exist.
- Client Roleplay SimulatorThe four conversations that actually decide deployments, as branching dialogue: your demo breaks in front of their CTO, a stakeholder i…
Labs — frequently asked questions
What is interactive, game-based learning for AI?
It's learning a concept by playing it instead of reading about it. Each lab here is a small browser game: you drive the idea yourself and fail on instinct, then watch the real method do it right, followed by the formal theory, a worked trace and a quiz. For abstract AI ideas like gradient descent, learning rates or retrieval, feeling the mechanic first — then formalizing it — makes it stick far better than a lecture or a wall of math.
Which lab should I start with?
Gradient Descent (The Descent) — rung 4 of the Training a network ladder, and the single most foundational idea in machine learning, since every neural network and large language model is trained by following the gradient downhill. If you want the three rungs under it first, the ladder opens by having you draw a decision boundary by hand.
Why are the labs in ladders instead of tags?
Because play order changes what a lab teaches, more than reading order does for a written page. The training ladder has you draw a boundary by hand, bend it, look at the terrain it lives on, and only then walk downhill — played the other way round, the walk is a demo rather than a discovery. A tag list cannot express that; an ordered ladder can, so each rung is built assuming the one below it.
Do I need math or a machine-learning background?
No. The labs lead with a visual, hands-on mechanic and a concrete story, not proofs. You'll meet the real terms — loss, gradient, learning rate, local minima, momentum — and see the update rule, but the understanding comes from playing the system: nudging it, tuning it, and breaking it.
How are labs different from the algorithm games or the tools?
The algorithm games teach classic data-structures-and-algorithms topics (shortest paths, sorting, search). Labs cover AI and engineering concepts — how models learn, how retrieval works, how a request flows through a system. The free tools are utilities you reach for while building (calculators and visualizers); labs are guided, game-first lessons that teach a concept end to end.
Are the labs free?
Yes — every lab is completely free, runs entirely in your browser with no account or sign-up, is keyboard-playable, and respects reduced-motion settings.