The thing that actually changed

Experienced developers always knew what good code was. Taste was never the bottleneck. The bottleneck was the distance — the immense, hour-by-hour traversal between the design clear in your head and the same thing realised in your file tree. You knew exactly what you wanted; getting there was the expensive part.

AI collapsed that distance by an order of magnitude. The structure you can see in your mind now appears in your editor almost as fast as you can describe it. For anyone who already had the taste, this is intoxicating — most of the cost of being right just evaporated.

But the feeling of bending reality to your will is partly an illusion, and the illusion is where the danger lives. The model is not a faithful scribe. It cuts corners at random, gets lazy, quietly drops half an instruction — and hands the result back with total confidence. The distance shrank; the fidelity didn’t come with it. What you get is fast realisation, not trustworthy realisation, and the gap between the two is exactly where slop is born.

That old distance was also doing a second, quieter job: it was a filter. A sprawling or careless design cost real hours to build, so people thought twice — bad ideas were rationed by how expensive they were to commit. That filter is gone too. Now the wrong thing is as cheap to produce as the right thing, and the agent will help you build either one with the same eager fluency.

So the job changed underneath us. It was never really writing — that was always just the toll you paid to get the good thing out of your head. Now the toll is gone, and the scarce, valuable work is what’s left: deciding what to write, bounding it so it can be delegated, and verifying what an unreliable executor actually gave back. This course is about that work — and the discipline that makes it reliable.