The Tower Keeps Rising

There's a new blog post making the rounds that reaches for an unusual reference point to explain something odd happening in AI-assisted software development: Bruegel's painting of the Tower of Babel, and the biblical story behind it. The familiar reading of that story is about hubris getting punished. The author's reading is different. It's about coordination, and what happens when the thing that makes coordination possible quietly disappears while the building keeps going up.

The argument goes like this. Large software projects were never bottlenecked purely by how fast one person could type out code. They were bottlenecked by how well a group of people could keep a shared mental model of the system in sync: what the concepts mean, where the boundaries sit, which rules can't be broken, who's responsible for what. That shared model doesn't live in a single document. It gets built and rebuilt through code review, hallway arguments, and the simple friction of having to explain your change to a colleague before you're allowed to ship it.

AI coding agents strip a lot of that friction away, and that's the point of the essay. One engineer asks an agent to bolt on OAuth, another asks a different agent to add caching, a third has an agent rip out the database and repaint the UI pink. Each change passes its tests. Each one compiles. And none of the three people involved ever had to sit down and reconcile their understanding of the system, because the agent handled the translation instead of a human colleague. The author's blunt line on this: agents don't feel pain, only people do, so the pushback that used to come from a frustrated teammate simply doesn't happen anymore.

What makes this genuinely unsettling, according to the piece, is how it diverges from the original Babel story. In Genesis, when the shared language vanished, construction stopped immediately — the confusion was visible, the project ground to a halt. In a vibecoded codebase, the essay argues, nothing stops. Changes keep landing. The tower keeps rising. It's just that the architectural language letting humans reason about the whole structure together has already quietly evaporated, and there's no dramatic failure to signal that it happened.

That absence of a visible breaking point is the real subject here, more than any specific bug or outage. The essay isn't predicting collapse. It's pointing at a blind spot: a system can keep functioning, keep compiling, keep shipping, even after the people building it have stopped sharing a common understanding of what they're building. Nobody notices, because nothing forces them to notice.