Random Thoughts on Leadership & Technology

The AI Software Factory is Coming

ai-factory

The AI Factory - the end of the road of software commoditisation

Why the end-state of AI-driven development is a self-service platform that turns specifications into live products - with almost no humans in the loop.

The Pattern We Keep Ignoring

Every foundational technology follows the same arc - invention, craft, industrialisation, commodity. We have watched it happen with textiles, steel, electricity, automobiles, and semiconductors. Each time, incumbents insist their domain is different - too complex, too creative, too nuanced to be reduced to a factory line. Each time, they are wrong.

Software is now headed down that road. That is not the end of software, just as there are still textile, semiconductor and steel industries and they are thriving. The logical terminus for software is not another framework, another low-code tool, or another copilot. It is something that can be called the AI Factory - a fully autonomous platform where a customer uploads a specification, answers clarifying questions, approves a quote, and receives a live, deployed product on the public cloud. No project managers. No sprint ceremonies. No deployment engineers. Minimal or zero sustained human intervention across the entire software development lifecycle.

This is not a prediction about some distant future. It is the inevitable destination of a trajectory that began decades ago, and it is arriving faster than most of the industry is prepared to admit.

A Short History of Making Things Cheaper

Textiles - The Original Template

Before 1764, cloth was produced by skilled artisans working in cottages. The spinning jenny, the water frame, and the power loom didn't just speed up production - they restructured the entire economic model. By 1830, a single factory worker operating a power loom could outproduce forty hand-weavers. The craft didn't disappear entirely - bespoke tailoring still exists. But the vast majority of the world's fabric is now produced by machines that require minimal human skill to operate.

The parallel to software is striking. Most software - CRUD applications, dashboards, e-commerce stores, internal tools, data pipelines - is the digital equivalent of cotton cloth. Functional, repetitive, and structurally identical from one instance to the next.

Steel and the Bessemer Convergence

In the 1850s, producing steel was an art. Experienced puddlers judged the carbon content of molten iron by the colour of the flame and the behaviour of the sparks. Henry Bessemer's converter didn't just automate the process - it made the judgement irrelevant. Temperature, timing, and airflow could be controlled mechanically. Production costs dropped by over 80% within two decades.

Andrew Carnegie understood the implications better than anyone. His insight was not about steel itself but about the system - vertical integration from raw ore to finished rail. The factory was not a building - it was an end-to-end process that converted inputs to outputs with ruthless efficiency. The AI Factory follows this same logic - the input is a specification, the output is a deployed product, and everything in between is orchestrated by machines.

Electricity - From Bespoke to Utility

In the 1880s, every factory that wanted electric power had to build and maintain its own generator (pretty much like AI data centers today 😆). J.P. Morgan's mansion had its own power plant. The idea that electricity would become an invisible utility - something you simply plugged into - was considered naive by the engineers who built those early systems.

Samuel Insull changed that. His central power stations, standardised voltages, and metered billing transformed electricity from an engineering project into a commodity. Nicholas Carr drew the explicit parallel in The Big Switch (2008), arguing that computing was following the same path from private infrastructure to shared utility. Cloud computing proved him right. The AI Factory is the next step - not just infrastructure as a utility, but development itself as a utility.

Automobiles - The Assembly Line Lesson

Henry Ford did not invent the car. What he invented (or rather one of his engineers, a reverse of the disassemby line in butchery at that time) was the process of making cars at scale. The Model T was deliberately simple - "any colour so long as it is black" - because simplicity - it was the fastest drying paint - enabled the moving assembly line. By breaking production into 84 discrete steps, Ford reduced the time to build a chassis from twelve hours to ninety-three minutes.

The lesson for software - constraint enables automation. The AI Factory does not need to build every conceivable application. It needs to build the 80% of applications that follow well-understood patterns - the "Model Ts" of the software world - and build them with extraordinary speed and consistency.

Semiconductors - The Foundry Model

Perhaps the most directly relevant precedent is the semiconductor industry's evolution. In the 1970s and 1980s, chip companies were vertically integrated - they designed and manufactured their own chips. Then Morris Chang founded TSMC in 1987 on a radical premise - a "pure-play foundry" that would manufacture chips designed by others. The customer provided the specification (the chip design) - the foundry handled everything else.

This is almost exactly the model the AI Factory follows. The customer provides the specification - the factory handles architecture, implementation, testing, deployment, and infrastructure. The foundry model didn't eliminate chip designers - it liberated them from the need to own fabrication plants. Similarly, the AI Factory doesn't eliminate the need for people who understand what software should do. It eliminates the need for them to also understand how software is built.

