The Build Loop

Here is the loop you'll run over and over. It's small on purpose.

1. Slice the feature into small vertical steps. Each step should be something you can build, run, and see working in a few minutes.
2. Pick one step. Just one. Ignore everything else for now.
3. Prompt for that one step. Be specific about what changes and what stays the same.
4. Review the change. Read what the AI wrote. You don't need to understand every line, but skim it for anything obviously wrong.
5. Run the app. Actually click the button, load the page, hit the endpoint. Confirm the step works.
6. Commit. Save a checkpoint in version control with a short message.
7. Repeat from step 2 with the next step — until the feature is done.

Drawn as a cycle, the loop looks like this — you keep going around it, one small step per lap, until the feature is finished:

        ┌──────────────────────────────────────────┐
        │                                           │
        ▼                                           │
   ┌─────────┐    ┌─────────┐    ┌──────────┐       │
   │  SLICE  │───▶│  PICK   │───▶│  PROMPT  │       │
   │ feature │    │ one step│    │ for step │       │
   └─────────┘    └─────────┘    └────┬─────┘       │
   (once, up                          │             │
    front)                            ▼             │
                                 ┌──────────┐       │
                                 │  REVIEW  │       │
                                 │ the diff │       │
                                 └────┬─────┘       │
                                      ▼             │
                                 ┌──────────┐       │
                                 │   RUN    │       │
                                 │ the app  │       │
                                 └────┬─────┘       │
                          works?      │             │
              broken ◀────────────────┤             │
              undo & re-prompt        │ yes         │
                                      ▼             │
                                 ┌──────────┐       │
                                 │  COMMIT  │───────┘
                                 │checkpoint│  next step
                                 └──────────┘

The whole point is that you're never far from a working app. If step 4 produces something broken, you only have one small change to undo, not a tangled mess.

People who skip steps 4 through 6 feel faster for about twenty minutes. Then they hit a bug they can't locate, because the last known-good version of their app is a hundred changes back. The loop feels slow precisely because it never lets you build up that kind of debt.