iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
AI-assisted code can satisfy each request and still make a system harder to maintain. The risk is cumulative: repeated small changes can blur ownership, add dependencies, or spread business rules across boundaries. In Robert Adamson’s September 29, 2026 essay, “AI Can Make Every Local Decision Look Reasonable — While Making the System Worse,” this is an engineering argument illustrated with scenarios—not a measured study showing how often AI causes architectural decline. Read Adamson’s essay.
Why can individually reasonable changes make a system worse?
A change can be correct for its immediate task without improving the system around it. A helper may be convenient in one pull request; later, other features may use it too, until unrelated business rules collect in a shared location. Each step can look defensible on its own, while responsibility becomes harder to locate and future changes harder to reason about.
Adamson describes sequences of small changes that can produce unclear ownership and dependencies running in both directions. These are explanatory scenarios, not evidence about how common the outcome is or proof that AI alone causes it. The broader engineering concern is that local correctness and system-level maintainability are different review questions.
What should you check beyond passing tests?
Tests can show that expected behavior still works; they do not, by themselves, establish that boundaries or ownership remain clear. A hypothetical example in Adamson’s essay has “100% tests passing,” but unclear ownership and dependency creep. That figure is illustrative, not a reported test result or statistic.
#1 Best Overall
- Ownership: Is it clear which part of the system owns each rule?
- Dependency direction: Does a change make dependencies more tangled or create a path back across a boundary?
- Duplication: Has the change copied a business rule that already exists elsewhere?
- Abstraction: Does a new helper or service clarify a stable responsibility, or merely relocate complexity?
- Explainability: Can a developer still describe where this behavior belongs and why?
How can a reviewer spot cumulative drift?
Consider the pattern, not just the diff in front of you. Adamson’s suggested prompt is: “If we repeat this pattern 20 times, what does the system look like?” The number is a thought experiment, not a threshold or measured benchmark. It helps make the long-term consequence of a locally convenient choice easier to discuss.
For a proposed change, ask whether it introduces an abstraction, moves responsibility, adds a dependency, or duplicates a pattern. Then consider what repeated use would do to the codebase. If the answer is difficult to explain, pause and clarify the intended ownership or boundary before approving the pattern.
How can teams make architecture expectations explicit?
Adamson recommends writing down architectural invariants—decisions or boundaries that changes should preserve—and asking for an architecture impact assessment before implementation. For example, a team might state which domain owns a business rule and which direction dependencies are expected to flow. These practices give reviewers concrete questions to apply; the essay does not claim they guarantee a particular outcome.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesWhen reviewing AI-generated work, separate two judgments: whether the change completes the task, and whether it fits the system’s design. The agent can propose code, but the human reviewer remains responsible for deciding whether its structure is appropriate. As Adamson puts it: “The agent owns the task. You still own the architecture.”
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Can AI help detect architecture drift?
AI can also be asked to inspect a codebase for possible boundary problems, duplicated rules, or dependency changes. Treat its findings as leads to verify against the code and the team’s stated invariants—not as proof that a problem exists or that a proposed refactor is safe. Adamson’s advice is to detect and rank concerns before refactoring, so investigation precedes broad changes.
A separate chapter on trajectory search discusses agents continuing competently along a mistaken path and the role of environmental evidence and independent verification. That is adjacent guidance about evaluating agents, not direct evidence for claims about architectural drift.
Quick Recap
Best Value
Rank #4
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
