The Factory Returns

How AI Revives the Software-Factory Dream, and Whether Agility Can Survive It

Published by Polity | July 2026
Authors: Alexandre Kotcherguine, Vision Officer & Investor, Polity;
Kevin Riedl, Managing Partner, Wavect GmbH

This article concerns software-development methodology and organisational design. It draws on original research, official records and first-party company reporting reviewed through 2 September 2026. Vendor studies and benchmark results are identified as such. Nothing in it constitutes professional, legal or investment advice.

Executive Summary

In 1968, at the NATO Conference on Software Engineering, Douglas McIlroy called for an industry of mass-produced, catalogue-ordered software components. It was an influential industrial analogy for turning programming into a repeatable supply chain. Literal software-factory programmes followed in the 1970s and 1980s, while the Agile Manifesto of 2001 later framed itself as an alternative to documentation-driven, heavyweight development. This article argues that agentic AI revives McIlroy’s vision in a new form: fitted code generated on demand rather than components ordered from a catalogue. The evidence is mixed. GitClear’s 2026 vendor study reports worsening maintainability signals; METR’s early-2025 randomised trial found experienced developers slower with AI even as they believed it sped them up; and METR’s later experiment could not yield a reliable current estimate because of selection and measurement problems. The engineering discipline the Agile signatories defended therefore does not disappear under AI; it moves up the stack, from the keystroke to the specification and validation system. Stripe’s first-party account provides a production case: more than a thousand entirely Minion-written pull requests are merged each week, but humans review them and the agents run inside extensive tooling and tests. The deciding variable is governance, not the model alone.

The Dream That Failed Twice

The case for industrialising software is as old as the discipline’s name. The organisers titled the 1968 meeting the NATO Software Engineering Conference, and its report recorded both the ambition to establish software engineering and disagreement over what that should mean (1). At that conference, McIlroy proposed families and catalogues of standard components, explicitly comparing them with screws, resistors and industrial subassemblies (2). The analogy resembles Taylor’s decomposition and standardisation of work, although calling McIlroy’s proposal itself “explicitly Taylorist” would go beyond his paper. Software-factory programmes were pursued in earnest: field research by Michael Cusumano documents Hitachi’s Software Works from 1969 and factory efforts at NEC, Toshiba and Fujitsu from the mid-1970s onward (3).

Those programmes did not establish a universal catalogue economy for software. Cusumano’s research instead describes company-specific combinations of tools, reusable assets, standardised methods, training and quality control, with different results across organisations (3). Later, the seventeen signatories of the Agile Manifesto met in 2001 seeking an alternative to documentation-driven, heavyweight development processes (4). The historical record therefore supports a narrower analogy than a simple two-time failure: industrial approaches achieved local process and quality gains, but neither removed the need for context, adaptation and engineering judgement.

Why This Time Is Different

Agentic AI changes the mechanics in a way the software factory never could. McIlroy’s components had to be written, catalogued, generalised and maintained by people before anyone could order them; the overhead of generalisation was what killed reuse. A coding agent collapses that overhead. It does not retrieve a pre-built component from a shelf; it synthesises a fitted one on demand, from a description of intent, against the specific context of the codebase in front of it. The catalogue is no longer finite and human-maintained; it is, in effect, the model’s latent capacity to generate the part you need when you ask for it.

The capability is no longer speculative, but the benchmark history needs care. The original 2023 SWE-bench paper reported a best result of 1.96 per cent on its full test set. SWE-bench Verified was introduced later, so that figure was not a Verified score. Anthropic reported 80.84 per cent on Verified for Claude Opus 4.6 in February 2026, while the official benchmark maintainers have also documented contamination concerns and a compressed leaderboard near its ceiling (5). Anthropic’s Economic Index, based on sampled Claude.ai and first-party API traffic mapped to O*NET tasks, reported in March 2026 that about 49 per cent of jobs had seen Claude used for at least a quarter of their tasks. That is cumulative platform-observed coverage, not the share of all work actually performed by AI (6). These results show that substantial coding work can be delegated, but they do not by themselves establish autonomous end-to-end delivery.

The Old Tension, Now Measurable

If the mechanics are new, the danger is old, and vendor research now quantifies several warning signals. GitClear’s June 2026 study analysed 623 million changes from 2023 through the first half of 2026. Relative to 2023, it reports cross-file function calls down 35 per cent, refactoring line moves down 70 per cent, code-block duplication up 81 per cent, within-commit copy and paste up 41 per cent and two-week churn up 15 per cent (7). The report measures correlations in GitClear’s dataset and should not be read as a controlled causal estimate of AI’s effect. In Ward Cunningham’s original metaphor, shipping faster while deferring consolidation can create technical debt whose interest eventually slows delivery (8).

