AI coding tools generate functions in seconds. They scaffold features and pass initial tests with startling speed. Yet the systems they help build often grow harder to maintain. The bottleneck isn’t generation. It’s comprehension.
Software has always carried two burdens. One is accidental. The other is essential. Fred Brooks laid this out decades ago in his essay “No Silver Bullet.” Tools attack the first. The second stays stubbornly human. The Next Web explores how this split now defines the limits of AI assistance in “Complexity is the ceiling: software design in the age of AI coding”.
Writing code grew cheap. Understanding a sprawling codebase and altering it safely did not. Models produce volume. Engineers and the models themselves must still grasp dependencies, invariants and ripple effects. That grasp hits a wall at system complexity. So the cleaner the architecture, the more an AI can achieve without constant human rescue. Messy designs cap what agents deliver. They also multiply the cost of every future change.
John Ousterhout captured this in his book on software design. Complexity appears as change amplification. A tweak in one spot forces updates across many. It shows up as cognitive load. Developers juggle too many details at once. Unknown unknowns hide the true impact of edits. None of these yields to faster typing or better prompts. They demand structure that keeps interfaces clear and implementations hidden.
AI tilts the balance toward tactical fixes. Models optimize for code that runs now. They duplicate logic instead of extracting shared concepts. They extend parameters rather than rethink abstractions. The result looks functional. Over time it erodes. A 2026 arXiv study of more than 300,000 AI-authored commits found over 15 percent introduced new issues. Nearly 90 percent of those were code smells. The program compiled. Tests passed. The design quietly worsened. (The Next Web).
But the data grows sharper. BlueOptima’s AI Refactoring Evaluation benchmark tested models on real maintainability tasks drawn from production environments. Success rates averaged 17 percent. Even top proprietary systems topped out at 23 percent. Localized changes fared better. Architectural overhauls barely cleared 5 percent. Jason Rolles, CEO of BlueOptima, put it plainly. “This ability to work within large, complex, and constantly evolving codebases is the harder and more consequential part of software engineering, and it’s where LLMs are falling short.” The models plateau. Further scaling yields diminishing returns. (DevOps Digest, May 18, 2026).
Wes McKinney saw the same pattern in practice. Agents handle accidental complexity well. They refactor boilerplate and chase obvious patterns. Essential design questions without clear precedents trip them up. And they introduce fresh accidental complexity. Defensive code. Unneeded abstractions. Bloated context that chokes later passes. His projects crossed the 100,000-line mark and hit what he calls the brownfield barrier. Agents began chasing their own tails. Changes hacked through prior generations of machine-generated jungle. At Posit, the Positron codebase exceeds one million lines. Agents struggle more there. “When generating code is free, knowing when to say ‘no’ is your last defense,” McKinney wrote. (Wes McKinney’s blog, Feb. 17, 2026).
MIT Sloan researchers reached similar conclusions in brownfield settings. Generative tools can lift productivity 55 percent in controlled trials. In legacy systems the gains come with hidden costs. Technical debt compounds faster. Inexperienced developers ship AI output that looks correct yet embeds subtle flaws. Maintenance expenses rise. Security weakens. One Stanford study found developers using AI assistants produced less secure code yet felt more confident in its safety. Output that runs is not output that lasts. (MIT Sloan Management Review).
Google’s DORA report on AI-assisted development reinforces the pattern. The technology amplifies existing conditions. Strong engineering foundations see higher throughput and stability. Weak ones suffer more failures and rework. Complexity decides the direction of that amplification.
Deep modules offer one practical counter. They present a simple interface that hides sophisticated behavior. Engineers specify the contract. Models fill the implementation. Review focuses on boundaries, tests and risk points. Shallow, leaky designs remove that option. Every change requires tracing threads across scattered pieces. The model gets lost. So does the human.
David Parnas argued for information hiding in 1972. Modules should conceal decisions likely to change. That principle scales to AI delegation. Clear contracts and fast feedback loops let models operate safely inside bounded units. Tangled code slows feedback and accelerates damage. The Pragmatic Programmer’s insight applies equally to people and machines. The rate of feedback sets the speed limit.
Teams that treat design as continuous work fare better. Kent Beck called it incremental design. Invest small amounts of effort steadily rather than allow entropy to build. Models remain tactical. Humans supply the strategic layer above them. The most valuable skill isn’t prompt crafting. It’s knowing which code not to write and which structures to protect.
Recent benchmarks and production data suggest the ceiling is real. Models improve on narrow tasks. They saturate synthetic tests. Real-world refactoring and long-horizon maintenance expose persistent gaps. Enterprises managing multi-repository systems report the same. Architectural context across services and languages remains difficult for current tools. Scale, compliance and legacy generations add layers no single prompt can pierce. (Augment Code, updated 2026).
Yet the story isn’t one of failure. AI already lifts output where design stays disciplined. The question shifts from how much code a team can generate to how simply it can arrange what exists. Complexity sets the ceiling. Strategic investment in structure raises that ceiling for everyone. Models included.
Engineers who master this distinction will extract the most from AI. Those who treat generation as the goal will watch their systems calcify under layers of tactical output. The fundamentals haven’t changed. Their price of neglect has.
WebProNews is an iEntry Publication