AI is the next layer of software development

Nobody writes machine code anymore. For a good reason - it's inefficient to write. Luckily, we don't need to, because somebody already wrote it for us.

People wrote machine code, froze it into a layer, and now the rest of us build on on top of that foundation without having to reinvent that wheel.

This is a massive part of all human innovation, and in a sense it's the history of software. Assembly hid the opcodes. Compilers hid the assembly. The operating system hid the hardware. Garbage collection hid the memory. Then npm install hid the fact that someone, somewhere, already wrote the thing you needed. Each layer is pre-generated work. You don't earn it again. You build the novel part on top and let the floor carry the rest.

The effort you put in barely changes. What changes is how far it reaches. In 1980 almost everything you shipped, you wrote yourself, because the foundation under you was thin. The same slab of human work today sits on a foundation many times its size, so it ships far more without you working any harder.

So when AI drafts a function from a sentence, it isn't a break from this story, it's just the next iteration. It sits a little above the package ecosystem and a little below the code only you could write, doing what every layer before it did - replacing the work you used to do without a new foundation you can stand on.

What's different is texture, not kind. The older layers are deterministic. Run the compiler twice, get the same binary. This layer is probabilistic, so it drafts rather than guarantees, and you read what it gives you the way you'd read a dependency you didn't fully trust yet.

Though be honest: when did you last read the source of a package before installing it? npm install is also blind trust, most of the time. The distinction is subtler than deterministic versus probabilistic. A bad package either works or visibly breaks. A bad AI draft can look right, pass tests, and ship wrong. That's the real texture difference. It's a reason to stay in the loop, not a reason to reject the layer.

The useful question was never "is this real engineering?" - we answered that when we let the compiler write our assembly. The real question is the same one we've asked at every floor: "now that this is handled, what's the novel code worth writing on top?"