AI Made Output Cheap. It Didn’t Make Attention Cheap.
There is an old instinct in software engineering that I think is becoming relevant well beyond software: more output is not the same thing as more value.
More lines of code has never meant more engineering. If two systems solve the same problem, the simpler one is usually easier to understand, test, secure and maintain. Code is both an asset and a liability. Every line we add is something that may need to be understood later, tested, documented, patched and reasoned about when circumstances change.
That is why experienced engineers develop a healthy suspicion of unnecessary machinery, and why some of the best engineering work ends with less code than you started with. Somebody found the unnecessary abstraction, removed a special case or realised that something did not need to exist at all.
AI is starting to teach the rest of knowledge work the same lesson.
I was listening recently to Tobi Lütke, Shopify’s CEO, describing a pattern that has become increasingly recognisable. He called them “slop grenades”: large amounts of AI-generated work thrown over the wall for somebody else to deal with.
It is a good phrase because it names something many people have started to notice. Lazy work no longer necessarily looks like too little output. Increasingly, it can look like far too much: a giant pull request, a ten-page document, a detailed analysis, twenty neatly formatted tickets, a wall of text in Slack. All generated quickly, sometimes barely read by the person who produced it, then handed to somebody else, human or machine, to understand, verify, untangle, reject or absorb into the next stage of the system.
The work has not disappeared. It has moved.
Production is no longer the expensive part
For most of our working lives, producing something substantial involved enough friction that the output itself carried some information about the effort behind it. A long report took time to research and write. A presentation took time to assemble. Thousands of lines of working software certainly took time to produce.
That was never the same thing as quality. We have all seen enormous documents and codebases that would have benefited from being half the size. But production had a meaningful cost.
Generative AI changes that equation very quickly. I can now ask a model to produce ten approaches to a problem in roughly the time it once took me to formulate one properly. An engineer can generate changes across a codebase in minutes. A product manager can turn a few paragraphs of intent into pages of requirements almost instantly.
That is useful. I use these tools constantly and have no nostalgia for doing everything the old way.
The important asymmetry is that the cost of producing information is falling much faster than the cost of evaluating and acting on it.
A model can generate a 5,000-word analysis in seconds. Other models can summarise it, challenge it, compare it with alternatives and verify parts of it just as quickly. But somewhere in the system, a decision still has to be made about whether the assumptions are sound, what matters, which trade-offs are acceptable and what should happen next.
The same is true of code. Generating an implementation is becoming dramatically cheaper. Agents can review other agents. Tests can be generated and executed automatically. Static analysis can catch whole classes of problems. None of that means the surrounding system no longer needs architecture, context, judgement or responsibility.
AI does not remove bottlenecks. It relocates them.
AI-native means redesigning the system
There is an obvious objection here. If AI can produce software, documents and analysis much faster, perhaps the humans reviewing all that output are simply the old bottleneck. If every tenfold increase in machine output requires a proportional increase in human review, then we have not built an AI-native system. We have attached a very efficient generator to an old process.
That objection is right.
AI-native should mean designing around the strengths and limitations of AI rather than preserving every workflow we inherited from a world where production was expensive. Agents should review other agents where that works. Low-risk decisions should become autonomous. Tests should do more of the checking. Humans should not inspect every artefact simply because humans used to produce every artefact.
The mistake is jumping from that to the idea that human judgement has therefore become obsolete.
Spend any serious amount of time building with current models and the distinction becomes difficult to ignore. They can produce remarkably good implementations, analyses and designs, while still producing something that is subtly wrong for reasons that are hard to specify exhaustively. The abstraction is technically valid but wrong for the system. The analysis is internally coherent but based on the wrong frame. The product decision makes sense locally but creates an ugly constraint later. Ten individually reasonable choices combine into something nobody would deliberately have designed.
This is where taste, intuition, tacit context and judgement still matter enormously.
An AI-native organisation should automate aggressively around those points, not pretend those points have disappeared.
Individual productivity can still create organisational drag
This is why some of the current conversation about AI productivity feels too narrow.
If I spend five minutes generating a document that requires six other people to spend half an hour each understanding and reviewing it, I have not created five minutes of work. I have created several hours of downstream work and moved most of the cost somewhere else.
That downstream cost does not have to fall on a human. It might fall on another agent, an automated test suite, a verification pipeline or, if none of those catch the problem, a customer or production system later on.
The point is not that humans must inspect everything. The point is that generated output is not free merely because generation was cheap.
There is even a research term emerging for this. Researchers have used “workslop” to describe AI-generated work that shifts the burden of interpretation and correction onto somebody else. One BetterUp Labs and Stanford survey found that more than a third of desk workers had encountered it, with recipients reporting hours each month spent dealing with the consequences.
The wider pattern matters more than the label. You can make an individual look dramatically more productive while making the system slower. Engineers should recognise this because we have spent decades learning that optimising one stage of a system does not necessarily improve the whole. If the constraint moves elsewhere, you may simply have built a queue.
When writing becomes cheap, editing and selection matter more. When implementation becomes cheap, architecture, testing and integration matter more. When research becomes cheap, deciding what evidence deserves weight matters more. When generating ideas becomes cheap, choosing among them becomes the work.
And when information becomes abundant, attention becomes more expensive.
Generation is not completion
None of this means we should deliberately constrain generation while thinking. Quite the opposite.
One of the things I value most about modern models is that they make exploration cheap. Generate ten hypotheses. Ask for the strongest counterargument. Produce the ugly first draft. Explore an approach you would previously have dismissed because investigating it would have taken too long. Have an agent create twenty test cases rather than three.
That expanded search space is enormously useful.
But there is a difference between what is generated as part of the search process and what is allowed to propagate through the wider system.
If I ask a model for twenty approaches, that does not mean twenty approaches deserve escalation. The useful work may be understanding them well enough to identify the three worth discussing.
If an agent produces a 2,000-line change, the job may not be finished because the tests pass. Perhaps another agent can simplify it. Perhaps the implementation can be reduced before a human sees it. Perhaps no human needs to inspect it at all if the system has enough confidence in the surrounding controls.
The principle is not that a person must review everything. It is that generation should not be confused with completion.
AI gives us permission to be expansive while exploring. It does not give us permission to let every intermediate artefact leak into everybody else’s attention.
The scarce part is judgement
Attention is the constraint, judgement is the scarce input, and curation is what judgement looks like under abundance. They are really different parts of the same problem.
Models are becoming extraordinarily good at reasoning over large amounts of information. They can produce options, challenge assumptions, search through possibilities and increasingly perform useful verification themselves.
But reasoning and judgement are not quite the same thing.
Reasoning can tell you what follows from a set of assumptions. Judgement is about deciding which assumptions matter, whether the frame itself is wrong, which trade-off is acceptable, when an answer is technically correct but strategically bad, and whether something is worth doing in the first place.
Some of that will be automated too. I would be surprised if it were not.
But right now, good projects, products and systems still depend heavily on people with enough experience to recognise when something feels wrong before they can fully articulate why, enough taste to distinguish a merely functional solution from a good one, enough intuition to make useful connections that were never explicitly encoded in the problem, and enough context to know which seemingly sensible option does not fit the situation.
The role of the human therefore changes. It becomes less about manually producing every artefact and more about setting direction, providing context, recognising quality, deciding where scrutiny is warranted and taking responsibility for the result.
That is not resistance to AI-native working. It is what good AI-native working looks like today.
The goal is not to preserve human review for its own sake. It is to preserve human judgement where it still adds value while eliminating as much unnecessary human labour as possible.
Curation is part of the work
We have often treated editing, filtering and summarising as secondary activities. Someone produces the work, then somebody tidies it up.
That distinction stops being useful when production approaches zero marginal cost.
Choosing what survives the generation process becomes part of the primary work. Which argument is actually strong? What can be removed? Which implementation is unnecessarily clever? Which model suggestion survives contact with reality? What deserves escalation? What does the next person, agent or system actually need?
Those are curation questions, but curation here is broader than editing. It is selection under abundance.
The people and organisations that get the most value from AI will not necessarily be those producing the most with it. They may be those best at using AI to explore widely while remaining selective about what gets promoted into codebases, products, decisions and other people’s attention.
Software engineers have had a version of this instinct for decades. Nobody sensible celebrates a codebase simply because it contains more code.
We are going to need the same instinct everywhere else.
AI made output cheap. It didn’t make attention cheap.
The new laziness isn’t failing to produce. It’s refusing to curate.