Agentic AI Systems Turn Fragile as Non-Engineers Build Big Balls of Mud

Nielsen Norman Group researchers studying so-called "vibe architects" — users with little technical background who assemble complex agentic AI systems around large context libraries — have identified a familiar failure pattern: the big ball of mud, the architecture term for a system scraped together for short-term functionality rather than designed for long-term durability.

The finding matters because of who is now doing the building. Building systems for working with AI agents is software engineering, whether or not the builder knows it. Increasingly, the builders are not engineers. They compose agents, prompts, and context libraries piecemeal to support daily work, and the economics of AI remove the constraints that once forced discipline.

Software engineers learned long ago that systems patched together to meet today's needs turn fragile and unmaintainable. They learned to plan architecture so that changing a system later would not cost more time, money, and expertise than they had. AI makes all three resources feel unlimited. With nothing forcing them to prioritize, the study participants grew their systems without structural planning.

The result resembles the classic big ball of mud described in the canonical software architecture literature (the term originates from Brian Foote and Joseph Yoder's 1997 essay, hosted at laputan.org). A big ball of mud is a system assembled for immediate utility, not architected for endurance. In traditional software, such systems collapse under their own weight quickly, which is why engineers invested in upfront design.

The AI era changes the calculus in one crucial way: a big ball of mud now works surprisingly well, for a while. Generation is nearly free, so patching another agent onto the pile costs almost nothing and delivers immediate value. That tolerability is the trap.

The breaking point arrives with accumulated complexity. The researchers observed that these agentic systems eventually become difficult to direct, difficult to diagnose, and difficult to reconstruct. The owner can no longer explain why the system behaves as it does, cannot trace failures to their causes, and cannot rebuild or substantially modify the system without starting over — because no coherent architecture underlies it.

This inverts the traditional cost curve. In pre-AI software engineering, the pain of mud appeared early, in maintenance costs, which pushed teams toward architecture. In agentic AI systems, the pain is deferred: users extract value for months before the system's opacity catches up with them. By then, the knowledge needed to untangle it lives nowhere except inside the accumulated pile itself.

The pattern has implications for anyone designing tools, interfaces, and platforms for agent-building audiences. If the failure mode is invisible until it is severe, the interface layer becomes the only viable place to surface it. Builders who cannot read code need other signals: indications of system structure, dependency relationships between agents and context sources, and warnings when a configuration has crossed from composed to entangled.

It also reframes what "AI makes building free" actually means. The marginal cost of adding a component approaches zero, but the marginal cost of understanding the whole does not. That gap widens with every addition, and it is the gap the NN/g study found users falling into — systems that serve them until the day they cannot.

The full article, part of NN/g's ongoing research into vibe architects and agentic workflows, suggests the next phase of this work: establishing which architectural practices, if any, non-engineer builders can adopt to keep their systems comprehensible as they scale.