Day 1: First Principles & the Model Lineup

30 minutes. The foundation every later session cites.

Lecture

The machine. Claude is a large language model: given a sequence of tokens (word-fragments, ~3–4 characters of English each), it predicts what comes next, repeatedly. Everything else is scaffolding. Two consequences dominate all architecture:

First, the context window is the model's entire working world. What's in the window — system prompt, conversation, tool results, files — is what the model can act on. Frontier Claude models in 2026 carry 1M-token windows (Haiku 4.5: 200k), which sounds infinite and isn't: cost scales with tokens processed, and signal quality degrades when the window fills with junk. The architect's reflex: curate, don't dump.

Second, the model is stateless between calls. It remembers nothing. All "memory" — Chat's memory feature, Claude Code's CLAUDE.md, the API memory tool — is scaffolding that re-inserts selected state into the next call's window. Once you internalize this, features that seem magical become legible engineering.

The lineup. As of July 2026, four models matter, verified against platform.claude.com/docs:

Model	API ID	Context	Max out	$/MTok in/out	Role
Claude Fable 5	claude-fable-5	1M	128k	$10 / $50	Frontier. Hardest reasoning, long-horizon agents. Always-on adaptive thinking.
Claude Opus 4.8	claude-opus-4-8	1M	128k	$5 / $25	The coding & agentic workhorse. Notably better at catching flaws in its own code than 4.7.
Claude Sonnet 5	claude-sonnet-5	1M	128k	$3 / $15 (intro $2/$10 through Aug 31, 2026)	Production default: ~90% of the capability at a fraction of the cost.
Claude Haiku 4.5	claude-haiku-4-5-20251001	200k	64k	$1 / $5	High-volume, low-latency: subagent worker, classifier, real-time.

(Also live: Claude Mythos 5, a limited-release frontier sibling of Fable 5, and older 4.x models in maintenance. Time-boxed notes: Fable 5 was free for paid users through July 19, 2026; Sonnet 5 intro pricing ends Aug 31.)

Thinking and effort. The big 2026 shift: adaptive thinking replaced manual thinking budgets. On Fable 5 and Opus 4.8, the model decides when and how deeply to reason — you cannot turn it off on Fable 5. Your dial is the effort parameter: low / medium / high / xhigh (and max in some harnesses). Same model, different depth-vs-cost tradeoff. Architect's rule: pick the cheapest model that can do the job, then tune effort — model choice sets the ceiling, effort sets how hard it pushes toward it.

The economics that change your designs. Two features turn "expensive" into "cheap" and thus reshape what's worth building:

Prompt caching: cached prefix reads cost 0.1x normal input price (writes cost 1.25x–2x once). A 100k-token system prompt + reference corpus that would cost $0.50 per call on Sonnet 5 costs ~$0.03–0.05 on cache hits. This is why big stable system prompts, loaded skills, and long-lived agent sessions are economically viable — if you structure prompts stable-prefix-first so the cache actually hits.

Batches API: 50% off for async, non-urgent workloads. Nightly evaluation runs, bulk classification, corpus processing — half price for tolerating latency.

Everything else the platform does (you'll meet these in context later): tool use and MCP, structured outputs (schema-guaranteed JSON), vision, web search and web fetch tools, code execution containers, the memory tool, computer use (beta), context editing and compaction, 1M-context long-horizon support. File the names; sessions 4–6 make them concrete.

The four laws (memorize verbatim — the whole track hangs on them):

1. Context is the scarce resource.
2. The loop is the unit of work, not the message.
3. Generation and evaluation must be separated.
4. Model choice is an economic decision.

Anecdotes

The $4,000 classifier. A team ran a frontier model over every inbound support ticket for sentiment tagging — a task Haiku 4.5 does indistinguishably well at a tenth the price. Nobody chose that; it was the default model left over from a prototype. The bill was the code review. Law 4 exists because defaults are sticky and invoices are quiet.

The prompt that got cheaper by getting longer. An agent builder resisted adding a 30k-token style guide to a system prompt — "too expensive." With caching structured correctly (stable guide first, variable request last), the guide cost full price once, then ~10% on every subsequent call in the cache window. The counterintuitive lesson: with caching, stable context is nearly free; it's churning context that costs. Architects design for cache hits the way web devs design for CDN hits.

The disappearing thinking dial. In 2025, developers hand-tuned budget_tokens for extended thinking per request. In 2026, adaptive thinking made the model self-tuning and effort became the coarse dial. The meta-lesson: the platform absorbs low-level knobs over time. Learn the current abstraction, and re-check the docs before reusing last year's integration pattern — knowledge here has a shelf life, which is exactly why this track flags dates.

Lab (10 min)

1. In Claude Code or Cowork, ask: "Which model are you running, what's its context window, and what effort level is this session using?" Note the answer.
2. Fetch the live lineup yourself: have Claude fetch https://platform.claude.com/docs/en/about-claude/models/overview and produce a two-line delta report vs the table above. (Habit being installed: verify against live docs, don't trust memory — yours or the model's.)
3. Cost estimate by hand: a loop runs every hour with a 60k-token stable prompt and 2k variable tokens, producing 1k output, on Sonnet 5 standard pricing. Compute daily cost with and without caching (5-min cache expires between runs — so use the 1-hour cache write at 2x, reads at 0.1x). Check yourself in the answer key (file 11).

Key takeaways

The model predicts tokens; scaffolding does the rest. The context window is the working world and the cost driver. Four models span the price/capability space: Fable 5 (frontier), Opus 4.8 (agentic workhorse), Sonnet 5 (production default), Haiku 4.5 (volume). Adaptive thinking is on by default; effort is your dial. Caching makes stable context ~10x cheaper; batches halve async work. And the four laws — context scarcity, the loop, gen/eval separation, model economics — are the load-bearing walls of every session that follows.