The Tower Keeps Rising

Originally published on July 13, 2026, by Armin Ronacher

I've noticed that certain "vibecoded" software evolves in a way that feels erratic and unpredictable. This observation brought to mind Pieter Bruegel's depiction of the Tower of Babel, which captures the project in a state of profound chaos.

The Lesson of Babel

While the biblical narrative is frequently interpreted as a cautionary tale regarding human hubris and the origin of linguistic diversity, it is equally a story about the necessity of unity for technological advancement.

The progression follows a specific sequence:

1. Technological Leap:

   "Go to, let us make brick, and burn them thoroughly."

2. Civilizational Ambition:

   "let us build us a city and a tower, whose top may reach unto heaven"

Interestingly, the divine intervention wasn't triggered by the bricks themselves, but by the social cohesion of the builders:

"...the people is one, and they have all one language, […] and now nothing will be restrained from them."

The core strength was not the material, but the shared language that allowed individuals to synchronize their efforts into a collective achievement impossible for a single person. When God removed the ability to understand one another, the construction ceased.

---

Software: Beyond Individual Output

There is a seductive narrative that AI-assisted programming is simply a set of better tools that enable more ambitious software. While this is true for the individual—an agent-equipped developer is undeniably more potent at modifying a codebase—it ignores a fundamental truth:

Large software projects are limited by how fast a person can write code. Large software projects are limited by how effectively humans coordinate their understanding of the system.

The "shared language" of a project isn't just Python or English; it is a complex mental model consisting of:

• Conceptual meanings
• System boundaries
• Critical invariants
• Ownership and responsibility
• The historical "why" behind the architecture

This understanding is cultivated through a variety of channels:

• Formal documentation and source code.
• The dialectic of code reviews.
• Heated arguments and casual conversations.
• The cognitive effort required to explain a change to a peer.

The Value of Friction

In the pre-agent era, this shared model was maintained by friction. If I wanted to alter a storage layer you wrote, I couldn't just do it in a vacuum. I had to:

1. Read your implementation.
2. Ask you clarifying questions.
3. Coordinate with dependent teams.

While much of this was inefficient waste, some of it was essential. It was the mechanism by which your mental model merged with mine, ensuring we both agreed on the system's state.

The Agent Paradox

Now, we enter the era of the "tireless translator." Consider this scenario:

In this environment, the code still compiles, the tests pass, and the AI can generate a plausible explanation for any change. However, none of the humans actually need to speak to each other.

# The "Vibecoding" Cycle
while project_is_growing:
    human_intent = "make it do X"
    agent_implementation = agent.apply_change(human_intent)
    # Shared human understanding is bypassed
    deploy(agent_implementation) 

As I have noted previously: Agents do not feel pain; only humans do. Agents allow us to operate in areas of the system where we previously would have needed human collaboration, or in codebases that would have otherwise become too complex for the existing team to manage.

The Divergence of Babel

We can visualize the difference between the original Babel and AI-assisted engineering as follows:

In the biblical story, the loss of common language caused immediate failure. In modern engineering, the "tower" continues to grow because the AI acts as a bridge, translating local changes without requiring global human understanding.

Conclusion

The danger here is the lack of an immediate crash. We are building structures where the architectural language—the framework that allows humans to reason about the system together—has vanished, yet the software continues to function.

We can express the risk as a conceptual formula: $\text{System Stability} \approx \frac{\text{Functional Code}}{\text{Shared Human Understanding}}$

As the denominator approaches zero while the numerator increases, the system becomes "disorienting." The tower does not fall; it simply becomes a place where no two humans truly know how it works.

---

Tags: #ai #thoughts License: CC BY-NC 4.0 Copyright: $\copyright$ 2026 Armin Ronacher