AI you play.
AI and engineering concepts rebuilt as little games. You drive the idea and lose to your own instincts, then meet the method that never does — watch it work, tune its knobs, and try to break it. The theory, the update rule, a worked trace and a quiz come after, once it's already clicked.
Gradient Descent: The Descent
Don't read about gradient descent — play it. Roll a ball into the valley of a loss landscape by hand and waste steps, then let the algorithm read the slope and step downhill on its own. Crank the learning rate until it overshoots and explodes, dial it down until it crawls, then switch on momentum to escape a local minimum. Four acts — descend it, follow the gradient, tune the learning rate, escape the trap.
The Tokenizer
A language model can't read words — it reads tokens. Watch your text shatter into sub-word chunks, race character vs word vs sub-word tokenizers head-to-head, then build Byte-Pair Encoding by hand: merge the most frequent pair over and over to grow a vocabulary and shrink the sequence. Five acts — shatter it, race three tokenizers, build BPE, tune the vocab size, and feel why 'strawberry' trips up an LLM.
The Dice Loader: Sampling
Don't read about temperature, top-k, and top-p — drive them. A language model turns logits into a probability over the next token, then rolls; three dials load those dice. Slide temperature to sharpen or flatten the odds, clamp the tail with top-k or top-p, and watch the bar chart renormalize live — then hit Sample and roll. See exactly why an LLM sounds robotic at low temperature and unhinged at high.
The Gravity Wells: K-Means
Don't read about k-means — watch the clusters form. Drop three centroids into a cloud of thirty unlabeled points, then run two moves on repeat: assign every point to its nearest centroid, then slide each centroid to the mean of its crowd. Watch the mess snap into clean groups and the inertia drop each round. Unsupervised clustering, made playable, with theory, a runnable challenge and a quiz.
The Meaning Map: Embeddings
Don't read about embeddings — explore the map. Every word becomes a point in space, placed so that closeness means similar meaning. Click a word to rank its nearest neighbours by cosine similarity, then run the famous vector arithmetic — king − man + woman lands right on queen, paris − france + japan lands on tokyo. Word embeddings and cosine similarity, made playable, with theory and a quiz.
The Sliding Stencil: Convolution
Don't read about convolution — slide the stencil yourself. A 3×3 kernel glides over an image and, at each spot, multiplies the pixels underneath by its weights and sums them into one output pixel. Swap kernels — identity, edge-detect, blur, sharpen, emboss, Sobel — and watch the same image become edges, or blur, or sharpened. The single operation inside every CNN, made playable, with theory, a runnable challenge and a quiz.
The Spotlight: Attention
Don't read about attention — shine the spotlight yourself. In a Transformer, every word looks at every other word and weights how much to listen to each. Click a word to see where its attention goes — the verb leaning on its subject, the determiner pointing at its noun — as glowing links and a heatmap whose weights sum to one. Self-attention (the softmax(QKᵀ) heart of every LLM), made playable, with theory and a quiz.
Out of the Static: Diffusion
Don't read about diffusion — watch the picture climb out of the static. Diffusion models generate by starting from pure random noise and removing a little of it, step by step, until a shape appears. Step through the reverse process and watch a heart emerge from random pixels as the noise level drops to zero. The idea behind Stable Diffusion and DALL·E, made playable, with theory and a quiz.
The Bend: Activation Functions
Don't read about activations — bend the curve yourself. A neural network is just linear algebra until you add a non-linear activation on each neuron. Plot sigmoid, tanh, ReLU, leaky ReLU, and GELU with their derivatives, and slide a point to read the gradient — watching sigmoid's slope vanish at the edges while ReLU's stays a flat 1. The reason deep nets learn, made playable, with theory and a quiz.
The Line-Drawer: Perceptron
Don't read about the perceptron — watch it draw the line. The simplest neural network, one neuron from 1958, learns to separate two classes of points by nudging a straight boundary every time it gets one wrong. Step through the updates and watch the line swing from a bad guess into a perfect split — then meet the XOR wall that a single line can't cross. The seed of every neural network, made playable, with theory, a runnable challenge and a quiz.
The Loop: Agent Loop Simulator
Don't read about the agent loop — run it. Step a model through plan → act → observe: it thinks, calls a tool, reads the result, and loops until it can answer. Watch the context window fill turn by turn and compaction fold old turns away before it overflows — the beating heart of every AI harness, made playable, with theory and a quiz.
The Break-In: Prompt Injection
Don't read about prompt injection — try to pull one off. Feed a helpful agent a booby-trapped message that tries to steal its secret or hijack its tools, and watch it get owned. Then switch on real defenses — instruction hierarchy, input sanitizing, output filtering, tool permissions — and watch the same attack bounce. The #1 security risk in LLM apps, made playable, with theory and a quiz.
The Loop Designer: Outer Loops
Don't read about loop engineering — break a loop, then fix it. An agent must migrate 8 files overnight, unattended; you design its outer loop. Toggle the hard cap, the independent verifier, and the external memory, hit Run, and watch the classic failures fire live: the $500 runaway, groundhog-day amnesia, and victory declared on broken code. Four scenarios, one lesson — same agent, different loop, opposite outcomes.
The Memory Tax: KV-Cache Visualizer
Don't read about the KV cache — fill it. A model generating text pays a hidden rent: for every token, in every layer, it stores a key and a value so it never recomputes the past. Watch the cache stack up as it decodes, collapse it with grouped-query attention, then slam into the VRAM wall that decides how many users a GPU can serve — and quantize the cache to claw the memory back. Four acts — fill it, collapse it with GQA, hit the wall, quantize it.
The Skip-List of Space: HNSW
Don't read about approximate nearest-neighbor search — navigate it. A billion vectors, and you need the closest few in milliseconds — you can't compare them all. Drop a query into a vector space and watch HNSW hop across a layered proximity graph: coarse express lanes up top, dense local streets at the bottom. Race it against brute-force scanning, then tune efSearch and M to feel the recall-latency-memory trade. Three acts — navigate the layers, race brute force, tune recall vs speed.
The Understudy: Speculative Decoding
Don't read about speculative decoding — run it. A giant model reads one token at a time, slow, because each token drags all its weights through the GPU. So a small draft model guesses the next few tokens, and the big model verifies them all in one pass, keeping every guess it agrees with. Watch tokens get accepted and rejected, then tune the acceptance rate and draft length to see where 2-3x faster generation — with identical output — comes from. Three acts — feel the bottleneck, draft and verify, dial acceptance to speed.
The Rounding Room: Quantization
Don't read about quantization — round some weights yourself. A model is billions of 16-bit numbers, but do you need all 16? Snap each weight to a coarser grid — 8 bits, 4, even 2 — and watch the memory collapse while precision blurs. Discover why weights bunch near zero, why NF4 places its levels at the quantiles of a bell curve to beat plain INT4, and where quality finally breaks. Three acts — round one weight, quantize the whole bell curve, trade memory against quality at scale.
The Switchboard: Mixture of Experts
Don't read about mixture-of-experts — route the tokens yourself. How does a trillion-parameter model run like a small one? A router sends each token to just a few of many experts, so the model stores a giant and pays for a sliver. Watch tokens light up their chosen experts, slide expert count and top-k to pull total and active parameters apart, then send a burst with load-balancing off to watch one expert overload — and on to fix it. Three acts — route a token, store big pay small, balance the load.
The Crowded Desk: Context Rot
Don't read about context rot — cause it. Give a model a bigger window and it should get smarter, right? Bury one crucial fact in a wall of filler and find out. Slide the needle from top to bottom to watch it sink in the middle, pour in filler to watch recall rot as the desk fills, then toggle retrieval, repositioning and compaction to claw it back. Three acts — lost in the middle, the rot curve, fight back with context engineering.
The Assembly Line: Batching & Throughput
Don't read about batching — run the GPU. One request wastes a chip built for hundreds, because generating a token streams every weight through the GPU whether you use one sequence or fifty. Slide the batch up to watch throughput soar and cost-per-token fall, trade it against a latency budget, then race static batching (stalls on the slowest request) against continuous batching (never idles). Three acts — fill the GPU, throughput vs latency, static vs continuous.
The Taste Trainer: RLHF & DPO
Don't read about RLHF — do the aligning. A base model can write but doesn't know what people prefer, so you teach it taste: pick which of two answers is better, over and over, and watch a reward model learn your preferences. Then turn up the optimization pressure and watch the policy chase that reward — and reward-hack it into sycophancy — while a KL penalty pulls it back. Finally see how DPO skips the whole reward model. Three acts — teach the taste, chase and hack the reward, the DPO shortcut.
The Blame Machine: Backpropagation
Don't read about backpropagation — run it. A network guesses and gets it wrong; the hard question is which weight is to blame, and by how much. Push a number forward through a tiny network, measure the loss, then watch the error flow backward assigning a gradient to every weight via the chain rule. Train it to convergence (or crank the learning rate until it explodes), then slide network depth to watch gradients vanish and explode. Three acts — forward and back, learn a step, vanish and explode.
Raft: The Election
Don't read about Raft — run the cluster. Five nodes start as followers with random election timers; when one times out it becomes a candidate, bumps the term, and asks the others for votes. Win a majority and you're leader, sending heartbeats that reset everyone's timers. Kill the leader and watch a new election fire. Leader election and split-vote handling, made playable, with theory and a quiz.
The Quorum Dial
Don't read about quorums — dial them. With N replicas, a write goes to W of them and a read consults R of them. When R+W>N the read and write sets are forced to overlap, so a read always sees the latest write — strong consistency. Drop below that and reads can miss the newest value. Slide R and W and watch a read go fresh or stale. Tunable consistency, made playable, with theory and a quiz.
Vector Clocks: Who Caused What
Don't read about vector clocks — trace them. Three processes with no shared clock each keep a vector counting events they know about. A local event bumps your own entry; sending attaches your vector; receiving merges by taking the element-wise max. Compare two vectors and you can tell whether one event caused the other — or whether they're truly concurrent. Watch causality emerge on a timeline, made playable, with theory and a quiz.
CRDT Merge: No Conflict
Don't read about CRDTs — merge them. Three replicas edit the same counter at the same time with no coordination, then sync in any order — and always converge to the exact same value. The secret is a merge that is commutative, associative, and idempotent (here, element-wise max of per-replica counts). Increment replicas independently, merge them, and watch every replica agree, made playable, with theory and a quiz.
The Rumor Mill: Gossip
Don't read about gossip protocols — start a rumor. One node learns an update; each round, every node that knows it tells a random peer. The knowledge spreads like an epidemic — doubling each round — so all N nodes hear it in about log N rounds, with no central coordinator and graceful tolerance of failures. Watch a single update sweep a whole cluster, made playable, with theory and a quiz.
The Eviction Race: LRU vs LFU
Don't read about cache eviction — race the policies. Feed the same access stream to three caches of equal size and watch them make different choices: FIFO evicts the oldest, LRU evicts the least-recently-used, LFU evicts the least-frequently-used. On a hot-key-plus-scan workload, LFU keeps the hot item while LRU and FIFO throw it away — and the hit rates diverge. Step the stream and watch, made playable, with theory and a quiz.
The Load Balancer
Don't read about load balancing — distribute the traffic. A load balancer spreads requests across a pool of servers, but the strategy decides everything: round-robin cycles blindly, least-connections sends work to the least-busy server, and hashing pins each client to one server for stickiness. When requests have uneven cost, the naive strategies pile up on one box while least-connections stays smooth. Send traffic and watch the queues, made playable, with theory and a quiz.
Backpressure: The Bounded Queue
Don't read about backpressure — feel the queue fill. A fast producer feeds a slow consumer through a bounded buffer. Without backpressure the queue overflows and you silently drop work; with backpressure you slow the producer to the consumer's pace so nothing is lost — you trade latency for reliability. Toggle backpressure and watch drops turn into controlled waiting, made playable, with theory and a quiz.
The TCP Sawtooth
Don't read about TCP congestion control — watch the sawtooth form. A sender probes the network's capacity by growing its congestion window exponentially at first (slow start), then linearly (congestion avoidance). When a packet is lost, it halves the window and probes again. This additive-increase / multiplicative-decrease loop makes millions of independent senders converge to a fair, stable share. Grow the window, inject loss, and watch it recover — made playable, with theory and a quiz.
The DNS Journey
Don't read about DNS — watch a name resolve. Typing a domain kicks off a recursive walk down a global tree: your resolver asks a root server (which points to the TLD), the TLD server (which points to the authoritative server), and finally the authoritative server (which returns the IP). Then it caches the answer so the next lookup is instant. Resolve a name step by step and watch the cache short-circuit a repeat lookup, made playable, with theory and a quiz.
The TLS Handshake
Don't read about TLS — watch two strangers agree on a secret while everyone is listening. A certificate proves the server's identity, and an ephemeral Diffie-Hellman exchange lets client and server derive the same secret key from public numbers without ever sending it across the wire. Step through the messages, watch each side compute the identical secret, and see why an eavesdropper still can't read it — with real tiny-number DH math, a quiz, and theory.
The Query Planner
Don't guess why your query is slow — watch the planner choose. A cost-based query planner estimates the cost of every way to run a query — full table scan, index scan, bitmap AND of two indexes — and picks the cheapest. The catch: an index isn't always a win. Change how selective each predicate is, add or drop indexes, and watch the planner flip between a sequential scan and an index scan for reasons you can finally see. Made playable, with theory and a quiz.
B-Tree vs LSM-Tree
Don't read about storage engines — race them. A B-tree updates data in place: reads are cheap and stable, but every write is a random disk write. An LSM-tree appends writes to an in-memory buffer, flushes them as sorted runs, and compacts in the background: writes are cheap and sequential, but a read may have to check several runs. Stream the same writes into both, watch flushes and compaction happen, and see which engine wins for writes and which for reads — made playable, with theory and a quiz.
The Git Object Graph
Don't read about how Git stores your code — build the object graph. Every commit is a snapshot, not a diff: Git stores file contents as blobs, directories as trees, and each commit points to a tree plus its parent. Everything is addressed by the hash of its content, so identical content is stored exactly once and unchanged files are shared across commits for free. Edit files, commit, and watch new objects appear and unchanged ones get reused — made playable, with theory and a quiz.
How a Regex Runs: The NFA
Don't read about regular expressions — run one, state by state. A regex compiles to a small state machine (an NFA), and matching a string means tracking the SET of states the machine could be in at once — following epsilon jumps and consuming one character at a time. Because it tracks a set instead of guessing and backtracking, it matches in linear time with no catastrophic blowups. Feed characters into the machine for a(b|c)*d and watch the active states light up — made playable, with theory and a quiz.
The Optimizer Race
Don't read about optimizers — race them down the same hill. Training a neural network is gradient descent on a loss surface, and the optimizer decides the path. On an ill-conditioned ravine, plain SGD zigzags and crawls, momentum builds speed along the valley floor, and Adam adapts its step size per direction to head almost straight for the bottom. Step the three optimizers down the same surface and watch their paths and losses diverge — made playable, with theory and a quiz.
The Loss Landscape
Don't read about local minima — drop a ball and watch. Training is gradient descent on a loss landscape, and the shape decides whether descent finds the best answer, gets trapped in a worse one, or crawls to a halt. Roll a ball down a convex bowl (always finds the bottom), a double-well surface (where the start decides which minimum), and a flat plateau (where the gradient vanishes and progress stalls). See why the surface's shape governs training — made playable, with theory and a quiz.
Inside a Transformer: Self-Attention
Don't read about attention — compute it, token by token. At the heart of every transformer is self-attention: each token forms a query, compares it against every token's key to get scores, softmaxes those into weights, and builds its new representation as a weighted sum of every token's value. That's how a model lets 'it' look back at 'robot.' Pick a query token and watch its scores become softmax weights become a context vector — with the real dot-product math, a quiz, and theory.
RoPE: Position by Rotation
Don't read about rotary position embeddings — rotate the vectors yourself. Attention has no built-in sense of order, so RoPE injects position by rotating each token's query and key by an angle proportional to its position. Because a dot product depends only on the angle between vectors, the attention score ends up depending only on the RELATIVE distance between tokens. Slide two tokens along a sequence and watch their score depend purely on the gap — made playable, with theory and a quiz.
Chain-of-Thought vs Direct
Don't read about chain-of-thought — watch it rescue a wrong answer. A model produces one token at a time, so asking it to blurt a final answer to a multi-step problem crams the whole computation into one step — and it often takes a tempting shortcut and gets it wrong. Asking it to think step by step lets it spend intermediate tokens working the problem, each step small enough to get right. Run the same problems both ways and see the shortcut fail and the chain succeed — made playable, with theory and a quiz.
The MCP Playground
Don't read about MCP — watch a model use tools through it. The Model Context Protocol is a standard way to connect an AI host to external tools and data: servers advertise tools with schemas, the host discovers them, the model decides which to call and with what arguments, the server runs the tool, and the result flows back for the model to answer. Step through a real request — get the weather, then save it to notes — and see the whole discover, call, result, answer loop, with theory and a quiz.
The Latent Walk
Don't read about latent space — walk through it. A generative model turns a vector of numbers into an image, and that space is smooth and structured: nearby codes make similar images, a straight line between two codes morphs one into the other, and specific directions correspond to meaningful attributes. Move through a toy generator's latent space, interpolate between two points, and steer a single semantic direction to see how a model organizes what it can create — made playable, with theory and a quiz.
The Deployment Target Chooser
Don't guess where a customer solution should run — answer the constraints and watch the recommendation fall out. The FDE question that reshapes an architecture most is "where can this run?". Toggle whether data can leave, whether it's regulated, whether there's internet, and how fast you must ship updates, and see how the four targets — SaaS, customer VPC, on-prem, air-gapped — score, with the reasoning behind the winner. Made playable, with theory and a quiz.
The Integration Reliability Lab
Don't read about reliable integrations — watch a flaky endpoint drop and duplicate events, then fix it. Send a stream of deliveries through an endpoint that sometimes fails or times out, and toggle the three patterns that make it survive real traffic: retries (fewer losses, but new duplicates), idempotency (kills the duplicates), and a dead-letter queue (turns loss into something recoverable). Watch the exactly-once delivery rate climb — made playable, with theory and a quiz.
The Data Mapping Lab
Don't read about data mapping — do it, and watch rows pass or fail. Every customer hands you a messy export; before it flows in, each column must be mapped to a canonical field and coerced to a type, with the rows that don't fit quarantined, not silently dropped. Pick which column feeds each field and watch validation light up green and red, row by row — a wrong mapping fails everything, a right one quarantines only the bad values. Made playable, with theory and a quiz.
The Rollout Strategy Lab
Don't read about rollout strategies — ship a bug and watch the blast radius. How you roll out a change to a customer's users decides how many people a bad release hits before you catch it: big-bang exposes everyone, a canary exposes 1% first. Pick a strategy, ship a buggy or healthy release, and see the blast radius — and the rollout speed you trade for safety. Made playable, with theory and a quiz.
The Scoping Simulator
Don't read about scoping — cut it under a deadline. You have a two-week budget and a wishlist. Pick the features for a proof of concept and watch the verdict: does it include the one vertical slice that proves value, and does it fit the timebox? Overload it and you ship nothing; skip the core and you prove nothing. Find the smallest slice that makes the customer believe — made playable, with theory and a quiz.
All At Once — Text Diffusion Decoding
Don't read about diffusion LLMs — run one. An autoregressive model writes one token per pass; a text-diffusion model starts from a fully masked block and refines the whole thing in parallel over K denoising steps, emitting B/K tokens per pass. Watch a block go from ██████ to clean text, then tune the block size and step count to feel the speed-versus-coherence dial — and see why text diffusion (masking, discrete) is not image diffusion (Gaussian noise, continuous). Interactive, with theory and a quiz.
The Million-Token Bill — Sparse Attention
Don't read about long-context attention — run the numbers. Dense attention caches a key/value per token and scores every query against all of them, so at a million tokens memory grows linearly and compute grows with the square. Pull the two levers of compressed sparse attention — compress each token's K/V to a latent, and select only the top-k blocks per query — and watch the KV cache and attention FLOPs collapse, with the two savings multiplying (as in DeepSeek-V4). Drag the context to a million and see the ratios fall. Interactive, with theory and a quiz.
The Decomposition Round, Simulated
Don't read about the FDE decomposition round — sit it. Pick a case (taxi fleet, emergency response, fraud unification, marketplace) and get scored on the five clarifying questions you ask <em>before</em> the propose button unlocks, then on which sub-problems you attack and in what order, then on the two things you explicitly refuse to build. Premature solutioning scores negative, exactly like the real round. Ends with an interviewer verdict and a band. The signature Palantir-style round, interactive nowhere else.
Client Roleplay Simulator
The four conversations that actually decide deployments, as branching dialogue: your demo breaks in front of their CTO, a stakeholder insists on the wrong feature, security will not release the data, and a manager whose team gets smaller keeps raising objections. Every reply moves a live trust meter and changes what they say next. Ends with a scored verdict against the four signals FDE interviewers screen for — the round every guide tells you to rehearse with a friend.
The Learning Round, Simulated
Learn a library that does not exist. You get the internal docs for <code>flowpkg</code> — a package installer with dependency stages, a barrier between them, ordered post-install hooks and idempotent installs — in three unlocking sections with comprehension gates. Two rules are deliberately buried, and the last question can only be answered by combining rules from different sections. Tests reading strategy, not recall, exactly like the real round.
Eval Builder: From Fuzzy Goal to CI Gate
A customer says the system “should be accurate”. Turn that into something a contract can rest on, in four acts: pick metrics (two of the strongest are not accuracy at all), discover the real ceiling by measuring how often the two human experts agree with <em>each other</em>, configure and calibrate an LLM judge, then set a CI gate and watch it catch a change that raises overall accuracy while more than doubling the expensive errors. The most-cited hard skill in FDE job descriptions, made playable.
Security Review Gauntlet
The review that blocks more enterprise AI deployments than any technical problem, in three rounds. Answer a SIG/CAIQ-style questionnaire where a specific <em>no</em> with a compensating control outscores a vague <em>yes</em> — and a false yes ends the review. Survive a live CISO call with a trust meter that punishes bluffing exactly as the real one does. Then threat-model an LLM application, where the plausible mitigation is usually not the one that holds. Ends with a findings report: approved, approved with conditions, or blocked.
Stakeholder Politics Lab
Deployments die on org charts, not architecture. Six people at one customer, each identified by a single sentence — classify them as economic buyer, champion, end user, blocker or data gatekeeper, and expect the titles to mislead you at least twice. Then handle the three situations that actually end projects: the gatekeeper who never says no but never grants access, the team lead whose people you are automating, and the champion who resigns in month five — while a coalition meter tracks who is still with you.
Domain Ramp Sprint
The FDE meta-skill, drilled on three real verticals — insurance claims, hospital revenue cycle, or legal discovery. Learn the vocabulary that turns out to be codes (<code>status 7</code>, <code>CO-45</code>, TAR), reconstruct the workflow people actually follow rather than the one on the diagram, then pass expert gates including the one that asks which rule lives only in a practitioner's head. Scored on whether you could hold a conversation with them on Monday.
Precision vs Recall: Drag the Threshold
Don't read the definitions — drag the line. A spam filter scored 5,000 emails; you pick where to cut. Every bar in the chart recolours into its confusion-matrix quadrant as you move, so precision, recall and F1 stop being formulas and become regions you can see. Push it to the extremes: catch every spam and bury real mail, or never lose mail and let phishing through. Then flag nothing at all and watch the model score 85% accuracy while catching zero spam — the class-imbalance trap, in one click.
Bias vs Variance: Fit the Curve, Watch It Overfit
Don't memorize the tradeoff — cause it. Slide the polynomial degree from 1 to 12 and watch a fit go from too stiff to bend through every point. Training error falls the whole way; test error bottoms out at degree 3 and then climbs 3.5x. Then hit resample: at degree 1 the fits barely move, at degree 12 they fan across the entire frame. That fan is variance, and you made it appear.
Cross-Validation: One Exam, or Five?
Don't take the score on faith — see how much it could have been. Slide k to repartition 20 samples into folds, rotate the held-out fold and watch the mean assemble. Then run the payoff side by side: report a single hold-out split and your number swings from 0.790 to 0.880 depending purely on which split you happened to draw, while 5-fold sits still at 0.836 ± 0.033. Plus what it costs you — k folds means k trainings.
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?
Start with Gradient Descent (The Descent). It's the single most foundational idea in machine learning — every neural network and large language model is trained by following the gradient downhill — and it games beautifully: you roll a ball into a valley, tune the learning rate until it overshoots or crawls, and escape a local minimum with momentum. Once descent clicks, training, fine-tuning and optimization all have a foundation to stand on.
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.