Software is abundant. Judgment is not.

For most of the history of software, the constraint was obvious: making things was slow. A working prototype took weeks. A shipped feature consumed a quarter. Every company that built software organized itself, whether it knew it or not, around the scarcity of engineering time. Roadmaps were rationing systems in disguise. Product reviews were arguments over which ten ideas, out of the hundred worth trying, deserved the only developer-months anyone actually had.

That scarcity did something useful, almost by accident. It forced judgment early, because judgment was cheaper than building the wrong thing. A founder who spent two weeks with users before writing a line of code was not being careful for its own sake. She was hedging against the true cost of a wrong guess. A team that argued for a month over a schema was not being slow. It was pricing in the fact that schemas, once built on, are expensive to unwind. Scarcity is a strange kind of teacher, but it is a real one. It punishes carelessness quickly enough that organizations eventually learn to stop being careless.

That teacher just retired.

The cost of making software, in the plain sense of writing the code, designing the screen, drafting the copy, testing the flow, is falling toward zero. This is not the familiar story of tools getting better, the way faster IDEs or better frameworks or cheaper infrastructure have made engineers more productive for forty years. It is a different kind of event: an economic phase change, not a productivity gain. When something that used to require irreplaceable human hours can be produced continuously, in parallel, at almost no marginal cost, it stops being a constraint on the system. It becomes a background condition, the way electricity is, or bandwidth once was.

This has happened before, more than once, and it is worth remembering what happened next each time, because it was never what anyone expected in the moment.

When the printing press made words abundant, the scarce resource in publishing did not disappear. It moved, from the physical difficulty of producing a book to the intellectual difficulty of knowing which of the infinite possible books were worth producing at all. That gave the world editors, critics, and publishing houses: institutions with no reason to exist when a single book took a monastery a year to copy by hand.

When the camera made images abundant, the scarce resource in photography moved from the technical act of exposing film to the editorial act of choosing, out of thousands of frames, the one that actually said something. That gave the world picture editors, and later, the feeds and algorithms that now perform a version of the same job at a different scale.

When the factory made goods abundant, the scarce resource in commerce moved from the ability to manufacture to the ability to decide, correctly and ahead of time, what people would actually want to buy. That gave the world market research, brand, and merchandising as disciplines in their own right, rather than afterthoughts bolted onto production.

Software is having its printing-press moment now, compressed into years instead of centuries, and the industry has not built its version of the editor yet.

What abundant generation actually produces is not fewer decisions. It is more of them, arriving faster, and arriving as an open field instead of a narrow path. A team that could once afford to seriously consider three designs for a screen can now generate thirty before lunch, in a dozen tones and layouts and languages, at almost no cost beyond the API bill. From a distance that looks like speed. Up close it is closer to a flood: more surface area than any group of humans can hold in their heads at once, let alone reason carefully about.

This is the part of the story that gets missed when people talk about AI mainly as a productivity tool. Productivity was never really the constraint. Comprehension is. A team can now build more product in a month than its own users could meaningfully react to in a year, which means the real risk facing a modern product organization is not that it fails to ship. It is that it ships constantly, confidently, and is wrong in ways it does not discover until the wrongness has already compounded into a roadmap, a reputation, a cap table.

The traditional answer to that risk is user research, and user research is not broken so much as it was simply never built for this tempo. Its whole architecture assumes decisions arrive slowly enough to wait for it: recruit a panel, schedule the sessions, run the study, synthesize the findings, and bring them back to a team that, three weeks later, is already working on something else entirely.

That lag was tolerable when building was the bottleneck, because research and engineering moved at roughly the same speed. It is not tolerable now. A team shipping a hundred meaningful decisions a month cannot recruit a hundred panels a month, and pretending that a research process scaled for the old world can simply be run faster is not a plan. It is wishful thinking wearing a project plan’s clothes.

So most teams have quietly stopped trying. They ship, they watch a dashboard, and they call the aggregate outcome learning, which is really a way of doing research on real customers after the decision has already been made, and hoping the lesson arrives before the damage compounds. That is not judgment. It is an autopsy with better instrumentation.

We do not think the answer is a faster version of the old research process. We think it is a different kind of object entirely: not a study you commission when you have a question, but a standing, living model of the people you are building for, one you can query as fast as you can change your mind, and one that gets more accurate every time you ship something and find out what actually happened.

That is the thing we are building. We ground populations of AI agents in real census data, in behavioral science, and in a team’s own evidence: their interviews, their usage data, their support conversations, their existing research, so the population reflects an actual market rather than an average of the internet’s opinions. We run product decisions, pricing, design, roadmap, positioning, through that population before they harden into a release, the same way an engineer runs a test suite before merging code that would be expensive to undo. And we close the loop: when a decision ships, we tie the outcome back to the simulation that predicted it, so accuracy becomes a number that compounds, not a claim anyone has to take on faith.

Other labs are racing to build models of the physical world: systems that simulate matter, motion, and causality, the rules water and light and gravity actually obey. That is a hard and important problem, and not ours to solve. Someone still has to build the other half of the same idea: a model of the human side of the decision, of how a specific, real population of people responds to a specific, real change, before the change exists. It is not a caricature of users reduced to a demographic footnote. It is a grounded, calibrated, falsifiable model of the market itself.

We do not think the winners of this decade will be the companies that build the most. Building has stopped being the differentiator. It is becoming table stakes, available to nearly everyone, nearly instantly.

We think the winners will be the companies that build correctly the most often: the ones with a compounding, institutional sense of consequence, who know whether an idea was worth building before it hardens into a habit their users depend on.