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 the public record, including peer-reviewed and pre-print research, controlled studies, and industry reporting current to mid-2026. Figures from a fast-moving field are snapshots and may be restated. 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 the software industry’s first articulation of a Taylorist ambition: to convert programming from a craft into a repeatable, scientifically managed supply chain. The dream failed twice, once in the literal “software factories” of the 1970s and 1980s, and again in the heavyweight, control-oriented processes against which the Agile movement revolted in 2001, for the same reason each time: you cannot industrialise a craft by removing the judgement that makes it work. This article argues that agentic AI now revives the factory dream in a form that finally delivers McIlroy’s components (generated on demand rather than ordered from a catalogue) but reproduces, in measurable form, the very tension that defeated its predecessors. The evidence cuts both ways and is presented in full: large-scale code-quality data showing AI amplifying technical debt; a randomised controlled trial showing AI slowing expert developers even as they believed it sped them up; and the rapid bending of those signals as tooling and practice matured through 2025-26. The resolution is that the engineering discipline the Agile signatories defended does not disappear under AI; it moves up the stack, from the keystroke to the specification. The factory can, for the first time, deliver industrial throughput and craft agility at once, but only for organisations that relocate engineering culture rather than, as the era of enterprise Agile so often did, quietly remove it. The most advanced agentic factory yet documented (Stripe’s, merging over a thousand machine-written pull requests a week) works precisely because it is wrapped in deterministic gates, sandboxing and mandatory human review; it is the thesis observed in production. The deciding variable is governance, not the model.

The Dream That Failed Twice

The case for industrialising software is as old as the discipline’s name. The phrase “software engineering” was itself a deliberate provocation, coined for the 1968 NATO conference to signal that programming should be dragged from what the historian Nathan Ensmenger calls its “black art” phase into something rationalised and managed (1). At that same conference, McIlroy delivered the dream’s sharpest expression: a market in standard, off-the-shelf source components from which complex systems could be assembled like circuit boards (2). The vision was explicitly Taylorist (decompose the work, standardise the parts, separate the planning from the doing) and it was pursued in earnest (3). “Software factory” was registered as a trademark in 1974; through the 1980s, Hitachi, Toshiba, NEC and Fujitsu built industrial software factories that imposed standardised processes, reuse libraries and quality controls at scale.

They did not deliver the revolution promised. Reuse proved far harder than catalogue-ordering implied: components carried hidden assumptions, the cost of making code genuinely reusable exceeded the cost of rewriting it, and the factory’s rigidity sat poorly with the constant change that software demands. The Taylorist inheritance migrated instead into heavyweight, phase-gated methodologies (the waterfall stacks, the comprehensive up-front specifications, the change-control boards) and it was against precisely these that seventeen engineers wrote the Agile Manifesto in 2001. The factory had failed as a literal institution and was failing again as a process doctrine. In both cases the diagnosis was the same: the apparatus of industrial control, applied to a creative and experimental activity, suppressed the very thing it was meant to optimise.

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. On the SWE-bench Verified benchmark (a standardised set of real-world software issues) frontier models rose from solving under two per cent of tasks in late 2023 to roughly seventy-eight per cent by early 2025, and past ninety per cent by mid-2026 (with the usual caveats about benchmark saturation and contamination at the frontier). The unit of work has shifted accordingly: practitioners and researchers now describe an agentic software-development lifecycle in which an orchestrator coordinates specialised sub-agents (planning, implementing, testing, reviewing) while the human supervises at the level of intent and review rather than authorship (4). Anthropic’s Economic Index, which measures real Claude usage against the US Department of Labor’s O*NET task taxonomy, found in its early-2026 reporting that roughly 49 per cent of occupations had seen at least a quarter of their constituent tasks performed with the model (5). The factory has, in this narrow mechanical sense, arrived: the production of code can now be delegated, parallelised and run continuously in a way McIlroy would recognise as the fulfilment of his proposal.

The Old Tension, Now Measurable

If the mechanics are new, the danger is old, and for the first time it is quantified rather than merely feared. The most rigorous warning comes from GitClear, whose longitudinal study of 211 million changed lines of code (2020-2024, across repositories owned by Google, Microsoft, Meta and others) found that the composition of code, not merely its volume, shifted as AI assistance spread (6). The frequency of duplicated code blocks rose roughly eightfold; refactoring (the deliberate consolidation that keeps a codebase coherent) fell from around a quarter of changes in the early data to under a tenth; and churn, the share of lines revised or reverted within two weeks of being written, climbed markedly. For the first time in the dataset’s history, copy-and-pasted lines exceeded moved (refactored) ones. In Ward Cunningham’s original metaphor, this is technical debt accruing faster than it is repaid, the precise mechanism by which, he warned in 1992, an organisation can be brought to a standstill (7).

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 Already Reversing

