I read a lot of pull requests, design docs and cover letters. Over the last two years they've started to sound like each other.
Not badly written. The opposite. Uniformly competent, well structured, confidently argued, and almost interchangeable. The same three-point framing. The same tidy trade-off paragraph. The same closing line that gestures at nuance without committing to anything.
That is what happens when a few million people route their thinking through a handful of models trained on overlapping data. The floor rises and the variance collapses.
The pattern has happened before
When information was scarce, knowing things was the advantage. Whoever had the paper, the manual, the internal benchmark or the contact was ahead by default.
Then information became abundant, and knowing things stopped paying. Knowing what mattered started paying instead. Search made facts free, so the value moved to filtering, framing and taste.
AI is doing the same thing one level up. It isn't making information abundant, it's making the production of plausible answers abundant. Analysis, code, summaries, architecture proposals, research directions. All of it generated instantly, all of it reasonable-looking, and nearly all of it drawn from the same statistical centre of mass.
So the advantage moves again. Generating an answer is becoming worthless. Knowing whether the answer is good is becoming extremely valuable.
Convergence is a property of the tool, not a failure of it
This isn't a complaint about model quality. It's arithmetic.
A model gives you something near the consensus of its training distribution, adjusted by your prompt. That is exactly what you want most of the time. It's also why two engineers at different companies, asking the same question with roughly the same context, receive roughly the same answer.
The consensus answer is usually fine. It is almost never the reason anything wins.
Nothing I've worked on that mattered came from the middle of the distribution. Making a model fit inside a four-watt power budget is not a consensus problem. Neither is deciding that the interesting bottleneck is deployment rather than model size, or that your latency number is measuring the wrong interval. Those are positions. You can only hold a position if you have some reason to disagree with the average view, and the average view is precisely what a model hands you.
Where this bites in engineering
Anyone can generate code now. That was the part everyone expected to be hard and it turned out to be the easy part. What generation does not give you:
Knowing what to build. Models are excellent at answering the question you asked and completely indifferent to whether it was the right question. A generated implementation of a feature nobody needs is still waste, produced faster.
Knowing what to optimise. I do inference optimisation for a living, and most of that job is deciding where the time actually goes. Ask a model to speed up a kernel and it will speed up the kernel. It will not tell you that the kernel is three percent of wall-clock and the real cost is a memory copy that nobody instrumented.
Knowing when it's confidently wrong. This is the one that separates people. A model's tone is uncorrelated with its accuracy. It will describe a hardware behaviour that doesn't exist, or a quantization trick that silently destroys accuracy on your data, in exactly the register it uses when it's right. Spotting that requires a mental model built from having been burned before. When I was putting vision-language models on robots at Dyson, the recurring problem was never that the system lacked answers. It was that it lacked calibration about which of its answers to trust. The same failure now shows up in the tools we use to build.
Knowing what customers want. No model has sat in the room while someone tried to use the thing you shipped and gave up halfway through. That signal doesn't exist in the training data because it was never written down.
Each of those is a judgment problem wearing an engineering costume. Generation doesn't touch any of them.
Taste is compressed experience
"Taste" sounds like an aesthetic preference. In practice it's a compression of everything that has gone wrong for you before.
Knowing that a design will be painful in eighteen months is not intuition, it's memory of the last time. Knowing which benchmark is lying is memory of the last time. Knowing that a customer's stated requirement is not their real one is memory of the last time. It's a learned prior about how systems fail, and you acquire it by owning outcomes rather than producing artefacts.
Which is the uncomfortable implication of all this. The way you develop the judgment that makes you valuable in an AI-abundant world is by doing exactly the work that AI can now do for you. There's no shortcut where you skip the debugging years and arrive at good instincts.
I don't think the answer is to use these tools less. I use them constantly, and pretending otherwise would be theatre. But there's a difference between using a model to move faster through work you understand and using it to avoid understanding the work. The first compounds your judgment. The second quietly replaces it, and you don't find out which one you were doing until something breaks in a way the model can't describe.
What actually stays scarce
Assume the models keep improving, which they will. Assume everyone has equal access, which is roughly already true. What is left that is genuinely scarce?
Original experience. Things you have seen that aren't in the training data. Production failures, customer conversations, hardware quirks, the specific way your system falls over at 3am.
Problem selection. Deciding what deserves effort. This has always been the highest-leverage decision in engineering and it's now close to the only one that isn't commoditised.
Evaluation. The ability to look at a plausible output and know it's wrong. As generation gets cheaper, verification becomes the bottleneck, and verification does not scale by prompting harder.
Willingness to be non-consensus. Not contrarianism, which is just the consensus with a minus sign. Actually holding a view the average output doesn't contain, and being right often enough that it matters.
None of those are new skills. They're the skills that were always underneath, made visible now that the layer above them is free.
The output that sounds like you
The practical version of all this is small. When something you generated reads well and says nothing, notice it. When a model hands you an answer instantly, ask what it assumed, because it assumed something. When you agree with an output, check whether you agree because it's right or because it's articulate.
And when you write, put something in that only you could have put in. A number you measured. A failure you owned. A view you'd defend in a meeting.
Everything else, everyone else already has.