Most software is not being eaten because it is simple. It is being eaten because it has been built ten thousand times before, and every one of those builds is sitting in the training data. Complexity was never the fault line. Originality is.
Author: James Phoenix | Date: July 2026 | Riffs on: Marc Andreessen, “Why Software Is Eating the World”
The Diagnosis Everyone Reaches For Is Wrong
The standard line on why AI is gutting software is “it automates the simple stuff.” Todo apps, CRUD dashboards, auth flows, Stripe integrations. A twelve-year-old vibes one together in an afternoon, so obviously the easy tier is commoditized and the hard tier is safe.
That framing is comforting, and it measures the wrong axis. Plenty of CRUD apps are not simple. A multi-tenant admin panel with role-based permissions, soft deletes, audit logs, and a dozen edge cases in the billing state machine has real complexity in it. A model still one-shots most of it. Not because the problem is easy, but because the exact shape has been solved in public ten thousand times, and every solution is sitting in the corpus the model trained on. The model is not reasoning through your billing state machine. It is recalling the modal answer to a question it has already seen answered a hundred thousand times on GitHub.
What Actually Gets Eaten
Cliché is the tell, not simplicity. A cliché is any problem that has been solved often enough that the solution converged on a template: the SaaS dashboard, the marketplace checkout, the internal ops tool, the “AI wrapper” that pipes a prompt through an API and calls itself a product. These are not eaten because they are easy to build. They are eaten because there is nothing left to decide. Every design choice was already made by the ten thousand people who built the same thing before you, and the model just has to retrieve the consensus.
This is the mechanism underneath code becoming free at the low end. It is not that low-end code is dumb code. It is that low-end code is repeated code, and repetition is exactly what a next-token predictor is built to exploit.
What Survives
The flip side is not “hard problems survive.” It is unprecedented problems survive, and those two categories overlap less than people assume. A genuinely novel product decision, an unfamiliar business constraint, a design direction nobody has tried, a technical approach with no Stack Overflow answer because nobody asked the question yet: none of that has to be complicated. It only has to be new enough that no consensus answer is sitting in the weights.
That is the same claim as answer keys are authored, not found, approached from the other side. A cliché is a problem with a de facto answer key, because enough people solved it that their solutions became the training signal. A genuinely creative or critical decision has no answer key yet, because nobody has graded it. The coder-versus-programmer split is the same fault line again: the coder executes a known pattern, the programmer decides which pattern should exist. AI ate the first role because the first role was always cliché by definition, syntax for a known shape. It cannot touch the second, because there is no corpus of “the right novel decision” to recall from.
The Test I Actually Use
Before starting something, I ask one question: has this exact shape shipped ten thousand times already? If yes, expect a fast follower to clone it over a weekend with an agent, and do not expect to get paid for the build itself. What is left to sell is whatever is not cliché about it: the distribution, the taste, the specific judgment call nobody else made. If the answer is no, the leverage is real, not because the work is hard, but because there is no template to recall and someone still has to decide what good looks like.
That is where engineers get paid their weight in gold now. Not for typing faster than a template. For being the first answer key.
One Sentence
AI did not commoditize simple software, it commoditized repeated software, and the money moved to whoever is doing something for the first time.
Related
- Moats vs Execution: Code Was Never a Moat – The market-level version of this claim: code is free at the low end, amplified at the high end
- The Coder is Obsolete. The Programmer is Not. – The coder executes known patterns, the programmer decides which pattern should exist
- Answer Keys Are Authored, Not Found – Cliché problems have answer keys because enough people solved them first
- Seniority Was a Proxy for Typing Speed – The proxies that just got repriced were always proxies for having seen the pattern before