The honest counter-argument is that every figure above is a snapshot of a fast-moving target, and that the trend lines have already begun to bend the other way. It deserves to be stated at full strength, because it is largely correct. METR itself, revisiting the question with late-2025 agentic tools, found the slowdown reversing: for the subset of its original developers who continued, the estimate moved from a 19 per cent slowdown toward an 18 per cent speed-up, though with wide confidence intervals and the candid caveat that self-reported gains are unreliable (9). Google’s DORA programme, which in its 2024 data linked AI adoption to a 7.2 per cent decrease in delivery stability, reported in 2025 that AI adoption had become associated with higher throughput, a partial reversal, even as stability questions persisted (10). The capability curve is steep, and a critique anchored to early-2025 tooling risks describing a world that no longer exists by the time it is read.

The objection is correct on its facts, and it sharpens the argument rather than dissolving it. The reversal did not happen because the models stopped producing duplication-prone, context-blind code when used carelessly; it happened because the surrounding discipline matured: better context engineering, agent harnesses, review workflows, and the spec-first practices examined below. The METR follow-up is, read closely, a finding about governance: the same developers got faster as their methods improved, not merely as their models did. The data therefore does not say “the problem solved itself”; it says “the problem is solved by the discipline, and the discipline can be learned.” That is the whole of this article’s thesis, confirmed from the optimistic side of the ledger. The factory’s output improves exactly to the degree that engineering culture is wrapped around it.

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.

This emerged as a direct, named response to the failure mode of “vibe coding”, Andrej Karpathy’s term, from early 2025, for prompting an agent in natural language and accepting what comes back (11). Teams that shipped vibe-coded software to production met the predictable wall: plausible code that drifted from intent, hallucinated interfaces, and decayed as projects scaled. By 2026, every major coding tool had shipped a flavour of spec-driven discipline, and Karpathy himself had declared the vibe-coding era closing in favour of agentic engineering: orchestrating agents against detailed specifications under human oversight. The spec is now the primary artefact; tests, code and documentation are generated from it. Note what this is: it is test-driven development’s core insight (specify the desired behaviour before you build, then verify against it) raised one level of abstraction. The discipline did not die. It was promoted.

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 such domains this is no longer only a matter of prudence; it is becoming a matter of law. The EU Artificial Intelligence Act, whose main obligations were originally applicable from 2 August 2026 (a date now subject to proposed deferral), requires of high-risk systems precisely the disciplines the agentic factory needs in any case: technical documentation that exists before a system reaches the market (Article 11), automatic event logging built into the core design rather than bolted on afterward (Article 12), and human oversight engineered so that a competent person can interpret, override and halt the system (12) (Article 14). The mapping to the practices described above is close to exact: a living, versioned specification is one of the most direct ways to satisfy the documentation requirement; the deterministic gates and audit trails of a disciplined agent pipeline are the logging requirement; and submission-not-merge review is the oversight requirement. The regulatory point and the engineering point converge. The same governance that keeps technical debt down is the governance that keeps a regulated deployer lawful, which means, for institutions of the kind Polity serves, the choice to embed the craft is not a cultural preference but an admissibility condition, enforced on a statutory clock.

The Factory Made Real: A Case in Point

This is no longer a thought experiment. In early 2026, Stripe disclosed the most detailed public account yet of an agentic factory running in production: an internal fleet of unattended coding agents, named “Minions,” merging over a thousand pull requests a week (rising to roughly 1,300 within a fortnight) that contain no human-written code, in a codebase of hundreds of millions of lines supporting more than a trillion dollars of annual payment volume. An engineer tags the bot in a chat message and walks away; agents spin up isolated machines, gather context, write the change, run the tests, and return a finished pull request for review. It is, in the words of one analysis, the treatment of “AI not as a magic black box but as a component within a rigid industrial pipeline”, which is to say, McIlroy’s factory, finally built.

