The Industrial Croissant Cannon
AI code generators create a dangerous illusion of velocity by mass-producing raw code that overwhelms the human bottleneck required to ship software.
By Saul Berger
Sparked by AI usage patterns in software teams · discussion
Todd the VP of Engineering stares lovingly at a Jira dashboard glowing with a 400% spike in opened Pull Requests. He cannot fathom why his developers are complaining; after all, they are absolutely crushing their deployment metrics! Todd has a freshly minted degree in Management Information Systems, owns a closet entirely populated by branded fleece vests, and sincerely believes he is a tactical genius of the highest order. The charts look spectacular. The velocity graphs point aggressively up and to the right.
Meanwhile, down in the physical trenches of the actual repository, his senior duct-tape developers are drowning in a sea of synthetic code. They are currently experiencing a sensation roughly equivalent to untangling a miles-long ball of Christmas lights while wearing thick silicone oven mitts in a flooded basement.
We have been conditioned by slick vendor marketing and overcaffeinated venture capitalists to accept a deeply dangerous fallacy regarding software productivity. The prevailing industry assumption dictates that rapidly generating thousands of lines of text fundamentally equals moving faster. As long as the dashboard numbers escalate, the software must be getting written.
Wrong.
This metric-driven hallucination ignores basic history. To borrow a highly accurate historical comparison regarding arbitrary metrics, measuring programmer productivity by simply counting output is exactly like measuring airplane building progress by weight.
(Listen closely, metric-obsessed MBA dashboard fetishists: I do not want to hear a single syllable about your burndown charts, your abstract story points, or your sprint velocity algorithms. Just close the tab, go color in your coloring book, and let the adults talk.)
When a large language model effortlessly spits out six hundred lines of verbose, superficially plausible React components, the result is completely devoid of inherent business value. It just makes the airplane drastically heavier. To understand why this artificial weight is systematically destroying your engineering team, we have to pivot away from technical griping and look at stark microeconomics.
Every software development department on the planet operates precisely as an industrial bakery.
A functioning engineering team takes raw ingredients and transforms them into baked bread that paying customers can actually eat. In this physical ecosystem, the unmerged code represents the raw dough. The ovens represent the senior developers reviewing, testing, verifying edge cases, checking for SQL injection vulnerabilities, and finally merging that code into production.
Rather than contributing any actual baking to the process, modern AI code generators function entirely as an Industrial Croissant Cannon.
They sit on the factory floor, whirring away, blasting 10,000 raw, wet pastries a minute directly at two deeply exhausted human bakers. Dough generation rarely causes bottlenecks in any software organization, because the true constraint always remains oven space. The absolute maximum throughput of your factory is strictly limited by the excruciating human attention required to verify that the generated code actually solves the business problem without quietly siphoning all your user data to a server in Belarus.
Unmerged code functions strictly as raw inventory, actively depreciating the moment it leaves the generator. And on a physical factory floor, unbaked inventory simply takes up space and rots. Inside a codebase, this wet dough rots into massive merge conflicts, accumulating architectural debt, and broken builds that require a human being to physically unpick the mess. A feature branch sitting open for four days while a senior engineer tries to manually verify if a hallucinated crypto library is mathematically secure is the exact digital equivalent of a massive pallet of rotting yeast blocking your loading dock.
Imagine a two-panel MS-Paint flowchart right here. Top panel: A perfectly balanced factory featuring a small dough extruder feeding a properly sized oven, outputting hot bread. Bottom panel: The Croissant Cannon blasting an apocalyptic avalanche of wet dough at a tiny, overwhelmed oven labeled Senior Dev Review.
I call this looming disaster The Law of Synthetic Velocity. It describes the dangerous illusion of speed created by generating massive amounts of unverified inventory that nobody on the team possesses the cognitive capacity to bake.
Let us look at the actual math surrounding this chaos. Recent Linear data tracking AI usage patterns empirically observes this exact factory floor collapse playing out at scale. The platform's internal telemetry confirms the brutal reality of the Croissant Cannon, revealing that while AI features drastically inflate the volume of new issues and pull requests, the actual quantity of resolved issues stays entirely flat.
Read that again. The automated extruder is running furiously faster, but the bakery is failing to ship a single extra loaf of bread. The ovens are at absolute capacity, and the factory floor is simply filling up with unbaked sludge.
When you dive into the exhausted Hacker News comments discussing these exact Linear findings, the developers are practically screaming into the void. The visceral, human toll of managing this relentless influx of generated slop is burying teams alive. One weary engineer perfectly summarized the nightmare, noting that while the generated pull requests appear syntactically flawless, the underlying business logic is pure hallucination. Ultimately, it consumes vastly more time to scrutinize the synthetic garbage, uncover the subtle edge cases it missed, and fix the mess than it would have taken to simply write the feature from scratch.
Bingo. You have successfully transformed your most expensive, highly skilled problem solvers into full-time proofreaders of toddler logic.
The economics get demonstrably worse the closer you look. Exhaustive data from GitClear analyzing how AI impacts code quality demonstrates a skyrocketing rate of code churn across repositories. What does that mean in Programmerese? It means this unverified code rots so quickly that it frequently gets reverted, abandoned, or completely rewritten within two weeks of creation. Furthermore, the comprehensive DORA 2023 report empirically confirms that heavily adopting AI assistance does not guarantee any meaningful increase in actual software delivery speed.
Because some overpaid Director of Innovation invariably saunters over to your cubicle, brandishing a glossy vendor pamphlet about generative paradigms, and begins lecturing you endlessly on how funneling all your source code through an LLM will magically make your enterprise agile enough to fire the entire QA department while shipping flawlessly orchestrated microservices at the speed of human thought.
Hogwash.
The Architecture Astronauts and management consultants aggressively pushing this workflow fundamentally misunderstand basic factory economics. They will confidently tell you that the pragmatic solution to the human bottleneck involves building complicated automated AI review algorithms to autonomously check the output of the AI generator algorithms. They want to stack automated cannons on top of automated cannons until the entire factory floor collapses entirely under the sheer crushing weight of its own synthetic garbage.
We write software to solve actual problems for actual human beings, and verifying that those problems are truly solved requires deep, exhausting human cognition. You cannot bypass the oven. You cannot cheat the underlying math of inventory management by simply turning the dial on the extruder up to eleven.
If you are using automated AI-PR bots to flood your repo, stop it. Just stop. Turn off the auto-PR bots today. Stop measuring lines of code, burn your velocity dashboards, and start measuring shipped, verified software. Everything else is wet dough.