Zero Marginal Logic
As AI turns software logic into a disposable commodity, the SaaS middle collapses, shifting all value to raw compute and consumer aggregators.
By Marcus Vale
Sparked by Karpathy’s Pelican · discussion
Last week, former OpenAI director Andrej Karpathy posted a video of an AI-generated 3D demo, rendering a complex virtual scene constructed entirely by a large language model in a single pass. The internet reaction, particularly among developers, was swift and overwhelmingly hostile. As one commenter in the Hacker News reaction thread summarized the output, it was effectively unmaintainable slop.
The critics are absolutely right about the technicals: the code is an unmitigated mess. The architecture is brittle, the variables are poorly named, and attempting to debug or refactor it over a multi-year product cycle would be an operational nightmare. That, though, is exactly the rub: the developer consensus has correctly diagnosed the technical reality of the output while missing the fundamental economics completely.
To understand the economic shift underway, you have to walk the traditional value chain of software. Historically, code has always operated as a high-fixed-cost capital asset. The primary input for creating software logic is human engineering time, and human engineering time is exceptionally expensive. As a baseline metric, the average base salary of a U.S. software engineer currently sits at $124,134. Once equity compensation, health benefits, and senior management overhead are factored in, the fully loaded cost of a single mid-level developer routinely exceeds a quarter of a million dollars a year.
Because the fixed cost of writing logic is so astronomically high, the business of software necessitates a deep, abiding obsession with maintainability. Instead of discarding a capital asset that cost hundreds of thousands of dollars to build, rational businesses document it, refactor it, and painstakingly extend it over decades. We even invented a specific financial metaphor—technical debt—to describe the deferred cost of keeping these assets alive. This structural dynamic created massive economic moats in the middle of the technology stack. Independent SaaS businesses, specialized middleware platforms, and proprietary internal enterprise tools captured immense margin precisely because assembling and sustaining reliable logic was inherently hard and incredibly expensive. Far from being merely an aesthetic preference for elegant engineering, maintainability served as a strict structural requirement dictated by exorbitant fixed costs.
In 2015, Ben Thompson laid out a framework for understanding the internet era in Aggregation Theory. The core argument was that the internet's fundamental disruption was eliminating the marginal cost of distribution. As the marginal cost of sending data to one more user fell to zero, the companies that aggregated consumer demand captured all the value. More recently, the conversation has naturally shifted to the onset of zero marginal content, where generative AI makes the creation of text, audio, and images practically free.
What Karpathy’s 3D demo actually represents is the surgical extension of that framework into the very core of software itself: Zero Marginal Logic.
When you can ping an API from a state-of-the-art foundation model like Claude 3.5 Sonnet for $3 per million input tokens and $15 per million output tokens, the foundational economics of software invert. Generating ten thousand lines of functional code costs a business a matter of cents. Rather than persisting as a high-fixed-cost capital asset requiring human stewardship over years, logic rapidly degrades into a disposable consumable. The developers critiquing the generated 3D scene are operating under the assumption that someone will eventually need to read and maintain it. But when the marginal cost of generating an entire feature from scratch is a fraction of a penny — orders of magnitude cheaper than the hourly rate of a salaried engineer attempting to comprehend it — maintainability becomes economically obsolete.
Just as repairing a disposable paper cup is economically irrational, maintaining Zero Marginal Logic defies basic financial sense. When a feature breaks, or when a user decides they want a completely different dashboard layout, filing a Jira ticket to refactor the codebase becomes entirely unnecessary compared to simply generating the application state from scratch.
If the middle layer of logic and software assembly hits a marginal cost of zero, the immediate strategic question is where the margin actually goes. Picture the legacy software stack as a vertical value chain, and compare it to the emerging AI epoch stack. The structural hollowing out is glaringly obvious.
At the bottom of the stack sits Cloud and Compute, which houses the foundation models. Far from being zero marginal cost, this layer is immensely capital intensive. Training and running frontier models requires staggering expenditures in specialized silicon, data center real estate, and energy. This is a structural reality explicitly acknowledged in the OpenAI Charter, which commits to marshaling substantial resources to fulfill its artificial general intelligence mission. This base layer requires massive fixed-cost capital investments, meaning only a handful of hyperscalers and highly funded labs can compete.
Above that sits the newly hollowed-out middle: the undifferentiated zone of Zero Marginal Logic. In the legacy stack, this was the domain of human developers writing B2B SaaS applications, middleware routing data between disparate systems, and bespoke API integrations. Now, it is a frictionless passthrough. Value inevitably flees from a layer where the product can be generated on the fly for pennies; there is no sustainable margin to extract from a completely disposable asset.
Directly at the top sits Consumer Demand and Aggregation. The companies that own the user relationship, aggregate demand, and dictate the interface will simply pull disposable logic from the bottom layer on demand, bypassing the traditional software vendors entirely.
Consider a specialized mid-market SaaS company — an inventory management platform for independent auto-parts retailers, for instance. For the last fifteen years, this company's entire moat was the fixed cost of its codebase. They wrote the complex logic required to connect inventory databases, format purchase orders, and present a clean user interface. The value was embedded in the code itself, protected by the sheer expense a competitor would incur attempting to replicate it.
In an era of Zero Marginal Logic, that proprietary codebase transforms from a structural moat into deadweight loss within the value chain, destined to be bypassed by whichever aggregator commands the end user's attention. Instead of relying on a third-party SaaS vendor to provide a specialized workflow tool, a modern platform—whether that is an enterprise chat aggregator like Slack or a dominant operating system like iOS—can seamlessly generate the required logic for that specific auto-parts retailer in real time, discarding the code when the session ends and recreating it tomorrow.
To put it another way, owning demand will ultimately trump owning disposable logic. The independent developer tooling companies and mid-tier software vendors are fighting to maintain their margin in a node of the value chain where the fundamental economics have just evaporated. The logic layer — previously the beating heart of software margin — is collapsing into a commodity feature of the foundation models, leaving value to accrue exclusively to those supplying the raw compute or those capturing the end consumer.
This brings us back to the developers on Hacker News, furiously defending the principles of clean architecture against an avalanche of AI generation. Their frustration is entirely understandable; their deeply valuable skills are being commoditized by a system that produces technically inferior, unreadable code. Yet, they are fighting the last war. The structure of the market is set: profits will inevitably pool at the capital-intensive bottom and the aggregator top, leaving nothing for the disposable middle. When exactly the last SaaS company realizes this, though, is another question entirely: as always, it depends, and even in tech, epochs take a decade to turn.