What AI actually changed about how I build

I started with Scratch in 2020 and Copilot in 2024, which means I have spent about half my time building software with a model in the loop. I have no nostalgic period to compare against and no career to feel threatened about. That makes me a strange witness and possibly a useful one.

The honest version is less dramatic than either side wants.

It removed the typing, not the thinking

Before, the loop was: know what I want, fight the syntax, find out I did not quite know what I wanted, repeat. The syntax fight was slow, and while it was slow it was also doing something — it was a delay during which my half-formed intent had time to finish forming.

Now the loop is: know what I want, get it, find out I did not know what I wanted. The middle step got cheap. The last step did not, and it arrives much sooner.

The bottleneck moved from "can I express this" to "do I know what I actually want". That second question is harder. It has no keyboard shortcut and no model that answers it for you, because it is a question about your own intent and you are the only available source.

The failure mode is code you did not decide on

The specific thing I have to guard against is not wrong code. Wrong code announces itself. It is plausible code — code that works, that I would not have written, and that I accepted because it worked.

Accept enough of it and you end up maintaining a system whose decisions you did not make. It runs. You cannot change it confidently, because changing something requires knowing why it is the way it is, and the answer is "a model suggested it and the tests passed."

The rule I hold to is unglamorous: if I cannot explain every line, I do not understand it yet. Not "I could work it out if pressed" — explain it, now, including why it is this way and not the obvious alternative. When I cannot, that is not a failure of the model. It is a description of where I actually am.

What it did not change

Architecture. I have never had a model tell me what a system should be, and I have stopped expecting it to. It will produce a plausible structure for a thing you describe, and plausible structure is exactly the trap — it is confident, conventional, and has no opinion about your particular constraints, because it does not know them and frequently neither do you until you have argued with yourself for a while.

It also did not find my bottleneck. Six weeks of a latency problem, and the answer was a component nobody would have flagged as suspicious — the simplest one, the one I had written first. No tool told me to look there. Profiling did.

The uncomfortable part

I do not know what I would be if I had learned five years earlier. I would probably have more syntax memorised and a much better sense of what is genuinely hard, because I would have hit walls that I now walk through without noticing they were walls.

That is a real cost and I cannot measure it. My compensation is the explanation rule, which is a deliberate way of manufacturing the friction that used to be free. Whether that is enough is not something I can know yet, which is exactly why it is written here rather than settled.