AI Product Thinking — the judgment layer
The final topic of the course — no mechanisms, only judgment: what to build, and the meta-skills that survive every model release.
Build where fallibility is affordable. Models are probabilistic (Lesson 1, never repealed). Products that thrive absorb errors structurally: drafts a human sends, suggestions a user accepts, triage a queue backstops, search with citations. Products that require determinism — payments, compliance math, anything where one error is catastrophic — want rules and SQL, with AI at most proposing. The maturity test of an AI product isn't its accuracy; it's what happens on the wrong answer — Topic 21's layered-defense instinct, elevated to product strategy. Twin principle: build where verification is cheap (Topic 58's asymmetry as a market map — it predicted coding's boom; apply it forward: which domains have cheap checkers? those are next).
Build on the trendline, not the snapshot. Capabilities improve relentlessly and costs fall roughly an order of magnitude every year or two for equivalent quality. Two corollaries in tension, both true: "barely works today" means "works next year" — the too-early product beats the impossible one — and thin layers get absorbed: if your product is one prompt-shaped gap in the platform's capabilities, the next model release is your extinction event. The test: does your product get stronger when models improve (flywheel, workflow depth, integrations — the tide lifts you) or redundant (you were patching a capability gap — the tide covers you)? Build the former, always.
Respect the demo-to-product gap. A demo is p50; a product is p99 (Topic 76's percentile lesson as strategy). The last 10% of reliability is 90% of the work, and Module 10's eval discipline is the only vehicle that crosses it — which is why "we have a great demo" and "we have a product" are separated by precisely the golden set, the regression battery, and six months of the Topic 75 loop.
And the most senior judgment of all: knowing when not to use AI. If a regex, a SQL query, or three business rules solve it — the LLM is expensive, slow, nondeterministic tech debt wearing a trendy jacket. The engineer who says "this doesn't need a model" earns more trust than the one who models everything; restraint is the credential.
Summary
Build where errors are absorbable and verification is cheap; build for where models are going, in shapes the tide strengthens rather than absorbs; cross the demo–product gap with evals; and keep the confidence to not use AI at all. Ship small, instrument everything, let the flywheel compound.
Mental model
Surfing, not swimming: the wave (model progress) supplies the power — your judgment is position (which problems), timing (trendline, not snapshot), and balance (fallibility-absorbing design). Paddling against the wave, or standing where it breaks, are both losing strategies regardless of skill.
Mistakes to avoid
building your product's core value on patching a current model weakness (you are short the entire AI industry's R&D); and equating a wowed demo audience with product-market fit — the p99 grind, not the demo, is the product.
Exercise · the course's final one
Write your one-page thesis: a problem you're positioned to solve with AI. State — where errors get absorbed; what's verifiable; why the trendline strengthens it; the flywheel's gears; the moat among Topic 81's four; the three numbers (quality/speed/cost, Module 10) you'd track from day one; and what part deliberately doesn't use AI. Then build the concierge version. That page plus this course is everything you need.
Curriculum Complete
Look back at the distance: you started with "an LLM is autocomplete" and you're ending with unit-economics frontiers, durable orchestration, and product theses. The arc, in one breath: tokens → attention → parameters → data as the spec → LoRA and quantization → the bandwidth law → serving economics → retrieval and memory → tools, loops, and guards → the model zoo → the five deployment addresses → measurement as discipline → judgment. Eighty-four topics, and the deepest pattern across all of them: the same dozen ideas kept returning wearing new clothes — compression, verification asymmetry, cheap-wide-then-expensive-precise, everything-is-prompt-assembly, measure-don't-vibe. You didn't memorize a field; you learned its grammar. That was the deal made in Lesson 1.
What now: the exercises you skipped are the course you haven't finished — the Lesson 6 fine-tune, the Topic 75 eval suite, and the Topic 78 chatbot assembly are the three that convert knowledge into portfolio.
Next: Module 12 (Bonus) — The Career Layer. The eleven modules above make you an engineer. The bonus module makes that legible to the people who hire and fund. It is the module most curricula are too polite to include, and it is blunter than the others, because career advice that hedges is worthless.