The Last Artisanal Industry
Almost every important industry has made the journey from craft to industrial production. Textiles moved from handlooms to mechanised mills. Automobiles moved from workshops to assembly lines. Consumer goods moved from local workshops to globally integrated factories. In each case, something that had been made expensively by skilled hands became something made systematically at a fraction of the price — and the world got far more of it.
Software helped make many of those transitions possible. Yet software creation itself remained stubbornly dependent on craft. A serious software product has traditionally required a large and varied team: product managers to define what should be built, designers to shape how it works, engineers to write the code, testers to find defects, security specialists to protect it, infrastructure teams to operate it, consultants to implement it and support staff to help customers use it. Seventy years into the computer era, the production process would still be recognisable to a programmer from 1985.
Four production lines. Three found their factory. The fourth is the opportunity.
It is not that nobody tried. Higher-level languages reduced how much code humans had to write. Reusable libraries stopped every developer rebuilding common functions. Offshoring moved work to lower-cost locations. Low-code platforms let predefined applications be assembled faster. Open source gave builders components created by a worldwide community. All of these mattered. None removed the central constraint. A skilled human still had to understand what was needed, translate it into software, connect the parts, test the result, diagnose its failures and maintain it over time. The craftsman acquired better tools — but the production system still revolved around the craftsman. The bottleneck survived every assault, and so did the prices built on it.
The cloud then created a second, more subtle paradox: it industrialised software’s distribution without industrialising its creation. Before the cloud, software was packaged, installed and upgraded separately for each customer. SaaS replaced that with one centrally operated product delivered over the internet; the marginal cost of another user became almost nothing. By every rule of economics, prices should have collapsed. Instead they went up. Providers learned that software could be priced on customer value rather than production cost. Perpetual licences became subscriptions; subscriptions became per-user plans; plans became bundles, editions, add-ons and usage charges; annual increases became normal. The industry achieved factory-scale distribution of handmade goods — at handmade prices.
The paradox at the heart of the software industry.
Meanwhile the products themselves kept expanding. Every new customer segment brought requests for more controls, more integrations, more reports, more configuration. Features accumulated like geological layers; the product became a suite, and the suite became a platform. This expansion was not entirely wasteful — large, complex customers do need sophisticated capabilities. But a structural imbalance emerged: the product was designed for the totality of customer requirements, while each individual customer used only a fraction of it. A company might rely on a handful of workflows, reports and integrations, yet pay for hundreds of capabilities it never touches. A smaller company might reject the product altogether as too expensive and too complicated. Software achieved abundance in features — but not affordability in outcomes.
AI coding agents are the first technology in the industry’s history that changes the production function itself. Today’s agents can inspect a codebase, write features, generate tests, diagnose bugs, produce documentation and run many tasks in parallel; Anthropic’s own research on how its coding agent is used found that the large majority of interactions were automation rather than assistance — the agent doing the work, not helping a human do it. These remain evolving tools, and complex software still demands human architecture, judgement and governance. But the direction is unmistakable: more and more of the production process can be delegated to machines.
The significance is much larger than programmer productivity. A programmer becoming thirty per cent faster improves the economics of the existing software company. A small team directing a collection of agents to produce, test and operate many applications changes the nature of the company itself. The unit of production shifts from human hours to a system: specifications, agents, reusable components, tests and quality controls. Software begins to move from workshop to foundry.
That distinction is the essential one. A workshop produces one application through concentrated craftsmanship. A foundry creates a repeatable process through which many applications are produced. The foundry does not eliminate human expertise; it elevates it. Humans specify the problem, set the architectural principles, define the quality standards, inspect the exceptions and take responsibility for consequential decisions. AI performs a growing share of the construction, testing, documentation and maintenance.
Markets have already sensed the shift: the great software sell-off of early 2026 — a trillion dollars of SaaS market value repriced in weeks — was the sound of investors realising that per-seat pricing and feature-count value propositions sit on a foundation that is dissolving. But a sell-off is only demolition. The construction is what matters, and it has a precise threshold: The industrial revolution in software will not arrive when AI writes all the code. It will arrive when the tenth reliable application is materially cheaper and faster to produce than the first. That is the line between better tools and a new industry.