The productivity picture is equally double-edged. In mid-2025 the non-profit METR ran the field’s first randomised controlled trial of AI coding assistance: sixteen experienced open-source developers, working on mature repositories they knew well, completed 246 real tasks with AI use randomly allowed or disallowed (8). The developers forecast a 24 per cent speed-up; expert economists and machine-learning researchers forecast larger gains still. The measured result was the opposite: tasks took, on average, 19 per cent longer with AI. More striking than the slowdown was the perception gap: even after experiencing it, the developers estimated that AI had sped them up by 20 per cent. This is Goodhart’s shadow in a new setting: every visible metric (commit volume, pull-request count, lines shipped) can climb while the thing that matters, time to a correct and maintainable result, moves the other way. A complementary concern, which practitioners have begun calling comprehension debt, names the deeper risk: when generation outpaces understanding, the only people who can reliably review AI output (the senior engineers) become the bottleneck, and the issues they miss reach production.

A First Objection: The Signals Are Moving

The honest counter-argument is that every figure above is a snapshot of a fast-moving target. METR’s late-2025 experiment produced estimates in the opposite direction: an 18 per cent speed-up for ten returning participants and 4 per cent for newly recruited participants. But both confidence intervals included zero, and METR concluded that participant selection, task selection and unreliable time measurement made the experiment an unreliable signal of the current productivity effect (10). DORA likewise found a changing but still mixed association: its 2024 survey estimated that each 25 per cent increase in AI adoption was associated with 1.5 per cent lower delivery throughput and 7.2 per cent lower delivery stability; its 2025 report associated higher AI adoption with both greater throughput and greater delivery instability (11). These observational results do not prove that AI or any particular governance practice caused the change.

The newer evidence sharpens the practical argument without proving a simple reversal. Models and tools changed, participant behaviour changed, and measurement became harder. Better context, agent harnesses, review workflows and spec-first practices remain plausible and testable ways to manage risk, but METR’s follow-up cannot isolate them as the cause of faster work. Organisations should therefore measure their own end-to-end outcomes, including review time, rework, incidents and maintainability, rather than assuming that either benchmark gains or a general industry trend transfers automatically to their environment.

Where the Craft Goes: Up the Stack

The resolution to the paradox is that AI does not abolish engineering discipline; it relocates it. The practices the Agile signatories defended (test-first development, continuous integration, refactoring, the maintenance of code health) do not become obsolete when a machine writes the lines. They migrate from the keystroke to the specification, from the act of typing code to the act of defining, constraining and verifying it. The clearest expression of this migration is the rapid rise, through 2025-26, of spec-driven development. This is the practice of writing a structured, versioned specification (goals, constraints, acceptance criteria) before invoking a coding agent. The agent then has explicit intent to implement, rather than a vague prompt to interpret.

For the tool-specific decision rather than the historical argument, our GitHub Spec Kit review for production teams covers the current commands, limits, security boundary, cost and pilot design.

Andrej Karpathy coined “vibe coding” in February 2025 for a deliberately loose workflow in which the developer largely stops reading the code and accepts model-generated changes. His original post described it as suitable for throwaway weekend projects, not as a production method (12). Spec-driven development is a contrasting, more structured family of practices. GitHub’s Spec Kit, for example, treats goals, constraints and acceptance criteria as versioned inputs from which plans and implementations are derived (13). That does not make specifications automatically correct or make every coding tool spec-driven. It does move reviewable intent earlier in the workflow, much like test-driven development defines expected behaviour before implementation.

The human role shifts in proportion. The engineer of the agentic factory spends less time writing foundational code and more time on architecture, specification precision, and quality gatekeeping: product ownership in the fullest sense. The metaphor that recurs in the practitioner literature is apt: the AI carries the stones; the architect still designs and inspects the pyramid. This is not a diminishment of engineering judgement but a concentration of it, which is exactly why organisations that strip the judgement out, expecting the model to supply it, find the duplication and churn that GitClear measured. The model supplies code. It does not supply care.

Preserving Agility: The Governance Problem

Here the argument rejoins the older one about enterprise Agile, because the failure modes rhyme. The original software factory removed craft judgement and called the result industrialisation; enterprise Agile removed the technical practices and kept the ceremonies; the careless adoption of AI removes comprehension and keeps the velocity dashboard. In each case the visible, auditable surface is preserved while the load-bearing substance is hollowed out. The agentic factory is therefore not automatically a restoration of agility; it is a fork in the road. Down one path, AI becomes the ultimate de-engineering instrument: a machine for generating unreviewed, duplicative, context-blind code at industrial scale, with every productivity metric glowing green while technical and comprehension debt compound beneath. Down the other, it becomes the first tool that delivers the factory’s throughput and the craft’s adaptability at once.