The Commoditisation of Code Is Already Underway

The history above is interesting, but the more important point is that software commoditisation is not hypothetical. It has been unfolding for three decades, in clear and accelerating stages.

Stage 1 - The Open-Source Foundation (1990s–2000s)

Linux, Apache, MySQL, and PHP — the LAMP stack - demonstrated that the fundamental building blocks of software could be free. The value shifted from writing infrastructure code to assembling infrastructure code. By 2010, the raw materials of most web applications were open-source.

Stage 2 - Cloud as the Great Equaliser (2006–2015)

Amazon Web Services launched in 2006, and within a decade, it had made the sentence "we need to buy servers" sound as quaint as "we need to build a generator". The operational complexity of running software - provisioning, scaling, monitoring, failover - was progressively absorbed by the cloud provider. Heroku's famous "git push heroku main" compressed deployment from a multi-day operations exercise to a single command.

Stage 3 - The Low-Code / No-Code Wave (2015–2022)

Platforms like Shopify, Webflow, Airtable, and Bubble demonstrated that large categories of software could be created by people with no programming ability at all. These platforms commoditised development for a constrained set of use cases. The limitation was always the constraint itself - the moment you needed something the platform didn't anticipate, you hit a wall.

Stage 4 - AI-Assisted Development (2022–2025)

GitHub Copilot, Cursor, Claude, and their successors broke through the low-code ceiling by generating arbitrary code from natural language. A developer could describe what they wanted and receive working implementations. Productivity gains of 30–60% were widely reported. But the human remained in the loop - reviewing, editing, debugging, deploying. The developer's role shifted from writing code to supervising AI-written code.

Stage 5 - The AI Factory (2026–?)

This is the stage now emerging. The question is straightforward - if AI can write the code, and AI can write the tests, and AI can configure the infrastructure, and AI can deploy to the cloud, and AI can monitor the result - then what, exactly, is the human doing in the middle of that process?

The honest answer, for a large class of applications, is - not much that couldn't also be automated.

Anatomy of the AI Factory

The AI Factory is not a single AI model. It is an orchestrated system - a pipeline of specialised agents, deterministic processes, and human touchpoints reduced to the bare minimum. Here is what the workflow looks like:

1. Specification Upload

The customer uploads a requirements document, a set of user stories, wireframes, an existing product to replicate, or even a natural-language description of what they need. The system ingests this in whatever format it arrives.

2. Clarification Dialogue

An AI agent analyses the specification for ambiguities, contradictions, missing requirements, and implicit assumptions. It generates targeted questions and presents them to the customer through the web platform. This is the AI equivalent of a discovery workshop - but it happens asynchronously, at the customer's pace, and it is thorough in a way that human workshops rarely are, because the AI systematically cross-references every requirement against every other requirement.

3. Architecture & Estimation

Based on the clarified specification, the system generates an architecture tradeoffs and a proposal, a technology stack recommendation, and a cost estimate. The estimate is derived not from expert guesswork but from a model trained on thousands of previous projects - their scope, their actual cost, their actual delivery time and their real cost to operate - litteraly the total cost of ownership. The customer receives a quote.

4. Budget Approval

The customer reviews the quote and approves, rejects, or negotiates. This is one of the irreducible human touchpoints - someone must authorise spending. The platform handles this as a simple approval workflow with notifications.

5. Autonomous Development

This is the core of the factory. A coordinated system of AI agents executes the full SDLC:

6. In-Process Notifications

During development, the system may encounter decisions that require customer input - scope ambiguities that weren't caught earlier, trade-off decisions that affect cost or timeline, or design choices that depend on business context. These are surfaced as notifications in the web platform, with clear options and recommendations. The customer responds at their convenience.

7. Deployment & Handover

The finished product is deployed to the customer's chosen public cloud provider. The system configures DNS, SSL certificates, monitoring, alerting, and backup. The customer receives credentials, documentation, and a live URL.

8. Ongoing Maintenance (Optional)

The factory can continue to operate post-deployment - monitoring for errors, applying security patches, scaling infrastructure in response to load, and accepting change requests through the same specification-and-approval workflow.

Why "Common Repeatable Solutions" Is a Bigger Category Than You Think

The immediate objection is always - "This might work for simple apps, but real software is complex and unique."

This objection overestimates the uniqueness of most software. Consider the following categories:

