A practitioner-direct curriculum for engineers who shipped ML before but watched the LLM stack move past. Modern architectures, context engineering, RAG, agents, evaluation, inference cost, reliability, production patterns. Twenty-six interactive widgets that make the math visceral. No signup, no upsell.
Every page is written like a senior engineer telling you what they wish they'd known six months ago. Concrete decisions, the math behind them, and the tradeoffs nobody publishes. No marketing copy. No "exciting world of AI." Just the engineering layer.
Opinions stated as opinions. Numbers shown with their sources. Tradeoffs spelled out. The voice you'd want from a senior engineer who's shipped this stuff and is now teaching you what they wish they'd known.
Twenty-six widgets — calculators, simulators, decision matrices, trace visualizers, cost explorers — embedded inline. Slide a parameter; see the math change. Reading without doing builds fluent commentators, not practitioners.
The curriculum ends with deployment patterns, on-call playbooks, cost governance, and senior interview prep. Capability is week 1-11; week 12 is the engineering discipline that keeps capability shipped.
Each week is roughly 8–10 hours of work: reading, widgets, build exercises, optional deep reads. Designed in order — early weeks set vocabulary and mental models that later weeks rely on. You can skip ahead if a topic is already familiar; most weeks stand alone for the practitioner already at their level.
Tokenization, attention variants in 2026, KV cache, sampling. The mental models everything else builds on.
Read this week→Long-context economics, prompt caching, position effects, the lost-in-the-middle problem. Where the practitioner work happens.
Read this week→When (and when not) to fine-tune. LoRA, QLoRA, full SFT. The decision matrix and the parameter math.
Read this week→DPO, RLHF, IPO, KTO. How preference signals shape models. Why reward hacking is fundamental, not a bug.
Read this week→Embeddings, vector search, chunking. The geometric intuition for why retrieval works (and why it breaks).
Read this week→Hybrid search, rerankers, query rewriting. The 2026 production-RAG architecture and what makes it work.
Read this week→How agent loops work, where they break, the discipline that keeps them bounded. Three traces, six tools, thirty cells of judgment.
Read this week→Eval is the single highest-leverage practice. Golden sets, LLM judges, judge-vs-human agreement, eval-in-prod.
Read this week→Cost arithmetic that works. Batching, speculative decoding, model routing, KV cache reuse. The math behind a 10× cost difference.
Read this week→Vision pricing, multimodal token economics, code-agent traces. Where the next product wave is built.
Read this week→Calibration, verifier ensembles, citation entailment, formal grounding. The reliability stack that holds up under load.
Read this week→Deployment patterns for non-deterministic systems, on-call playbook, cost governance, the 7-pillar interview frame.
Read this week→After two or three weeks, you stop noticing the format and just absorb the content. Each week opens with a stated goal, builds across numbered sections with embedded widgets and quick checks, and closes with concrete build-this-week exercises and interview-prompt questions.
What you'll be able to do at the end. The honest answer to "why this week."
Concrete, actionable angles on the topic. No filler, no recap of what you already know.
Calculators, visualizers, simulators where the math becomes visceral.
Small multiple-choice questions inline to verify the concept landed.
Four to five concrete exercises. Pick at least two; do them this week, not someday.
Curated papers and reference posts. Foundational, not exhaustive.
Ten questions an interviewer might ask. Practice your verbal answer.
Bullet list of capabilities you should have by week's end. Self-assessment.
Most teams know their per-token pricing. Few can produce a defensible monthly forecast. The gap is arithmetic discipline — combining input/output token counts, request volume, model tier, and cache-hit rates into a number you'd stake your headcount on.
The right calculation is per-call cost × request volume × hours × days, with separate input and output token streams. Here's the calculator we'll use for the rest of this section:
Slide the request rate to 50 RPS; watch Sonnet at default settings produce $237k/year. Switch to Haiku: $58k/year. The 4× ratio is the intuition you want before you walk into the architecture meeting.
The trap most teams fall into is reasoning about per-call cost in cents and never multiplying by the rate. Per-call cost looks fine; monthly burn looks like a year of headcount.
Every widget is single-file standalone HTML with the same design system. They're built to teach a concept by letting you slide parameters and see the consequence — cost numbers, latency curves, calibration arcs, agent traces. Click any to launch. They open in their own page; come back when you're done.
The curriculum assumes basic ML literacy: you know what gradient descent is, you've read about transformers, you're comfortable reading code. Beyond that, no assumed background. The ramp is steep but the entry point is reasonable.
The reading layer of this site is free and will stay free. No signup, no email gate, no "premium tier" of locked content. Anthropic, OpenAI, and Google's docs are free too — knowledge that gates itself doesn't compound.