What separates the paths is governance, and its components are now reasonably well understood. They include specification discipline as an organisational capability rather than an individual habit (living, version-controlled specs that persist beyond any single agent session); automated quality gates between agent output and human acceptance, so that an agent producing a thousand pull requests a week at even a one-per-cent vulnerability rate does not silently ship ten new weaknesses; review workflows retooled for the new failure modes, which are structural and security-shaped rather than typo-shaped; and persistent, governed context (shared memory, conventions and constraints that travel with the codebase so the agent stops re-importing the duplication the model defaults to). For regulated domains (financial services, healthcare, and the on-chain finance infrastructure in which Polity works) this governance layer is not optional polish; it is the precondition under which agentic throughput becomes admissible at all. The control that the original factory imposed from above, and that enterprise Agile imposed as ceremony, is here re-imagined as discipline embedded in the development substrate itself, close to the engineer, expressed as executable specification and automated verification rather than as a foreman’s ledger.

For some regulated uses this is also a legal design issue. Under the consolidated EU Artificial Intelligence Act, Chapter III Sections 1 to 3 apply from 2 December 2027 to Annex III high-risk systems and from 2 August 2028 to product-based high-risk systems under Annex I. Articles 11, 12 and 14 require technical documentation, automatic event-recording capabilities and effective human oversight for systems that actually fall within the Act’s high-risk categories (14). A versioned specification, pipeline audit trail and human approval gate can support those controls, but none is automatically equivalent to legal compliance. Classification, risk management, data governance, accuracy, robustness, cybersecurity, post-market monitoring and the provider-deployer allocation of duties still require a system-specific assessment.

The Factory Made Real: A Case in Point

This is no longer only a thought experiment. In February 2026 Stripe described Minions, its unattended, one-shot coding agents. Stripe says more than a thousand entirely Minion-written pull requests are merged each week, after human review. Its 2026 developer keynote separately said Minions ship more than a thousand pull requests to production weekly and that humans review and approve them. Stripe’s 2025 annual letter reported $1.9 trillion in total volume, which explains the operational stakes without implying that every Minion touches payment-critical code (15).

Stripe’s account attributes the result to much more than a model: isolated development environments, repository context, location-specific rules, linting, selective tests drawn from a suite of more than three million tests, and human review. Minions are built on a fork of Block’s open-source Goose agent, but Stripe’s surrounding platform and internal tools are company-specific. The published account supports the narrower conclusion that high agent throughput can coexist with deterministic checks and human approval. It does not publish a controlled comparison, a defect rate, cost per pull request or enough evidence to generalise Stripe’s result to other organisations (15).

Conclusion: The Factory With a Conscience

McIlroy’s 1968 proposal was right about the destination and wrong about the route. He believed industrialisation required standardised, human-catalogued parts and the Taylorist apparatus to manage them; that route killed the agility software needs and the judgement engineers supply. Agentic AI reaches the destination by a different road (generating fitted components on demand rather than ordering generic ones) and in doing so removes the specific obstacle that defeated the factory for half a century. But it inherits the original sin in a new form. The temptation to treat the model as a replacement for engineering culture, rather than as an instrument wielded by it, is the same temptation that hollowed out the literal factory and then enterprise Agile, now available at far greater speed and scale.

It is only fair to record the strongest objection: if agents can eventually specify, write, test and review, “keeping the craft” may describe a transitional phase rather than a permanent allocation of work. Stripe already shows that humans need not type the code in every merged change. Yet its published system still relies on human review, deterministic checks and infrastructure designed by engineers. The durable point is therefore not that every pull request must always receive the same kind of manual review. It is that an accountable organisation must still define what is worth building, what evidence counts as correct, which failures are tolerable and when automation may approve a change. As evidence improves, those decisions may move into policies and gates, but they do not disappear.

The lesson the Agile signatories spent two decades trying to deliver applies, unchanged, to the agentic era: lightness of process must be earned by strength of engineering beneath it. AI makes the lightness almost free and the strength almost optional, which is precisely why the strength must now be a deliberate choice, encoded in specifications, enforced by quality gates, and owned by humans whose role has risen from writing code to governing its creation. The factory has returned. Whether it industrialises software or de-engineers it (whether it preserves agility or merely automates its destruction) will not be decided by the model. It will be decided, as it always has been, by whether the organisation chooses to keep the craft.