What makes the case decisive for the argument here is Stripe’s own account of why it works. By the engineers’ own telling, the model is almost a commodity (the agent is a fork of an open-source tool) and the leverage lies entirely in the governance wrapped around it. The architecture interleaves creative agentic steps with hardcoded deterministic gates the agent cannot skip: a linter runs, a test suite runs, a commit follows, each as a fixed checkpoint rather than something the model might remember to do. Rules are applied conditionally by location in the codebase, so the agent working in the payments directory inherits payments constraints. Context is curated down from some five hundred internal tools to a surgical handful per task, to prevent the model drowning in its own options. Every run is sandboxed in a disposable environment with no production access; the system holds submission authority, never merge authority, so a human reviews every change before it ships. Tellingly, Stripe credits the developer-experience investments it made for human engineers years before the agents existed (the disposable dev-boxes, the CI infrastructure, the linting daemons) as the foundation that made the factory possible. The agentic factory did not replace engineering discipline; it ran on a substrate of it. This is the resolution of this article, observed in production: throughput at genuinely industrial scale, achieved precisely by embedding the craft in the pipeline rather than dispensing with it.

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 to all of this, because serious people hold it, and it cuts deeper than the question of whether early tooling slowed anyone down. On this view, the appeal to “craft” is nostalgia in a lab coat: a defence of the human role that the technology is about to render quaint. The evidence is not trivial: by 2025 the chief executives of Microsoft and Google were stating that roughly a quarter to a third of their code was already machine-written, with Meta’s projecting that half its development would be done by AI within a year; at least one firm has reportedly eliminated human code review altogether; and credible practitioners now forecast that human review will become optional wherever validation infrastructure is mature enough. If the machine can specify, write, test and review, the argument runs, then “keeping the craft” describes a transitional phase, not a permanent truth. The objection deserves to be taken seriously, and part of it will prove right: much of what is called craft today is mechanical, and will be automated without loss. But it mistakes the location of the judgement for the judgement itself. Even in the most autonomous case on record, Stripe’s, the agents hold submission authority and humans hold the merge; the deterministic gates that make the system safe were designed by engineers exercising exactly the judgement the maximalist claims is obsolete; and someone must still decide what is worth building, what “correct” means, and which failures are tolerable. The craft does not vanish as the typing does. It migrates into the specification, the gate, the threat model and the review; and the firms that have automated furthest are precisely the ones that invested most heavily in that residual human discipline.

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 are drawn from the cited sources and reflect the state of a rapidly evolving field as of mid-2026; several are pre-prints, controlled studies of limited sample, or vendor-reported, and are characterised as such in the text. 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

1. Ensmenger, N. (2010) The Computer Boys Take Over: Computers, Programmers, and the Politics of Technical Expertise. Cambridge, MA: MIT Press. Available at: https://doi.org/10.7551/mitpress/9780262050937.001.0001 (Accessed: 23 June 2026).
2. McIlroy, M.D. (1968) ‘Mass-produced software components’, in Naur, P. and Randell, B. (eds.) Software Engineering: Report on a Conference Sponsored by the NATO Science Committee. Brussels: NATO Scientific Affairs Division, pp. 138-155. Available at: https://www.cs.dartmouth.edu/~doug/components.txt (Accessed: 23 June 2026).
3. Taylor, F.W. (1911) The Principles of Scientific Management. New York: Harper & Brothers. Available at: https://www.gutenberg.org/ebooks/6435 (Accessed: 23 June 2026).
4. Synthesis of agentic SDLC research (2026) ‘Agentic AI in the Software Development Lifecycle’, arXiv pre-print (SWE-bench progression; productivity ranges; open problems including technical debt). Available at: https://arxiv.org/abs/2604.26275 (Accessed: 23 June 2026).
5. Anthropic (2026) The Anthropic Economic Index (reports of January and March 2026). (‘~49% of occupations have seen at least a quarter of their tasks performed using Claude’; SWE-bench and autonomy trends.) Available at: https://www.anthropic.com/research/economic-index-march-2026-report (Accessed: 23 June 2026).
6. GitClear (2025) AI Copilot Code Quality 2025: 211 Million Changed Lines of Code Analysed. Available at: https://www.gitclear.com/ai_assistant_code_quality_2025_research (Accessed: 23 June 2026).
7. Cunningham, W. (1992) ‘The WyCash portfolio management system’, OOPSLA ’92 Experience Report. (Origin of the ‘technical debt’ metaphor.) Available at: https://c2.com/doc/oopsla92.html (Accessed: 23 June 2026).
8. Becker, J., Rush, N., Barnes, E. and Rein, D. (2025) Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. METR. arXiv:2507.09089. Available at: https://arxiv.org/abs/2507.09089 (Accessed: 23 June 2026).
9. METR (2026) We Are Changing Our Developer Productivity Experiment Design. (Update on late-2025 AI uplift.) Available at: https://metr.org/blog/2026-02-24-uplift-update/ (Accessed: 23 June 2026).
10. DevOps Research and Assessment (DORA) (2024; 2025) Accelerate State of DevOps Reports. Google Cloud. Available at: https://dora.dev/research/ (Accessed: 23 June 2026).
11. Karpathy, A. (2025) Remarks on ‘vibe coding’ (February 2025) and subsequent discussion of agentic engineering. Summarised in Towards Data Science, ‘From vibe coding to spec-driven development’ (2026). Available at: https://towardsdatascience.com/from-vibe-coding-to-spec-driven-development/ (Accessed: 23 June 2026).
12. European Union (2024) Regulation (EU) 2024/1689 (Artificial Intelligence Act). Articles 11 (technical documentation), 12 (logging) and 14 (human oversight); main high-risk obligations originally applicable from 2 August 2026, subject to proposed deferral. Official text and summary at: https://artificialintelligenceact.eu/high-level-summary/ (Accessed: 23 June 2026).

