A while back I wrote that the gate got wider, that more people can build software now because the unrelated friction got stripped away. I still believe every word of it. This is the other half of that thought, the part that does not fit on a celebratory poster. The gate got wider, yes. But something got narrower at the same time, and almost nobody is talking about it.

Here is the uncomfortable version. Generating code became nearly free. Being responsible for it did not get cheaper by a single cent.

the thing that actually got easy

Let me be precise about what changed, because the hype blurs it. What collapsed in price was production. The act of turning an intention into a working block of syntax used to cost you minutes or hours of typing, looking things up, fighting the compiler. Now it costs a sentence and a few seconds. The supply of code went vertical.

What did not collapse is everything downstream of that block of code existing. Someone still has to decide whether it is correct. Someone has to notice that it handles the happy path and quietly drops the three cases that actually hurt you in production. Someone has to be standing there, named, when it fails at the worst possible moment and a real person is on the other end of the failure.

That someone is you. It was always going to be you. The model does not get paged at three in the morning. The model does not sit in the incident review. The model will, with total confidence, hand you four hundred lines and feel nothing about whether they are right, because it is not capable of feeling anything about it. The accountability did not move. Only the typing did.

the trap hiding inside the convenience

There is a specific failure mode I keep watching people walk into, and I have walked into it myself. You ask for something, you get a confident, well-formatted answer, it looks like code a competent person would write, and so you wave it through. It runs. The tests, such as they are, pass. You merge.

The problem is that looks right and is right have never been further apart than they are now. Generated code is fluent by construction. It has the cadence of correctness. It uses the right library names and the right idioms and the confident tone of someone who knows what they are doing. None of that is evidence. Fluency is exactly the thing the model is best at, and correctness is exactly the thing it cannot guarantee.

You cannot review what you cannot understand. And a thing you waved through without understanding is not a thing you reviewed. It is a thing you adopted.

That is the line I keep coming back to. The moment you accept a block of code you could not have written and could not fully explain, you have not saved yourself the work of understanding it. You have only deferred that work to the worst possible time: the outage, the audit, the customer email, the moment when understanding it is suddenly urgent and you are starting from zero.

the floor of judgment went up

So here is the strange shape of it. The floor for making software came down, which is the good news I already wrote about. But the floor for owning software went up. When code was expensive to produce, the slow act of writing it forced a kind of understanding on you whether you wanted it or not. You could not ship a system you had never thought about, because typing it out was itself the thinking.

That forced understanding is gone now. The thinking is no longer bundled into the typing. You can hold a working system in your repo that no human in the building actually understands, and nothing will stop you until it breaks. The understanding still has to happen. It just stopped being automatic, which means now you have to choose it on purpose.

Which is why the scarce skill quietly changed jobs. It used to be production: can you make the thing exist. Increasingly it is judgment: can you tell whether the thing that now exists is any good. Taste. Review. Knowing what to ask for, and knowing the difference between an answer that is plausible and an answer that is true. The market is about to be flooded with people who can generate code and a small number of people who can be trusted with it, and those are not the same people.

how i try to actually own it

I do not have a clean framework, but I have a few rules I keep returning to, mostly learned by getting them wrong first.

Do not merge what you cannot explain. If I could not stand at a whiteboard and walk a colleague through why this code is correct, it does not go in, no matter how nicely it is formatted. Generated or not, the bar is the same bar it always was. The model is a very fast junior who never gets tired, and you would not merge a junior's PR you did not understand either.

Read it like you are looking for the bug, not like you are hoping there isn't one. Those are different postures and they find different things. The convenient posture is to skim for anything obviously broken and approve. The honest posture is to assume something subtle is wrong and go hunt for it, because with confident generated code, something subtle usually is.

And keep your own hands in the codebase. The fastest way to lose the ability to review generated code is to stop writing any yourself. Judgment is not a static credential you earned once. It is a muscle, and it atrophies in exactly the conditions that make it most tempting to let it.

so, the sign-off

None of this is a complaint about the tools. I use them every day and they have made me faster and, on my good days, better. The gate got wider and I am still glad it did. I just want to say the quiet part next to the loud part, because the loud part on its own is a setup for a lot of people to get burned.

The model can write the code. It cannot own it. Ownership is a thing with your name on it, and a name is not something you can generate. When it ships, you shipped it. When it breaks, you broke it. That part never went on sale, and I do not think it ever will.

e.