These categories cover the vast majority of custom software projects commissioned every year. They are structurally repetitive. The business logic varies - a dental clinic's booking system is different from a yoga studio's - but the architectural patterns are nearly identical. This is precisely the kind of variance that AI handles well - the pattern is fixed, the parameters change.

The long tail of genuinely novel, architecturally unprecedented software - operating systems, database engines, real-time trading platforms, aerospace control systems - will continue to require deep human expertise. But that long tail is perhaps 5-10% of the software the world needs built. The AI Factory is aimed at the other 90%.

The Economics Are Inescapable

The current model of custom software development is, by any industrial standard, astonishingly inefficient:

The AI Factory attacks every one of these inefficiencies. Communication overhead drops to near zero when the "communication" is a structured dialogue between a customer and an AI agent in a survey type of structured questioning. Misunderstood requirements are caught by systematic cross-referencing, not by a developer realising the problem three sprints in. Delivery timelines compress from months to days or hours, because the factory operates 24 hours a day and does not context-switch, take holidays, or lose motivation.

When the cost of building a standard web application drops from $200,000 and four months to $20,000 (let's be honest - venture capital will not pay the AI bill in the long run and $5,000 in tokens will not do the trick) and forty-eight hours, the market for custom software doesn't shrink. It explodes. Thousands of businesses that currently can't afford custom software suddenly can. The AI Factory doesn't destroy demand - it creates it, just as Ford's assembly line didn't reduce the demand for transportation.

The Objections, Taken Seriously

"Software development is creative work. AI can't replace creativity"

This conflates two different activities. Deciding what to build is creative. Building it is increasingly mechanical. The AI Factory doesn't replace the person who identifies a market opportunity, imagines a product, and defines what it should do. It replaces the execution layer. This is exactly what happened in every previous commoditisation cycle - the creative act of designing a garment survived the industrialisation of producing it.

"AI-generated code is unreliable."

Today, yes - sometimes. But "AI-generated code in 2026 is unreliable" is a statement about the current state of the technology, not about its ceiling. AI code generation is improving at a rate that makes linear extrapolation from today's limitations misleading. More importantly, the AI Factory doesn't rely on a single model producing perfect code in one pass. It uses layers of validation - automated testing, AI-driven code review, formal verification for critical paths, and human escalation for genuinely novel problems.

"Customers can't write good specifications"

This is true - and it is precisely why the clarification dialogue exists. The AI Factory does not assume the customer arrives with a perfect spec. It assumes the customer arrives with a rough idea, and it systematically refines that idea through targeted questioning. This is arguably better than the traditional process, where a business analyst spends two weeks writing a specification document that is outdated by the time development begins.

"What about security? Compliance? Edge cases?"

These are engineering problems, not philosophical ones. Security scanning, compliance checking, and edge-case testing are all highly automatable - in many cases, more reliably automatable than their human-executed equivalents, because the AI doesn't forget to run the OWASP Top 10 check or skip the accessibility audit because the deadline is tight.

What Happens to Developers?

This is the question everyone wants to ask but few want to answer honestly.

The historical pattern is clear - commoditisation does not totally eliminate jobs, but it radically reshapes them. The number of people employed in textile production today is a tiny fraction of the pre-industrial figure, yet the textile industry's total economic output is orders of magnitude larger. The jobs shifted - from weavers to machine operators, from machine operators to machine designers, from machine designers to supply-chain optimisers.

For software, the shift will likely follow similar contours:

The transition will be disruptive. It will be painful for some. Pretending it isn't coming helps no one.

The Factory Is Not a Metaphor

I have used the word "factory" deliberately, not as a loose analogy but as a precise description. A factory is a system that converts raw materials into finished goods through a series of automated, repeatable processes, with human involvement limited to oversight, quality control, and handling exceptions.

The AI Factory converts specifications into deployed software through a series of automated, repeatable processes, with human involvement limited to approval decisions, clarification responses, and handling exceptions.

The raw material is the customer's intent. The finished good is a live application. The assembly line is an orchestrated pipeline of AI agents. The quality control is automated testing and AI-driven review. The factory floor is the cloud.

This is not the end of software craftsmanship any more than the power loom was the end of beautiful cloth. It is the beginning of software abundance - a world where the cost and friction of turning an idea into working software falls drastically, and where the limiting factor is no longer "can we build it?" but "should we build it?"

That has always been the more interesting question.

The factory is coming. The only open question is who builds it first.