The Disposable Code Dilemma: The Hidden Cost of Ephemeral Scripts

AI has made a peculiar kind of software almost free.

Need to rename ten thousand files? Generate a script.
Need to transform a database export? Generate another.
Need to scrape a page, reconcile two APIs, patch an awkward deployment problem, or automate something nobody expects to do twice?

Describe it. Run it. Discard it.

For many jobs, this is wonderful.

The problem begins when software that was supposed to disappear quietly refuses to die.

Someone keeps the script.
Someone else modifies it.
A cron job begins depending on it.
Three months later it has credentials, configuration files, two undocumented environment variables and a name like finalfixv7.py.

Temporary software has become infrastructure.

Generation cost is not ownership cost

AI dramatically reduces the cost of producing code.

But writing software has never been the entire cost of software.

Someone eventually has to understand what it does.
Someone has to know what happens when the input changes.
Someone has to notice when an API disappears.
Someone has to explain why a strange conditional exists eleven months after the conversation that created it has vanished.

Disposable code creates a seductive accounting illusion.
The generation cost approaches zero.
The maintenance cost arrives later.
And unlike generation, maintenance compounds.

Software carries memory

Well-designed software contains more than instructions.
It contains decisions.

Why this database?
Why this interface?
Why is this error handled differently?
Why was one apparently elegant approach deliberately avoided?

Architecture is partly a way of preserving institutional memory.
An ephemeral AI-generated script rarely contains that memory unless someone deliberately adds it.

It solves today's problem beautifully.
Tomorrow's engineer receives the solution without the reasoning.
That is where cheap software becomes expensive.

Not everything needs to become architecture

The answer is not to ban throwaway scripts.
A program genuinely used once can disappear without ceremony.

The useful distinction is not between AI-generated code and human-written code.
It is between temporary execution and persistent responsibility.

Before keeping an AI-generated script, perhaps teams need one additional question:
If this still exists six months from now, who will understand why?

Anything that survives that question deserves documentation, tests, ownership and architectural attention.

Because software becomes infrastructure surprisingly quickly.
AI has made code cheap enough to throw away.
It has not made understanding disposable.