AI code duplication happens when an assistant writes a fresh implementation of something the system already does, and its cost arrives later, when that decision has to change in every copy. Manju George makes the case for this kind of system-level attention in a recent article, and this piece extends one claim from it.
George argues that a working component can still break the system
George, a staff software engineer whose career runs from CBASIC point-of-sale systems to AI, argues that framework skills age while systems thinking lasts. Her clearest example is reuse. She describes building reusable Angular libraries for enterprise user interfaces, which she says served more than a dozen internal apps. Before that work, separate teams built the same features separately, and the cost showed up later: the same defect fixed several times, user experience drifting apart, harder testing, and improvements that reached only one app. She found the hard part was boundaries, extension points, versioning, and ownership, and she concluded that an abstraction earns its place only when its value over time exceeds its maintenance cost.
She then applies the same view to AI-assisted development. Generated code still lands in a larger system, so someone has to decide whether it fits, what it assumes, what risks it adds, and whether it repeats a capability that already exists. She suggests teams ask “should we implement it this way?” as well as whether they can.
AI code duplication lowers the cost of a copy and leaves the cost of change untouched
George’s list of duplication costs is a list of change costs. None of them appear on the day the second copy is written. They appear when a defect, a policy, or a user expectation changes and someone has to find every place the old behaviour lives.
Her rule for abstractions weighs value over time against maintenance cost. An AI assistant changes one side of that comparison sharply. Producing a working copy of a date formatter, a retry policy, or a permission check now takes seconds, while finding the shared library, reading its interface, and asking its owner for an extension point takes as long as it always did. At the moment of decision, the local choice favours the copy. The change cost that George describes stays exactly where it was, and it is paid later by someone else. My inference is that teams adopting assistants will produce more copies unless the review process makes the existing capability visible at the moment the copy is proposed.
Parnas defined a module by the decision it hides, and a copy spreads that decision
David Parnas gave this problem its classic form in On the Criteria To Be Used in Decomposing Systems into Modules, published in Communications of the ACM in December 1972. He proposed that a design should start from a list of difficult design decisions, or decisions likely to change, and that each module should be designed to hide one such decision from the others. A module, in his framing, is defined by the knowledge it keeps to itself.
Read through Parnas, a duplicate is a decision that has escaped its module. When an assistant writes its own version of how an order total is rounded or which roles may export patient data, that decision now lives in two places with no link between them. Each copy can pass its own tests, which is George’s point about a component working while the system fails. An assistant can only reuse what it can see. If the shared module is outside its context, the assistant has no reason to call it, and the reviewer becomes the only part of the process that knows the decision already exists.
For anyone working on AI governance, this is where duplication stops being a code quality topic. A security fix or a policy change applied to the shared module does not reach a copy that nobody knows about. The control is in place on paper and missing in production.
DORA’s 2024 data shows stability falling as AI adoption rises
The 2024 Accelerate State of DevOps Report from Google’s DORA team reported a result its authors called contrary to their expectations. For every 25% increase in AI adoption, they estimated a 1.5% reduction in delivery throughput and a 7.2% reduction in delivery stability. The same report found AI improving process measures such as documentation quality, code quality, and code review speed. The authors’ hypothesis was that faster code generation is growing the size of changelists, and that larger changes have consistently been slower and more prone to instability in DORA’s research.
DORA did not measure duplication, and I do not claim it explains the stability result. The two ideas share a mechanism, though. Both describe a local gain, more code per hour, that becomes a system cost once the code meets everything around it. A larger changelist that also carries a second implementation of an existing decision gives a reviewer more to read and less reason to notice what was copied.
Code reviews should ask where a decision already lives
The practical step is one review question for every AI-assisted change: does this change make, in a new place, a decision the system already makes somewhere else? If the answer is yes, the reviewer names the existing owner and either routes the change through that module or records why a separate copy is justified. This is my proposal, drawn from George’s emphasis on ownership and Parnas’s criterion, and it is not a practice either of them prescribes.
Two supporting habits make the question answerable. Teams can keep a short catalogue of shared capabilities with a named owner for each, and give it to the assistants as context so the reuse option is visible before the copy is written. Leaders can also track known duplicates of security-relevant decisions, such as authorization and input validation, as a count that should fall over time.
There are clear boundary conditions. George herself writes that some things should not go into a library. Two copies are the right answer when the decisions inside them are expected to diverge, as with two products whose pricing rules belong to different business owners. A small team with one application gains little from a catalogue. And an abstraction pulled out too early can cost more than the copies it replaced, which is exactly the trade-off her value-over-time rule asks teams to weigh.
Why This Matters for Engineering Leadership
AI assistants make it cheap to say yes to a local solution. George’s experience with shared libraries shows where that bill arrives: in defects fixed several times and in improvements that never reach most of the system. Parnas explains why, since each copy carries its own version of a decision that should have one home. DORA’s 2024 data suggests the system-level cost of faster generation is already visible in delivery stability. The response that fits a leader’s role is procedural: every review asks where a decision already lives, and a named person owns the answer.
FAQ
What is AI code duplication?
It is code an AI assistant writes that re-implements a capability the system already has. Each copy carries its own version of the same design decision, so a later change has to be made in every copy.
Why does duplication cost more over time?
Manju George lists the costs from her own work on reusable libraries: defects fixed several times, user experience that drifts apart, harder testing, and enhancements that reach only one application.
What did DORA find about AI adoption and stability?
The 2024 Accelerate State of DevOps Report estimated a 7.2% reduction in delivery stability and a 1.5% reduction in throughput for every 25% increase in AI adoption.
What did Parnas say about modules?
In his December 1972 paper in Communications of the ACM, David Parnas proposed starting a design from the decisions that are difficult or likely to change, and giving each module one such decision to hide.
Is duplication ever the right choice?
Yes. George writes that some things should not go into a library. Two copies are reasonable when the decisions inside them are expected to diverge, or when a shared abstraction would cost more to maintain than it saves.
What should a code review ask about AI-generated code?
This piece proposes one question: does this change add a second place where a decision the system already makes is now made again? If yes, the reviewer names the existing owner before merging.
