One lab a week.

Before you commit to a workflow, you need a feel for the three tool tiers in your hands, not in the abstract. You'll build the same trivial app, a tip calculator, in a chat assistant, an AI-native IDE, and an app builder, paying attention to the friction at each tier. The app is boring on purpose so the only variable is the tool.

A vague prompt forces the model to guess, and every guess is a place your app can be wrong. This lab makes that visible. You write a real one-page PRD first, build strictly from it, and log every spot where the spec was too thin and the model had to invent something.

Real work means changing code you didn't write, in a repo too big to hold in your head. This lab drops you into a small open-source project to add one genuine feature using agent mode, while deliberately controlling what the model sees, because context is the lever that decides output quality.

Models confidently answer from training data they may not have. RAG fixes that by retrieving your documents at question time so answers are grounded and citable. You'll build a tiny RAG chatbot over a document set the model has never seen and make every answer point back to its source.

Generators produce a lot of UI fast, but what comes out is inconsistent and sometimes inaccessible. The real skill is governing that output: pulling it onto consistent design tokens and fixing accessibility, so a fast first draft becomes something maintainable.

This is the backbone of most real apps: users sign in and see only their own data, persisted in a real database. You'll ship a working CRUD app with authentication on Supabase or Firebase and confront the part beginners skip, making data per-user and access-controlled.

Most apps are glue between services. This lab has you combine an AI API with a third-party REST API and react to a webhook, practicing authentication, error handling, and the asynchronous reality of external calls that can be slow or fail.

An agent is a model wrapped in a plan, act, observe loop with tools. You'll build one that takes a question, gathers sources, and returns a cited summary, feeling both the power (it chases the goal across steps) and the risk (a wrong early step compounds).

Section 8.6's always-on personal agent is the plan, act, observe loop living in your messaging apps. This alternate Chapter 8 lab makes you choose a narrow setup, name what could break, and put human checkpoints where mistakes are expensive, whether or not you actually install the gateway.

You learn how things break fastest by breaking them on purpose. This lab has you deliberately coax an AI into hallucinating and into writing 'looks right but broken' code, then document each failure and its fix, building the pattern-recognition that makes you a fast verifier.

AI-generated code that runs can still be wrong. This lab flips you into the verifier seat: take generated code and write a test suite that actually exposes its bugs, turning 'seems fine' into evidence.

Modern models take more than text. You'll build a small multimodal app, for example upload a photo, have a vision model describe it, and read the description aloud, chaining modalities into one flow.

The most expensive mistake in software is building the wrong thing well. This lab is deliberately no-code: you interview three real people, find one genuine pain, and design (not build) an MVP that addresses it, practicing the judgment AI can't do for you.

Code on your laptop isn't a product. You'll deploy one of your earlier apps to the public internet, add basic monitoring, and estimate what it costs to run, crossing the gap between 'works for me' and 'runs for everyone.'

You can't defend what you haven't attacked. This lab has you run a prompt-injection attack against a simple AI app, then harden it and write a short responsible-AI review, practicing both sides of the security mindset.

Founders waste months building things nobody wants. This lab forces the cheaper path first: you put a clear promise in front of real people and measure whether they care, before writing a line of product code. The deliverable is a go/no-go decision backed by evidence.

As AI content floods the web, telling signal from synthetic noise becomes a core literacy. In this lab, you investigate a real topic area, catalog the slop you find, and turn your observations into a reusable detection checklist.

You learn how AI products are built by taking them apart. This lab has you probe a shipping product, infer its architecture from observable behavior, and prove your mental model by rebuilding one slice of it.

An AI that hands out answers can quietly erode learning. This lab has you design the opposite: a tutor that asks, hints, and checks understanding, then test whether it actually teaches.

Inheriting a messy, AI-generated codebase is now a common starting point. This lab drills the skill that matters there: reading unfamiliar code, isolating what's broken, and fixing it surgically instead of starting over.

Real AI failures, from hallucinated legal citations to leaked secrets, are the cheapest lessons available. This lab has you dissect one rigorously and extract a prevention rule you can actually use.

AI makes data analysis fast and makes wrong conclusions just as fast. This lab pairs AI-assisted exploration with the human verification that keeps the conclusion honest: checking for leakage, confounders, and spurious correlation.

Local models trade frontier capability for privacy, control, and zero per-token cost. This lab has you feel that trade-off directly by shipping a small fully local app and benchmarking it against the cloud.

Fine-tuning is often reached for too early and evaluated too loosely. This lab keeps it honest: a tiny, well-scoped task, a real held-out set, and a head-to-head against the base model so you can see whether the tuning actually helped.

Indie hacking rewards finishing and shipping over polishing. This lab compresses the whole loop into a weekend: build the one feature that matters, put it online, and get it in front of real people.

The honest story of AI at work is augmentation with a human checkpoint, not full replacement. This lab makes that concrete: you automate a real chore, measure the gain, and map exactly where your judgment is still required.

AI has boomed and busted before. This lab turns that history into a forecasting tool: you reconstruct one past cycle in detail and use its pattern to make specific, checkable predictions about the present.

A working setup beats a bookmarked tutorial. This lab gets your whole toolchain installed and configured, then has you distill it into a cheat sheet of the commands, models, and settings you'll reach for repeatedly.

For a first-time programmer, reading and trusting what you built matters more than writing code from memory. This gentle lab has you make something small with AI and then explain it back, in plain language.

If you already know how to code, the adjustment has little to do with syntax and a lot to do with moving from author to director. This lab forces the new workflow on familiar ground so you can feel where your expertise still does the heavy lifting.

By the end of this lab, you'll have a real repository on GitHub that you push to over SSH with no password prompts, and a history that tells a story: a clean checkpoint, an agent run recorded as its own commit, and one deliberate revert of a change you decided against. The repo itself is disposable, and what you're actually building is the muscle memory, so that the next time an agent does something you didn't want, your hands already know what to type.

Nobody changes a habit they have never measured. In this lab, you run a real coding task with the meter visible, record the number, then design a cheaper second run and prove the saving with data rather than vibes. The skill it drills is the one Chapter Q is built on: reading your own usage output honestly, including the part where a cut in cost turns out to have cost you quality.