There is a moment in every industrial transition that most people miss.
It is not the arrival of the new machine. It is the moment someone realizes the machine changes what counts as a valuable unit of work. A weaver in 1800 did not lose their livelihood because the power loom was faster. They lost it because the unit of value shifted from individual skill at the hand loom to ownership and operation of the factory that housed the power loom.
The same shift is happening now. But the factory is not a building with smokestacks. It is a system of software, models, iteration loops, and human judgment. The unit of value is no longer the output you produce. It is the factory you build to produce it.
This is the argument I keep turning over. Not about AI replacing people. About what happens when the cost of trying something falls to near zero, and the thing that used to be valuable, the single correct output, becomes the cheap byproduct of a system that can run a thousand experiments before breakfast.
The cost of a try
What AI does is not magic. It collapses the cost of the try.
High iteration cost means you plan more, test less, commit early to one path. Low iteration cost means you can explore more branches, discard more failures, and let the best result emerge from volume. The marginal cost of a single prompt or agent-generated module is now so low that the constraint is no longer writing. It is knowing what to write. It is knowing what to keep. It is knowing what to discard.
One useful frame: the waste is not tokens. The waste is your time. If a model burns a million tokens exploring dead ends while you drink coffee, that is a good trade. The scarce resource is not computation on the server. It is attention, judgment, and verification on the human side. The most efficient person is not the one who produces the most output in the fewest steps. It is the one who runs the most useful experiments, discards the wrong ones fast, and knows a good result when it appears.
Software factories
When iteration is cheap, the software itself stops being the main artifact. The artifact becomes the system that produces software. The factory, not the product. The teams that get the most leverage from AI are not the ones who prompt for one-off scripts. They build systems that prompt, test, refine, and deploy on their behalf.
This changes who holds leverage. A single developer with a well-built factory can generate output that previously required a team of twenty. That sounds like fewer jobs, and it may be for some categories of work. But the more interesting effect is that it enables people who could not afford a twenty-person team to build things that compete with one. When models can generate, test, and explain code, the remaining scarce skill is not syntax. It is architecture, judgment, and taste.
Hardware becomes software
Hardware engineering has historically been resistant to this kind of leverage because physical prototyping is expensive. That is changing. Generative design tools and simulation models turn hardware into a software-like iteration loop. The engineer sets the constraints, the system generates candidate designs, simulation validates them, and the physical build happens at the end.
One example that stuck with me: someone described vibe coding a turbine blade. The phrase sounds absurd until you realize the mechanism is sound. The engineer sets the performance requirements, the model explores the geometry space, the simulation validates the aerodynamics, and the human makes the final call. The iteration happens in software. The physical object is the last step. Leverage shifts from the machinist who makes one precise part to the engineer who can evaluate a thousand simulated designs and pick the right one.
Open source and the hardware multiplier
China has a hardware advantage that is not about factories alone. It is about iteration speed. When you control the supply chain, you can turn design iterations into physical products faster than anyone else. Open source models amplify that because they remove the licensing bottleneck. A company can take an open-weight model, fine-tune it on its own design data, and run it across its engineering organization without asking permission.
The combination of open models, domestic production, and aggressive prototyping creates a feedback loop that is hard to compete with from a regulatory-heavy environment. The usual response is to propose more regulation. When the iteration advantage is the primary source of leverage, adding process steps is the wrong move. You do not beat a faster competitor by making your own process slower.
Frontier models and concentration
The argument for concentration: the most capable models require enormous investment, so only a few organizations can build them. The counterargument is that intelligence applied to a narrow domain can outperform a generic frontier model on that domain. There is a tradeoff between generality and specialization.
The practical consequence is that the most useful AI systems will not be the single largest model. They will combine a capable model with the right data, constraints, verification loop, and human in the loop. The model is a component. The factory is the system around it. This is good news for small teams. The team that knows its problem better than anyone else can build a system that outperforms a generic frontier model on that problem.
Humans as verifiers
The most consequential shift in human work is the transition from producer to verifier. Execution becomes less valuable relative to judgment. Speed becomes less valuable relative to taste. The ability to produce a correct output becomes less valuable than the ability to recognize one and know what to do when the system does not produce one.
This is uncomfortable for people who built their identity around being the doer. It is liberating for people with strong judgment who were limited by execution bandwidth. The person who can specify the right thing and verify the result becomes more valuable than the person who can execute a known process a thousand times.
The challenge is that verification at scale is not a natural human skill. We see what we expect to see. We miss anomalies. We get bored and start approving things we should reject. Building systems that compensate for these limitations is itself a factory problem.
Regulation as an iteration problem
Regulation is change-aversion codified into law. Every approval step adds iteration cost. That was the design intent. The difficulty is that when the rest of the world is collapsing iteration costs, a system that keeps them high becomes a competitive liability. The regulated entity falls further behind with each cycle. The regulator calls it safety. The market calls it extinction.
This is not an argument for no regulation. It is an argument that the current model, which assumes a stable world with linear change, does not fit a world where the underlying technology is doubling in capability every year. Regulating AI through the same process used for food safety or building codes assumes the thing being regulated is stable enough that a multi-year review cycle makes sense. That assumption is false.
The better model mirrors the iteration dynamic it governs: faster feedback loops, smaller batches, more experimentation within bounded domains, and a mechanism for correcting mistakes quickly rather than preventing every possible mistake upfront. The fifty-state experiment model, where jurisdictions compete on policy approaches and the best ones spread, is more relevant now than when it was designed.
Healthcare and N-of-1
Healthcare is the hardest case and the most important. Evidence-based medicine is designed for populations, not individuals. A randomized controlled trial establishes what works for the average person. The individual patient may not be average. But the system has no mechanism for learning from that individual except through another multi-year trial.
AI enables N-of-1 medicine. A patient's physiology produces data. The model learns. The treatment adjusts. The model learns again. The iteration loop is the patient's own biology, not a population study. The generalizable knowledge emerges from many individual loops, with aggregate patterns becoming visible across the population of patients and models over time.
The resistance to this is not technical. It is institutional. Healthcare is the most change-averse sector of the economy because the cost of a mistake is measured in human life. But the cost of not iterating is also measured in human life. There are people who will die because the system could not adjust their treatment faster.
Agency over routine
Most knowledge work routine is not the kind that builds skill. It is the overhead of coordination, formatting, searching, updating, and verifying things that should not need verification. AI agents are getting good at this routine because the pattern is predictable and the cost of running it is near zero.
The useful response is not to resist. It is to ask what the freed attention should be spent on. The judgment call with no precedent. The conversation that needs a human relationship. The design decision where taste outweighs optimization. This is agency over routine. You still own the work. You just stop being the one who does the parts a competent system can do.
Creativity, taste, and many small teams
If a model can generate a thousand variations of a song or a story, what is left for the human artist? Taste, surprise, and the choice of what to make. Models are good at generating variations within a known distribution. They are bad at knowing which variation is worth keeping. They are bad at knowing when to break the distribution entirely.
The picture that emerges is not a world with fewer people working. It is many small teams building highly specific factories for highly specific problems. Each team has a human core supplying direction, judgment, verification, taste, and real-world contact. Each team has an AI layer supplying iteration speed and production capacity. The teams that win will not have the biggest models. They will have the clearest sense of what they are building and the best loop between human judgment and machine iteration.
What this means for you
If this analysis is roughly right, there are a few conclusions worth testing.
First, invest in your ability to specify what you want. The people who can articulate a clear direction and recognize the right output when they see it will have more leverage than the people who can only execute.
Second, build your own iteration loops. Every domain has opportunities to lower the cost of trying. Find the bottlenecks where a single additional iteration would surface a better decision and make that iteration cheaper.
Third, find your small team. The future favors groups that combine complementary judgment with shared iteration loops. A team of three to five people with aligned taste and complementary skills, each running their own factory, can compete with organizations a hundred times their size.
The machines handle the repetition. The judgment, taste, verification, and the decision about what to build next stays with the people who build the factory.