Exhaust-Oriented Programming and the Death of the Artisan Commit

Git is a dead man walking, an obsolete, decomposing corpse of a paradigm currently being propped up by desperate corporate PR teams who absolutely refuse to admit that their underlying human-centric data model is being violently crushed under the sheer, incomprehensible industrial scale of AI-generated code. Yesterday I saw a link to Ask HN showcasing a thousand screaming, hyper-ventilating commenters losing their collective minds over the third major GitHub outage this week, with everyone furiously debating database sharding architectures and Vitess cluster configurations while acting as if this is just some routine, run-of-the-mill devops hiccup that can be solved with a bigger instance size. And folks, they are completely missing the actual macro trend here. Because trying to fix Git's scaling issues right now is exactly like running a boutique, hipster artisan chocolate shop and frantically trying to oil your little brass cash register while a literal freight train carrying ten million tons of raw, unrefined cacao violently derails and blasts straight through your front window. You've got guys in canvas aprons with tiny little tweezers trying to perfectly place a single sea-salt crystal on a truffle, and meanwhile, the entire structural foundation of the building is being vaporized by a Mach 3 tsunami of raw caloric material.

You can sit around and credulously read the sanitized corporate excuses all day, perusing the August availability report blaming internal routing infrastructure and degraded database health and whatever other mathematically meaningless, soothing euphemisms they routinely spin up to keep their enterprise clients from simultaneously voiding their bowels. Look, I'm not sitting here waving around a fancy distributed-systems PhD. I'm just a spectator watching the absolute carnage unfold from the sidelines, entirely, toddler-in-a-cockpit clueless as to how the physical database shards are actually routed. But doing the basic arithmetic on LLM token-burn velocity tells a much darker, much more terminal story. Look at the sheer, completely unmanageable volume dumped into the Octoverse 2024 report showcasing 5.2 billion total contributions and a staggering 98% year-over-year spike in generative AI projects. And those numbers are already completely obsolete the second they get published. We have entirely abandoned the quaint, historical era of human typing and blindly accelerated headfirst into Exhaust-Oriented Programming, a fundamentally terrifying new reality where autonomous agent swarms bypass the careful crafting of business logic, choosing instead to vomit entire monolithic codebases per second as an industrial byproduct of their stochastic guessing process. Free from biological constraints like sleep or bathroom breaks, and completely unconcerned with the elegant symmetry of their abstractions, these agents relentlessly burn tokens and emit deeply nested, violently unreadable ASTs.

We are all watching this happen right now. Picture the average developer sitting on their couch on a Saturday, trying to use an LLM agent to scaffold a stupid little Go service to scrape some API—just a dumb weekend toy that should take an hour. They fire up Cursor, feed it a vague, wildly imprecise prompt, and hit enter. And then they watch in absolute, slack-jawed horror as this agentic swarm essentially blacks out, hijacks the editor, and generates seventy-five individual files across eight subdirectories in about four seconds. It hallucinates an entire gRPC layer, a custom Redis caching strategy, and some ungodly Docker compose setup nobody asked for. And then—because the tooling is still desperately trying to maintain the illusion of human involvement—it proudly stages a massive Git commit for this 14,000-line diff, appending a completely generic, automated commit summary about updating basic middleware functionalities.

I mean, what is a team supposed to do with that? If a normal, sane human reviewer on a Monday morning was handed a 14,000-line PR by some junior engineer named Chad that reinvented the entire networking stack while pretending to fix a typo in the auth flow, Chad would be physically removed from the building by security. Lacking any of Chad's hard-won institutional context, the autonomous swarm simply forcefully dumps the payload onto your lap. And Git, bless its heart, dutifully tries to hash every single one of those garbage tokens into a pristine Merkle tree, treating this industrial-scale slurry like it is a sacred manuscript written by monks. It is absolute madness.

