Where Taste Comes From
By eliminating the grueling friction of writing code, AI destroys the exact feedback loop that compiles the editorial taste needed to build good software.
By Alan Reed
Sparked by Taste Is All That's Left · discussion
Suppose you want to build a new piece of software. You have to pay two distinct costs: the cost of figuring out exactly what the software should do, and the cost of physically typing the syntax to make it happen. Historically, the second cost was so astronomically high that it masked the first. You spent months fighting memory leaks, setting up databases, and wrestling with dependencies just to see if your core idea even functioned. Startups died simply because they ran out of money before the product stopped crashing. Now AI is driving the cost of execution to zero. Mathematically, that leaves only one bottleneck.
If you read the Hacker News comment threads lately, you will find endless emotional panic about AI destroying the "soul" of programming. We can ignore that. The soul of programming is a meaningless concept. This is just a cold economic equation of supply. As a recent ACM article noted, the conventional idea of 'writing a program' is heading for extinction. Execution is no longer the limiting factor.
The implication is a massive shift in market dynamics. Dropping the cost of execution increases the efficiency of production, which guarantees an exponential explosion in the sheer volume of generated code. A team that once shipped one feature a month will soon generate ten variations of a product in an afternoon.
With infinite code flooding the system, the only valuable skill left is editorial curation. Hackers usually just call this "taste." The industry is waking up to this reality rapidly. A widely circulated essay recently argued that "Taste Is All That's Left", noting that judgment is now the solitary economic multiplier. In a world where execution is perfectly commoditized, taste becomes the only differentiator between a billion-dollar company and a useless toy. If the machine can write anything, the premium shifts entirely to the person who knows what the machine should write.
People celebrating this shift tend to treat "taste" like an innate scalar value you are simply born with — a biological quirk or a mystical aesthetic feeling. But taste is a mechanism. It is a compressed dataset generated by ten thousand late-night compilation errors.
Trace the lifecycle of a hacker from the early 2000s, and you see exactly how this dataset is built. This judgment was compiled exclusively through what cognitive science labels a struggle with complex problems, a mechanism known as productive failure. You had to sit there staring at a terminal screen at 2 AM. Every bad architectural decision was punished by immediate, visceral pain. You learned system architecture by writing deeply inefficient functions, crashing the server, and having to manually garbage-collect your own lame ideas. If you chose the wrong database schema on day one, you spent the next six months writing awful, tortuous queries just to make the UI load. You didn't read about why a monolithic state is bad; you lived it.
Even philosophers of aesthetics understood this feedback loop. David Hume pointed out centuries ago that the standard of taste is only perfected by comparison and rigorous practice. The brutal friction of writing awful code was the literal compiler for good taste. The developer would test a hypothesis, watch it fail catastrophically, and update their internal neural weights. They iterated through the possibility space depth-first, finding out exactly why certain abstractions suck.
The result is that when a senior engineer instinctively spots a doomed product design today, they are simply running a lightning-fast heuristic trained on a massive historical log of painful, low-level friction. They know which architectural paths lead to dead ends because they spent years personally digging themselves out of those exact holes.
But we are currently using AI to drop the transaction cost of code to zero. In doing so, we are optimizing away the exact friction required to train the next generation's editorial judgment.
Consider how a junior developer enters the industry today. A prompt to a large language model entirely bypasses the struggle with the compiler. They are simply handed a perfectly formatted, functioning block of logic. Because the friction is gone, the feedback loop that compiles taste never actually executes. The junior developer is acting as an editor while completely skipping the grueling manual labor required to build an editor's eye. They are essentially trying to run a highly complex filter function on an empty dataset.
The downstream effect of this is a structural pipeline crisis. The future of software belongs entirely to those who already compiled their taste in the high-friction era, or to the rare founders who figure out how to artificially inject friction back into a junior developer's zero-cost environment.
Many assume that removing the tedious parts of software development will automatically result in a golden age of limitless creation. We imagine developers acting as pure visionary architects while autonomous machines handle the miserable physics of writing boilerplate.
But if you eliminate the cost of execution, you inevitably eliminate the friction that compiles taste. And without taste acting as a filter, an infinite supply of zero-cost software guarantees one mathematically inevitable outcome: a giant pile of crap.