The history of enterprise Agile taught that a method becomes dangerous not when it is wrong, but when its ceremonies outlive the craft that gave them meaning. The agentic factory poses the same test at a higher velocity: it will reward the organisations that move their engineering discipline up the stack, and punish, faster than ever before, those that mistake the disappearance of typing for the disappearance of the need to engineer.

About Polity

This article is part of an ongoing programme of governance and thought-leadership publications developed within the Polity governance model. Polity’s central thesis is that durable outcomes are shaped by governance architecture: the rules, incentives and institutions through which work, value and obligation are formed. The agentic software factory is a governance problem in exactly this sense: the same code-generating capability industrialises or de-engineers depending on the discipline wrapped around it. Polity builds infrastructure for regulated digital finance, with governance frameworks designed to bridge decentralised systems and institutional-grade compliance requirements; the question of how to admit autonomous, high-throughput software production into a regulated environment without sacrificing assurance is one it engages directly.

About Wavect

Wavect GmbH is an Austrian software engineering agency that builds product-led software for startups, scale-ups and enterprises, spanning full-stack development, fractional engineering and product leadership, software quality assurance, and applied work in artificial intelligence, blockchain and zero-knowledge systems. Wavect has provided software development and quality-assurance services to the Polity programme, and co-author Kevin Riedl is a Managing Partner of the firm. More information is available at https://wavect.io.

Disclaimer: This article is published for informational and educational purposes only. It does not constitute professional, legal, financial or engineering-management advice, nor an endorsement of any methodology, product, service or organisation. References to named researchers, studies, tools, frameworks and companies are made solely for analysis and commentary. Research figures were checked against the cited sources through 2 September 2026; several are controlled studies with limited samples or vendor-reported observational data and are characterised as such. All third-party sources are cited for reference; their inclusion does not imply endorsement by, or affiliation with, Polity. Co-author Kevin Riedl is a Managing Partner of Wavect GmbH, which provides software development and quality-assurance services to the Polity programme (see “About Wavect” above); this commercial relationship is disclosed in the interest of transparency and does not affect the independence of the analysis. Views expressed are the authors’ own.

References and Primary Sources

1. Naur, P. and Randell, B. (eds.) (1969). Software Engineering: Report on a Conference Sponsored by the NATO Science Committee. Original 1968 conference report. NATO report (reviewed 2 September 2026).
2. McIlroy, M.D. (1968). “Mass Produced Software Components”. Author-hosted text (reviewed 2 September 2026).
3. Cusumano, M.A. (1989). The Software Factory: A Historical Interpretation. Field research based on company data, site visits and manager interviews. Computer History Museum archive (reviewed 2 September 2026).
4. Agile Manifesto authors (2001). Official history; official manifesto (reviewed 2 September 2026).
5. Jimenez, C.E. et al. (2023). SWE-bench; Anthropic (2026), Claude Opus 4.6 System Card; SWE-bench public experiments. Original paper; system card; experiment records (reviewed 2 September 2026).
6. Anthropic (2026). “Anthropic Economic Index report: Learning curves”. Economic Index (reviewed 2 September 2026).
7. GitClear (2026). The Maintainability Gap: AI Code Quality in 2026. Vendor observational research covering 623 million changes. GitClear report (reviewed 2 September 2026).
8. Cunningham, W. (1992). “The WyCash Portfolio Management System”; Becker, J. et al. (2025). Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. Cunningham report; METR study (reviewed 2 September 2026).
9. Becker, J. et al. (2025). Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. METR study; paper (reviewed 2 September 2026).
10. METR (2026). “We Are Changing Our Developer Productivity Experiment Design”. METR follow-up (reviewed 2 September 2026).
11. DORA (2024; 2025). Official software-delivery research. 2024 report; 2025 report; 2025 errata (reviewed 2 September 2026).
12. Karpathy, A. (2025). Original “vibe coding” post (reviewed 2 September 2026).
13. GitHub (2026). “What is Spec-Driven Development?” Spec Kit documentation (reviewed 2 September 2026).
14. European Union (2024, consolidated 27 July 2026). Regulation (EU) 2024/1689, Articles 11, 12, 14 and 113, as amended by Regulation (EU) 2026/1744. Consolidated AI Act; amending regulation (reviewed 2 September 2026).
15. Stripe (2026). Minions engineering posts, developer keynote and 2025 annual letter. Part 1; Part 2; keynote; annual letter (reviewed 2 September 2026).