The Tower Keeps Rising
The story of the Tower of Babel is often told as a parable about pride and the origin of different languages. But, as Armin Ronacher invites us to reflect, there is a deeper and more surprising lesson for us, builders and technology leaders, especially in the era of Artificial Intelligence-assisted software development. And what he reveals is an uncomfortable truth: while in the biblical story construction stopped when communication failed, in the age of AI, the tower continues to rise, even when collective understanding collapses.
The True Strength Behind Great Projects
The biblical text begins with a technological update: "Go to, let us make bricks, and burn them thoroughly. And they had brick for stone, and bitumen for mortar." They use this innovation for an ambitious civilizational project: "let us build us a city and a tower whose top may reach unto the heavens." But, in assessing the situation, the divine concern was not the bricks or the technique. It was coordination: "the people is one, and they have all one language... and now nothing will be restrained from them, which they have imagined to do."
Their source of power was coordination. They shared a language and, with it, could combine their work into something none of them could build alone. God did not take away the bricks or the knowledge of how to make them; He took away their ability to understand each other, and construction stopped.
In the world of software, the lesson is the same. There is the seductive idea that AI-assisted programming means better tools, allowing us to build more ambitious software. This is true at the individual level; a developer with an "agent" (an AI assistant) will be dramatically more capable of modifying a codebase. However, large software projects have never been limited solely by the speed with which an individual can produce code. They are limited by the quality of coordination between people and the shared understanding of the system they are changing.
The Shared Language of Software and Essential Friction
The "shared language" of a software project is not Python or Portuguese. It is the common understanding of what its concepts mean, where the boundaries are, which "invariants" (rules that must always be true) matter, who is responsible for what, and why the system has the shape it has. This language is rarely written in a single place. It lives partly in documentation and code, but also in "code reviews", conversations, discussions, and the experience of having to explain a change to someone else.
Before AI agents, part of this shared understanding was maintained by "friction." If I wanted to change your storage layer, I would typically have to read your code, ask you questions, and perhaps coordinate with another team whose service depended on it. This was slow, and much of that slowness was waste, but not all of it. Part of it was the process by which my understanding became yours, and by which we both discovered if we still agreed on how the system worked. This friction synchronized people.
AI Agents: The Tower Keeps Rising, Understanding Collapses
AI agents remove much of this friction. I can ask an agent to add "OAuth" (a standard for authorization), you can ask to add "caching" (a temporary data storage mechanism), and someone else can ask to rebuild the database from scratch and make the user interface (UI) pink. Each change can be reasonable in isolation. The code compiles, tests pass, and explanations can be generated on demand. None of us necessarily needs to talk to others, or even acquire the part of the shared model that the change would have previously forced us to learn.
As Ronacher aptly puts it: "agents don't feel pain, only humans do." Agents now allow us to act on parts of the system where we previously needed other people and on codebases where people would have taken turns. Observing some rapidly scaled projects, codebases become a Babel not because no one can communicate, but because no one needs to. Each developer has a "tireless translator" who can explain a corner of the tower and make any local change requested of them. Changes continue to be implemented, even as the "architectural language" that would allow humans to reason about them together disappears.
But it's not the biblical story. In Babel, the loss of common language halts construction; in AI-assisted engineering, construction can continue after shared understanding has already collapsed. The lack of an immediate failure is what makes everything curious and somewhat disorienting. The tower doesn't fall, and so we don't realize what has been lost. It just keeps rising.
Why This Matters
For builders and technology decision-makers, this is a crucial observation. The "code delivery speed" metric may be masking a silent erosion of shared knowledge capital within your team or organization. AI is a powerful productivity tool, but if we are not intentional in creating new mechanisms to keep the "architectural language" alive – through collaborative design processes, active documentation, synchronization sessions, and, yes, still some strategic "friction" – we run the risk of building complex systems that, although functional, become unintelligible and unsustainable in the long run. The real challenge is not just to build faster, but to build in a way that the collective knowledge about what has been built can endure and evolve.
Sources
📬 Enjoyed this? Subscribe to the Vaccari's Code newsletter for the next wave of software & AI trends, straight to your inbox: Subscribe here