The new loop: think, spec, generate, verify, ship

1. The old loop is gone

For about forty years, the loop was the same. You thought about the problem. You typed the code. You ran it. You fixed what was broken. You shipped.

Most of the job was step two — typing the code. Senior engineers were people who'd typed enough code that they could think and type at the same time, and the typing didn't slow them down.

That loop is gone. Not changing — gone. The job you'll do in your first year is not the job a senior engineer did in their first year.

2. The new loop has five steps

You think about the problem. You write a specification of what you want. The model generates code from the spec. You verify the code does what the spec said. You ship.

OLD LOOP                          NEW LOOP

   think                             think
     │                                 │
     ▼                                 ▼
   type  ◄─── most of the day ───►   spec
     │                                 │
     ▼                                 ▼
   test                             generate  (model types)
     │                                 │
     ▼                                 ▼
   ship                             verify  ◄─── most of the day
                                       │
                                       ▼
                                     ship

The shape looks similar. The center of gravity moved. The old loop's heaviest step was typing. The new loop's heaviest step is verifying — reading what the model produced, deciding if you trust it, catching the parts that are wrong.

3. Why the shift matters

Typing was a skill you got better at over years. You learned the syntax. You learned the standard library. You memorized patterns so you could type them without thinking. A senior engineer typed faster, with fewer typos, and reached for the right pattern without looking it up.

The model doesn't need to learn syntax. It already knows it. It already memorized every pattern. It types without typos, in any language, at the same speed regardless of which one. The thing you spent ten years getting good at, the model is already good at on day one.

What's left is the part that was always the hard part anyway: deciding what to build, deciding if the thing you built is right, deciding what to ship.

4. What each step looks like

Think. Same as it ever was. Hold the problem in your head. Figure out what shape the solution has.

Spec. Write down what you want, precisely enough that someone (or something) else could build it. This used to be informal — a sentence in a ticket, a sketch on a whiteboard. Now it's the deliverable.

Generate. The model writes the code. You watch.

Verify. Read the code. Run the tests. Run the code. Check the types. Check the edge cases. Check the security. Check the cost.

Ship. Same as it ever was.

5. What this chapter is

The next six units take this loop apart and look at each piece. What humans type now. What the model types now. How to watch the model work. What the model gets wrong every time. Where the slow steps moved to. And what the new "10x engineer" actually does that's 10x.

If you came in expecting the job to be "type code faster than other people," this chapter is the part where you find out the job changed underneath you. That's not a bad thing. It's a chance to skip the part of the career that used to take a decade.