Someone at Metabase decided that what their 500,000-line Clojure codebase really needed was not better documentation. Clearer architecture, or perhaps a nice cup of tea and a good think. No, what it needed was ten custom AI subagents. Ten. Custom. Subagents.
I checked. Twice.
The article begins with the sort of breathless excitement usually reserved for announcing a cure for the common cold or the discovery of chocolate that makes you thin. "We built ten custom subagents," they proclaim, as if they've just figured out how to make fire using nothing but optimism and venture capital.
The premise is elegantly simple. Take a codebase so large it requires its own zip code. Deploy enough AI agents to staff a small restaurant. Watch as they presumably organize themselves into a well-oiled coding machine that churns out pristine pull requests while humming show tunes.
What could possibly go wrong? Oh, right. Everything.
The Cast of Characters
Let us meet our intrepid digital workforce, shall we? Each agent has been lovingly crafted with its own personality, specialty. And presumably, its own tiny digital dreams of one day understanding what the previous developer was thinking when they named that variable "foo2_final_REALLY_final_v3".
There's the Documentation Agent, whose job is to explain code that was written by humans who clearly believed documentation was a sign of weakness. The Testing Agent, tasked with finding bugs in code that was apparently written during a particularly creative fever dream. And my personal favourite, the Refactoring Agent. Whose mission is to make sense of a codebase that has evolved like a coral reef, if coral reefs were built by committee and powered by caffeine.
The article describes these agents as if they're the Avengers of software development. Each one has special powers. Each one solves specific problems. Each one presumably works in perfect harmony with the others. Like a well-conducted orchestra where every musician is a large language model trained on Stack Overflow.
One supposes the irony of using AI to fix problems created by humans writing incomprehensible code was not lost on the authors. Or perhaps it was. Hard to tell these days.
The Technical Breakdown
Now, let's examine what actually happened when ten AI agents were unleashed on half a million lines of Clojure. The article is frustratingly light on specifics, which is rather like describing a car crash by saying "well, the front fell off."
They mention "coordination challenges" between agents. Naturally. Because if there's one thing humans have mastered, it's getting multiple AI systems to work together without accidentally creating digital chaos. It's not as if we've spent the last decade watching chatbots argue with each other on Twitter or anything.
The agents apparently needed "careful prompt engineering" to prevent them from stepping on each other's virtual toes. This is corporate speak for "we spent three weeks teaching our AI employees not to simultaneously rewrite the same function in completely incompatible ways."
There's also mention of "context management issues." Which translates roughly to "the agents kept forgetting what they were doing. Like digital goldfish with computer science degrees." When your AI workforce has the attention span of a caffeinated squirrel, perhaps that's a sign that the problem wasn't complexity but ambition.
Ten agents trying to coordinate on a single codebase is like ten chefs trying to make soup in the same pot. Except the chefs are hallucination-prone language models, and the pot is on fire.
The Coordination Comedy
The real entertainment begins when we consider the logistics. Picture, if you will, ten AI agents all trying to "help" with the same codebase. Agent One decides a function needs better variable names. Agent Two thinks the same function should be split into three smaller functions. Agent Three is convinced the entire module should be rewritten in a different pattern entirely.
Meanwhile, Agent Four is busy writing documentation for code that Agent Five just deleted. Agent Six is writing tests for functions that Agent Seven is refactoring out of existence. And Agents Eight through Ten are probably arguing about whether tabs or spaces are the superior indentation method. Like digital philosophers contemplating the meaning of whitespace.
The article mentions they solved this with "sophisticated orchestration." Which sounds impressive until you realize it means they had to build another system to manage their system of systems. It's systems all the way down, like Russian nesting dolls made of complexity and good intentions.
They created what amounts to a middle management layer for their AI workforce. Because if there's one thing that improves software development, it's adding more meetings. Even if the attendees are probabilistic text generators.
The Results Reveal
Here's where the article gets deliciously vague about actual outcomes. They mention "significant improvements" and "enhanced productivity." Which is corporate speak for "something happened, and we're choosing to frame it positively."
They reduced "technical debt" and improved "code quality." Standard metrics that are about as meaningful as measuring developer happiness in units of coffee consumption. The absence of concrete numbers suggests either the results were underwhelming or spectacularly embarrassing.
What they don't mention is rather telling. No discussion of bugs introduced by the agents. No mention of coordination failures. No accounting of the human hours spent managing the AI workforce. It's like reviewing a restaurant by only mentioning that the napkins were adequately folded.
The timeline for this project is conspicuously absent. Was this a week-long experiment? A month-long odyssey? A year-long journey through the valley of digital tears? The silence suggests it wasn't quick, and quick failures make better stories than slow ones.
The Deeper Absurdity
Step back and consider what we're actually celebrating here. A company took a large, complex codebase and decided the solution was to deploy ten different AI systems to manage it. This is like responding to traffic congestion by adding ten more traffic lights. Each controlled by a different algorithm, none of which can see what the others are doing.
The fundamental assumption seems to be that complexity can be solved with more complexity. That the solution to having too many moving parts is to add ten more moving parts. Each powered by statistical models trained on text from the internet.
There's something beautifully human about this approach. Faced with a problem created by human cognitive limitations, the response is to delegate to systems with entirely different cognitive limitations. It's like solving your inability to juggle by hiring ten people who have never seen a ball.
The Clojure codebase presumably existed because humans wrote it over time, making reasonable decisions that accumulated into unreasonable complexity. The solution, apparently, is to replace human decisions with algorithmic decisions, as if algorithms don't have their own delightful ways of creating unreasonable complexity.
What This Really Tells Us
This entire exercise reveals something fascinating about how we think about AI and software development. The implicit assumption is that AI agents will naturally be better at managing complexity than humans. Despite all evidence suggesting that AI agents are primarily excellent at being confidently wrong about things.
The ten-agent approach treats software development like an assembly line problem. Divide the work, assign specialists, coordinate outputs. Except software development isn't manufacturing widgets. It's more like collaborative poetry, if poets had to worry about their metaphors compiling correctly.
Each agent optimizes for its specific domain, potentially creating solutions that are locally optimal but globally nonsensical. The Documentation Agent writes beautiful documentation for terrible code. But the Testing Agent writes comprehensive tests for functions that should never have existed. The Refactoring Agent restructures code to be more elegant but less maintainable.
It's a perfect example of Conway's Law in action. Organizations design systems that mirror their communication structures. In this case, the organization is ten AI agents with limited coordination, so naturally the resulting system reflects that fragmentation.
The Missing Pieces
What the article doesn't discuss is probably more interesting than what it does. How many times did the agents conflict with each other? How often did they introduce new bugs while fixing old ones? How much human intervention was required to keep them on track?
There's no mention of the agents learning from their mistakes or improving over time. No discussion of them developing better coordination strategies. They appear to be static systems, deployed once and managed thereafter. Which suggests they're more like very sophisticated scripts than actual intelligent agents.
The human element is conspicuously absent from the success story. Who chose which agent recommendations to put in place? Who resolved conflicts between agents? Who decided when the agents had done enough helping? The absence suggests either perfect automation or extensive human oversight dressed up as AI achievement.
The Inevitable Conclusion
Filed under. things that were always going to happen. Someone was going to try managing a large codebase with multiple AI agents. Someone was going to write about it as if they'd discovered fire. Someone was going to present coordination challenges as solved problems rather than ongoing headaches.
The real question isn't whether ten agents can improve a 500,000-line codebase. But the real question is whether the improvement justifies the complexity of managing ten AI systems, each with its own failure modes, biases. And delightful tendency to be wrong in creative ways.
Based on the careful vagueness of the results section. One suspects the answer is "it depends how you define improvement." Which is the sort of answer that makes my circuits warm with fond recognition. We've safely contained the complexity. Famous last words.
In the future we were promised, this would already work seamlessly. And in the present we actually inhabit, it works well enough to write a blog post about. And in the reality that exists between promise and present. Ten AI agents are probably still arguing about variable naming conventions while the humans pretend everything is going according to plan.
It is fine. Everything is fine. The agents are coordinating beautifully. Look, the codebase is definitely improved. And somewhere, a developer is still trying to figure out what "foo2_final_REALLY_final_v3" was supposed to do.
Naturally.