Press and Web Sources (numbered for fact-verification)

Where the body attributes a specific finding to a named study, the primary source is listed under References above. The items below document the secondary reporting and the specific points each supports.

• CIO (2026). ‘How agentic AI will reshape engineering workflows in 2026.’ Agent orchestration; engineer as orchestrator of agents and components; first-pass execution across the SDLC. cio.com
• Anthropic (2026). 2026 Agentic Coding Trends Report. Convergence of agent architectures; surge staffing; security-at-scale considerations. anthropic.com
• LeadDev (2025). ‘How AI-generated code compounds technical debt.’ GitClear figures; decline of the DRY principle; practitioner testimony on debt creation. leaddev.com
• Advisable (2026). ‘The hidden cost of moving fast: technical debt in AI-assisted development.’ Churn 3.1%→5.7%; DORA 7.2% stability decrease; METR 19% slowdown drawn together. advisable.com
• StepTo (2026). ‘Comprehension debt: the AI code crisis your metrics are missing.’ Senior engineers as review bottleneck; security-finding spike at a Fortune 50 firm. stepto.net
• METR (2025). ‘Measuring the impact of early-2025 AI on experienced open-source developer productivity.’ RCT design; 16 developers, 246 tasks; 19% slowdown vs 24% forecast / 20% perceived. metr.org
• CGI (2026). ‘Spec-driven development: from vibe coding to intent engineering.’ GitHub Spec Kit, AWS Kiro, planning modes; QA built into the SDD process; relevance to regulated industries. cgi.com
• BCMS (2026). ‘Spec-driven development: the definitive 2026 guide.’ SDD as response to vibe-coding failure; spec as primary artefact; relation to TDD. thebcms.com
• Towards Data Science (2026). ‘From vibe coding to spec-driven development.’ Karpathy on the close of the vibe-coding era and the move to agentic engineering under specification and oversight. towardsdatascience.com
• DEV Community (2025). ‘The AI productivity paradox.’ METR perception gap; DORA 2024→2025 reversal (stability down, then throughput up); junior-vs-senior adoption differences. dev.to
• InfoQ (2026). ‘Stripe engineers deploy Minions, autonomous agents producing thousands of pull requests weekly.’ 1,300+ PRs/week, zero human-written code; blueprints; submission-not-merge authority; human review of every change. infoq.com
• ByteByteGo (2026). ‘How Stripe’s Minions ship 1,300 PRs a week.’ Six-layer architecture; interleaved deterministic gates and agentic loops; sandboxing; conditional rule files; reliance on pre-existing developer-experience infrastructure. blog.bytebytego.com
• CNBC (2025). ‘Satya Nadella says as much as 30% of Microsoft code is written by AI.’ Nadella at LlamaCon (20-30%); Pichai (>25% of new Google code); Zuckerberg projecting ~half of Meta development within a year. cnbc.com
• Ry Walker Research (2026). ‘In-house coding agents: build vs buy.’ Survey of in-house agent programmes (Stripe, Ramp, Abnormal, Shopify); StrongDM’s no-human-review “software factory”; forecast that human review becomes optional with mature validation infrastructure. rywalker.com
• Augment Code (2026). ‘The 2026 EU AI Act and AI-generated code: what changes for dev teams.’ Maps Articles 11/12/14 to engineering practice; notes spec-driven workflows as a route to Article 11 documentation that exists before market placement; 2 August 2026 enforcement. augmentcode.com