Reading through these modern, heavily sanitized post-mortems inevitably highlights the absolute absurdity of our tooling history, specifically the primordial soup of 1990s version control, a dark age that perfectly illustrates how architectural paradigms always shatter violently whenever development velocity dramatically outgrows the underlying mental model of the tooling. Just look over the IBM Rational ClearCase documentation on configuration specs and you can feel a cold sweat break out just thinking about the absolute, unrelenting horror of Versioned Object Bases, or VOBs as the unfortunate, deeply traumatized souls trapped in that purgatory called them. Back then, simply trying to collaborate on a software team meant dealing with a global-locking file system so breathtakingly punitive and comically hostile to parallel human effort that encountering a locked binary file during a critical integration phase literally made people want to drink bleach. Engineers would sit there staring blankly at their terminals, completely paralyzed because some chump in another time zone checked out a core library file and went on a two-week vacation to Cabo, freezing the entire multi-million-dollar software pipeline in amber while management screamed about slipped milestones and threatened to fire the whole department. (I mean, I guess it was a fantastic era if you were a highly paid integration consultant charging premium rates to manually untangle symlinks, but for the actual rank-and-file working stiffs trying to ship software, it was basically medieval torture.) The overarching lesson from the spectacular, agonizing collapse of ClearCase is that when your data model mathematically enforces a bottleneck that the surrounding ecosystem has already completely bypassed—whether that bottleneck is a globally locked VOB in 1998 or a manually reviewed pull request in 2025—the ecosystem rarely waits politely for you to refactor your legacy tooling. The surrounding reality just routes around the damage and utterly crushes the obsolete paradigm under a tidal wave of new throughput.

So let's go back to our artisanal chocolate shop and really look at what Git fundamentally is at its core, because Linus Torvalds built an incredibly elegant, profoundly beautiful tool for a world that simply no longer exists. Git was explicitly engineered from the ground up for the artisanal era of human-crafted commits, a boutique, heavily romanticized workflow where bearded developers sat in dim lighting meticulously typing out bespoke, artisanal little SHA-1 truffles, packaging each one with a thoughtful, multi-paragraph commit message detailing the philosophical why of a specific class refactor before gently placing it in the pristine display case of the main branch. In this artisanal universe, a commit represents a discrete, logically bounded unit of human cognition, a carefully curated snapshot of intent that other humans can peacefully review while sipping their pour-over coffees and debating variable naming conventions in the pull request comments. You know exactly what I am talking about—that satisfying little dopamine hit when you squash your branch and craft the perfect commit summary. But Exhaust-Oriented Programming entirely rejects your artisanal process and your beautiful pour-over coffee. Circumventing the very concept of discrete human commits or clean diffs, an LLM agent swarm simply regurgitates millions of probabilistic syntax tokens across thousands of files simultaneously in an unrelenting, deafening geyser of automated garbage. It is an industrial machine that treats source code as a totally disposable, intermediate compilation target, churning out fifty wildly divergent implementations of a feature branch in the time it takes to type an initialization command. The freight train of raw cacao has officially arrived, and it is mercilessly burying the screaming chocolatier under a 10,000-ton avalanche of generated boilerplate while the cash register explodes into a shower of brass shrapnel.

You simply cannot mathematically scale a boutique chocolate shop to successfully ingest and cleanly process a runaway freight train of raw industrial output, because the foundational SHA-1 tree model of Git is fundamentally and inextricably incompatible with modern LLM output speeds. Anyone looking at the latest latency graphs is basically howling over the absolute absurdity of treating this like a minor scaling hiccup when we are quite clearly witnessing the catastrophic, structural failure of a core data structure. Mapping distributed, high-frequency AI output against a fundamentally immutable Directed Acyclic Graph creates an absolute, unmitigated mountain of digital manure, especially when you factor in the sheer parameterized complexity of resolving constant merge conflicts across deeply nested ASTs using a backend model that still stubbornly relies on human line-diffs. It is completely busted. The tooling is fundamentally assuming that a human being is going to sit down, look at a three-way merge screen (probably in some clunky, violently outdated desktop GUI, because God forbid anyone just use Emacs for everything), and thoughtfully decide which block of text survives. Which is absolute lunacy when the text was generated thirty milliseconds ago by an agent that has already moved on to refactoring the entire networking layer using some terrifying, hallucinated implementation of Polymorphic Inline Caching. When you have a hundred autonomous agents aggressively mutating the codebase twelve times a second, trying to maintain a coherent Merkle tree of human-readable commits is about as productive as trying to catch a high-pressure firehose with a heavily damaged butterfly net. Consequently, it is a mathematical certainty that within three years, the entire software industry will abandon manual version control snapshots entirely. We will inevitably shift to continuous vector-state synchronization, a model where the system mathematically maps the semantic intent of the continuous code stream rather than fruitlessly trying to freeze an unmanageable tsunami of tokens into cute little human history points.

I'm sure half of you are already frothing at the mouth to explain why your perfectly tuned CI/CD pipeline makes Git immortal, or how I just don't understand Merkle trees. Save it for the comments, you have a lot of rust to knock off. Let the flames begin. I'm going to bed.