On Monday, Armin Ronacher — the creator of Flask and one of the open-source world’s most respected voices — published an essay called “The Tower Keeps Rising.” By Wednesday morning it had racked up 511 points and 235 comments on Hacker News, the kind of reception reserved for pieces that name an anxiety the industry is already feeling but hasn’t yet articulated.
Ronacher’s argument, built around Bruegel’s painting of the Tower of Babel, is that AI-assisted coding — “vibecoding,” as the kids call it — is producing software the way the biblical tower was built: fast, chaotic, and without a shared language that any single developer fully understands. The tower rises, but nobody can explain how the lower floors work anymore. The essay is elegant, and the anxiety is real. But the metaphor is doing more work than Ronacher lets on, and what it’s really doing is worth examining.
The Story Babel Actually Tells
The conventional reading of the Tower of Babel — the one Ronacher borrows — is a cautionary tale about hubris and the limits of coordination. But read the text closely and the moral gets stranger. God doesn’t scatter the builders because their tower is shoddy. He scatters them because it’s working. “Nothing will be restrained from them, which they have imagined to do,” the text says. The intervention isn’t a quality-control measure. It’s a response to capability.
The anxiety in Ronacher’s essay follows the same structure. He isn’t warning that AI-generated code will fail. He’s warning that it will succeed — that the tower will keep rising, floor after floor, built by people who don’t understand the floors beneath them, and that this will somehow constitute a crisis. But a tower that stands is a tower that stands. The crisis is for the people who used to be the only ones who knew how to lay bricks.
Whose Shared Language?
Ronacher writes that “the shared language of a software project is not English or Python but it is the understanding of what the code is supposed to do.” This is a beautiful sentence, and it is also a description of a guild. For decades, that shared understanding was accessible only to people who had spent years learning the dialects: the design patterns, the naming conventions, the unspoken rules about what counts as “clean” code. These were not neutral technical standards. They were cultural markers, and they functioned as gates.
A junior developer at a mid-sized SaaS company in Atlanta put it to me this way over Slack DM on Tuesday: “My boss spent ten years learning to write React components the ‘right’ way. I spent two weeks with Cursor and shipped the same feature. The code isn’t elegant, but it works, and the customer doesn’t care about elegance.” The shared language Ronacher mourns is precisely the thing that kept my source’s boss employed at a premium and kept my source from being hired until recently.
This is the part of the Babel story the essay skips. The builders didn’t all speak the same language before God intervened — they were already a multilingual workforce, the text implies, gathered from across the known world. What they had was a project. The shared language emerged from the work, not the other way around. AI tools are doing something similar: they’re letting people build first and develop shared understanding later, if at all. That’s not a bug. It’s the whole point.
The Quality Argument Is a Status Argument
Every conversation about vibecoding eventually arrives at maintainability. The code is messy. It’s hard to debug. It produces technical debt. All of this is true. But the software industry has been shipping messy, hard-to-debug code since the first COBOL program ran on a mainframe. The difference now is who gets to ship it.
When a Stanford CS graduate writes spaghetti code, we call it a startup MVP and fund it. When a self-taught developer in Manila uses an AI assistant to build the same thing, we call it a maintainability crisis and write 2,000-word essays about the Tower of Babel. The quality concern is real, but it’s not evenly distributed. It lands hardest on the people who were already outside the guild.
Ronacher is too thoughtful a writer to be accused of gatekeeping outright. But the essay’s reception — 511 upvotes from the same Hacker News crowd that has spent years debating whether bootcamp graduates are “real engineers” — tells you something about whose anxiety is being soothed here. The tower keeps rising, and the people who used to own the blueprints are discovering they’re no longer the only ones on the job site.
Let the Tower Rise
There is a version of this argument that says: slow down, build carefully, value craft. It’s a lovely sentiment, and it has approximately zero chance of influencing the economic incentives that drive software development. Companies don’t pay for craft. They pay for features that ship. If AI lets a team of five do what used to require fifty, no amount of elegiac blogging about shared language will reverse that math.
The more interesting question is what happens when the tower gets tall enough that nobody — not the original architects, not the AI, not the vibecoders — fully understands the whole thing. That’s not a hypothetical. That’s already the state of most large software systems, and it has been for years. AI didn’t create the incomprehensibility problem. It just made it cheaper to contribute to.
The builders are still building. The tower is still rising. And the people who are most alarmed by this are, by remarkable coincidence, the same people who used to be the only ones allowed to hold a trowel.