Business Pill 17 · Software you can throw away
When software becomes cheap enough to throw away, the logic of building it reverses. The value moves from the code to what has to stay true.
A short explainer video. The numbers in it are round numbers for illustration.
Software Has Always Been Expensive
Software has always been expensive to write, so we wrote it once and used it for years. One program had to serve thousands of people to justify its cost. Everyone got the same screens and the same buttons.
What AI Changes
AI changes the first step. A model can now write a working program in minutes, for almost nothing. And when writing is nearly free, the logic reverses. You no longer need thousands of users. One user and one task is enough.
These are programs made for the moment, used and thrown away. This is discardable software. It is more like a note you jot down than a book you publish.
A Worked Example
The video uses round numbers. A custom tool takes a developer two weeks and costs $10,000. It must be used 1,000 times to be worth it. Spread over those uses, that is $10 each, which is this publication’s arithmetic on the example.
The same tool, generated in a minute, costs about a dollar. It can be used once and still be worth it.

What Still Has to Last
Not everything becomes discardable. The data must last. The rules of the business must last. And the checks that tell you the program did the right thing must last. The code in between can come and go.
So the value moves away from the code itself, which anyone can now generate, toward what stays the same: the record of what happened and the definition of what is correct.
Three Questions to Ask
- Which of our software has to be permanent?
- Which could be generated when it is needed?
- What has to stay true either way?
See It in the News
Karpathy’s Case for Discardable Software. A news piece on the same idea from a practitioner’s argument.
How This Concept Connects
Layer 4 of 8 · Agents & Workflows, on the Business Engineer Concept Map
- Discardable Software builds on AI Evaluation as Acceptance Test. The checks that tell you the program did the right thing must last even when the code is thrown away.
- Discardable Software contrasts with Operating Leverage. Software once had to serve thousands of users to justify its cost; near-free code reverses that build-once logic.
- Discardable Software builds on System of Record (lesson unlocks soon). When code becomes disposable, value moves to what must last: the data and business rules kept in one place.
- Verification Cost (lesson unlocks soon) constrains Discardable Software. Code that is cheap to make is not cheap to check, so checking caps how freely throwaway software can be used.
- Generative UI (lesson unlocks soon) is an example of Discardable Software. A screen the model builds for one question, every time, is software made to be used once, the idea of the discardable software lesson.
Great SaaS Bifurcation
Cheap code reshapes software economics.Business Engineer framework
From SaaS to AGaaS
From durable software products to agent-delivered work.
Get the full Concept Map as a free poster.
More Business Pills
- The Memory Wall: Why a Faster AI Chip Is Not Faster AI
- Tokens per Watt: What an AI Data Centre Actually Produces
- Why AI Can’t Be Both Instant and Cheap: Latency vs Throughput
- The Model and the Harness: Why Same-Model Products Differ
- Context, Not Capability: Why a Smart AI Model Gives Poor Answers
- Human in the Loop vs Human on the Loop: Supervising AI Agents
- The AI Audit Problem: When Making Work Is Cheaper Than Checking It
- AI Evaluation as Acceptance Test: How to Know It’s Good Enough
- Extensibility Is Control: Who Holds the Power in an AI Product
- RLHF Explained: How an AI Model Learns What People Prefer
- Pretraining Explained: How an AI Model Learns Before Anyone Teaches It
- Fine-Tuning Explained: How to Adapt a General AI Model to One Job
- Tokens Explained: The Unit AI Reads, Writes and Bills In
- Embeddings Explained: How a Machine Compares Meaning
- RAG Explained: How a Model Answers From Your Documents
- AI Hallucination Explained: Why Models State False Things
- Distillation Explained: How a Small Model Learns From a Large One
- Reasoning Models Explained: What Changes When AI Thinks First
- Tool Use Explained: How an AI Model Goes From Text to Action
- Capex and Depreciation Explained: Why Chip Lifetime Drives AI Profits
- Run-Rate Revenue Explained: What an AI Company’s Number Means
- Backlog Explained: Revenue That Is Signed but Not Yet Earned
- Switching Costs Explained: Why It Is Hard to Leave an AI Supplier
- Temperature Explained: The Dial That Sets How Predictable an AI Model Is
- Guardrails Explained: Rules Enforced Around an AI Model, Not Inside It
- Benchmarks Explained: Why a Test Score Is Not Your Own Result
- Agent Memory Explained: How an AI Assistant Remembers You Between Chats
- MCP Explained: The Shared Plug That Connects AI Models to Tools
- Quantization Explained: How a Large AI Model Is Shrunk to Fit
- Parameters Explained: Where an AI Model’s Knowledge Lives
- Scaling Laws Explained: Why AI Labs Keep Building Bigger
- Synthetic Data Explained: When a Model Writes Its Own Training Examples
- Transformers and Attention Explained: How AI Reads Every Word at Once







