Build It

Time: 45 minutes
You'll end up with: Your thing running on your machine

Why this exists

This is the first time you point everything you've learned at something that didn't exist an hour ago. Project, structure, plan mode, permissions, git — all of it, at once, on something you actually want.

It's also where the reflex to say "just do it" is strongest, and where that reflex costs the most.

The idea

Build in slices you can see working, and commit each one.

The failure here isn't Claude being bad at building. It's asking for the whole thing at once, getting something enormous back, finding it doesn't quite work, and having no idea which part is wrong — because none of it has ever worked.

So: smallest possible working version first. Then add.

Round	What you ask for	Why
1	The simplest version that runs at all	Something works. You have a baseline.
2	One thing from the brief	You know exactly what changed
3	Next thing	Same

Each round: plan mode, read the plan, approve, check it still works, commit. That last step is what makes the whole thing recoverable — from 4.2, a commit is a point you can get back to. Building without committing is building without a floor.

Read the plan properly. Plan mode is doing its most valuable work right now, because you're changing a thing you don't fully understand yet. Fifteen seconds of reading catches a misunderstanding while it's still free.

"It runs" is not "it works." The strongest habit you can build in this lesson is checking the actual thing after every round — open it, click it, use it. Not reading Claude's summary of what it did. The summary is a claim. The running thing is the evidence, and this is the same instinct 2.1 taught you about numbers.

When it goes wrong — and it will — you don't need to fix it yet. That's 5.3 and 5.4. For now: if a round breaks something, you have a commit from the round before, and going back to it costs nothing. That's the whole point of having done Level 4 first.

Do

Open your project folder from 5.1 in Claude Code. Make sure git is set up — git init if you haven't.
Round one: ask for the simplest version that runs at all. Plan mode on. Read the plan before approving.
Open the thing. Confirm it works with your own eyes.
Commit, with a message saying what round one was.
Round two: one item from the brief. Plan, read, approve, check, commit.
Keep going, one item per round, until the brief is covered.
When a round breaks something — don't fix it. Reset to the last commit and try the round again with a clearer ask.
When you're done, run git log --oneline and look at the history you built.

Step 7 will feel like giving up. It isn't. Re-running a round from a clean state is almost always faster than untangling a half-broken one, and you'll use that move constantly in Level 6.

Done when

Your thing runs on your machine and does what the brief said.
git log shows a commit per round, not one big commit at the end.
You checked the actual thing after every round, not just Claude's summary.
You reset to a commit at least once and it cost you nothing.

Never do

Don't ask for the whole thing in one go. You get something big, it doesn't quite work, and you can't tell which part is wrong because no part of it has ever worked on its own.

Don't go more than one round without committing. An uncommitted round is a round you can't undo — and this is exactly the situation Level 4 existed to prevent.