Software development has always had an asymmetry: code can be written faster than it can be understood.

Code is written once but read repeatedly during reviews, debugging sessions, refactors, and production incidents. The real constraint has always been understanding code rather than typing it.

AI dramatically widens that asymmetry. Tools like GitHub Copilot and Claude Code can generate thousands of lines of code in minutes, but the speed at which humans understand code hasn't changed.

Before AI, the speed of writing code naturally constrained how quickly systems could grow. AI removes much of that friction. But human comprehension speed hasn't changed. Systems can now grow faster than teams can understand them — or keep them coherent.

The asymmetry isn't new, but the magnitude is.

Systems Can Now Grow Faster Than Teams Can Understand

Discussions of AI-generated code often focus on correctness or "AI slop." That risk is real. But a larger risk is structural: how quickly disorder can accumulate as systems grow faster than humans can maintain them.

AI removes much of the friction from writing code. AI can generate large portions of features from a handful of prompts. But every line of code still has to be read, reviewed, debugged, refactored, and extended. Even correct code increases cognitive load, because it still increases the amount of code humans must understand.

A messy system with 20k lines of code is annoying. A messy system with 500k AI-generated lines of code becomes extremely difficult to understand.

AI increases code volume while increasing the speed at which structural entropy, like small inconsistencies and duplicated code blocks, can accumulate.

As that entropy grows, so does the system's cognitive surface area: the amount of structure developers must mentally explore to understand the code.

As systems grow faster, the team's mental model can struggle to keep up.

The Bottleneck Shifts

When developers switch to using AI tools, they spend less time manually writing code and more time analyzing AI-generated code:

• reviewing it
• validating that it actually behaves correctly
• integrating it correctly into the system
• refactoring it into something readable
• aligning it with existing patterns in the codebase

The bottleneck shifts from typing code to understanding, reviewing, and shaping the generated code to fit the system.

As code volume increases, code review becomes more cognitively demanding. Large AI-generated changes increase review fatigue, making it harder for both the author and the reviewer to fully understand and validate every change.

AI Introduces Structural Drift

AI generates code from the local context it sees rather than a full understanding of the system's architecture. As a result, it does not reliably maintain global structural consistency across the system. Small inconsistencies can accumulate across many changes, such as:

• slightly different abstractions
• duplicate logic
• inconsistent naming
• subtle architectural drift

Individually, these differences are small. But across hundreds of changes they compound.

Over time, these inconsistencies increase the cognitive entropy — the amount of disorder a reader must make sense of — of the system. The structure becomes harder to recognize. The patterns become less predictable. When patterns become unpredictable, understanding slows down.

Humans Maintain Coherence

In addition to validating correctness, developers must ensure AI-generated code fits the system's existing structure and conventions. This maintains system coherence. By coherence, I mean:

• The structure of the new code makes sense
• The patterns remain consistent internally and across the system
• The boundaries of methods, classes, and packages remain clear
• Responsibilities remain understandable
• Complexity remains manageable
• Naming remains accurate and meaningful
• Similar problems are solved in similar ways

Readable code is required to make that possible.

AI does not automatically maintain system coherence. As codebases grow faster through AI code generation, a larger part of the developer's job becomes counteracting structural drift. Without that effort, the system becomes harder to understand over time, even if every individual piece works.

Readable structure allows coherence to survive as the system grows.

AI Can Also Help Maintain Readability

AI can also help with the work of maintaining coherence. With enough context and a human in the loop to validate their proposals, frontier models are surprisingly good at:

• structural refactors
• naming improvements
• package reorganization
• large mechanical changes

I've had good results asking Claude Code to analyze an architectural layer of a codebase and propose an updated package and class structure based on the business functionality it detects — adding breadcrumbs for me. (More on using AI to improve a hard-to-navigate codebase in a future article.) It saves time by handling the analysis and tedious cut-and-paste, and the return on investment multiplies every time someone works in that part of the system and benefits from the improved navigability.

The Constraint Hasn't Changed

AI dramatically reduces the cost of producing code. But the fundamental constraint in software development has never been typing. It has always been understanding. Human comprehension speed does not scale with code generation speed.

Whether a system remains understandable depends on its coherence: the consistency of its structure, boundaries, and patterns. Readable structure is what preserves that coherence as a system evolves.

Some companies are experimenting with AI-driven development loops where agents generate specifications, write implementations, run tests, and even review their own changes. In those environments, humans may not read every line of code. But even highly automated systems still rely on humans when something goes wrong. Production incidents, unexpected behavior, and architectural changes require developers to understand what the system is doing and why.

Whether code is written manually, with AI assistance, or through AI-driven development loops, understandable systems are still necessary for the humans maintaining them.

But what actually determines how difficult a system is to understand?

In my next article, I'll go into more depth about cognitive surface area: the property of a system that determines how much of it developers must mentally explore to understand or change behavior.

AI was my editor, but these ideas are my own.

---

This article is part of a broader series exploring how code structure, navigability, and cohesion align with cognitive limits.

If you're interested in the deeper dive, the full series is here:
Designing Systems for Human Brains