A little utility that takes an afternoon to generate can sound wonderfully disposable. If it breaks tomorrow, ask the AI to make another one. There is less reason to spend weeks polishing code that may never run again.
That logic works right up to the moment someone needs the tool to keep working.
Take a script that rearranges a personal reading list. It reads a copy of a file, produces an output and leaves the original alone. If the result is nonsense, it can be discarded without losing the source material.
Now imagine a similarly small script updating a shared inventory every week. It has credentials, writes to a common database and contains a reconciliation rule nobody documented elsewhere. Replacing its code might be quick. Working out which records changed, preserving the rule and restoring reliable data could take much longer.
The code is only one thing you have to replace
In his October 2026 AI Engineer NYC talk, "Does Code Quality Even Matter?", Capital One Principal Software Engineer Max Kanat-Alexander describes a spectrum between disposable and durable software. He suggests considering four factors:
- Consequences: Could a failed run expose private information, corrupt records or make an irreversible change?
- Replacement: Could another version take over without losing the rules, data or evidence of work already completed?
- Dependencies: Do other people or systems rely on the program's output, schedule or availability?
- Maintenance: Will someone need to manage changing inputs, permissions, integrations or failures?
The reading-list script sits near the disposable end of that spectrum. A utility with serious consequences and many dependents sits much closer to the durable end. Kanat-Alexander cautions engineers to lean toward durability when they're unsure.
For the inventory script, a replacement would still need to know which records are authoritative, how reconciliation works and which changes the previous script made. If those details are missing, another source file doesn't restore the work.
Kanat-Alexander is making an engineering argument, illustrated with examples and proposals. The talk doesn't establish how widely disposable software will be used or demonstrate that the suggested practices were deployed at Capital One.
Making a tool disposable takes more than deleting its code
Kanat-Alexander also describes ways a team might make software easier to discard: isolate it, restrict access to data and systems, limit what depends on it, and keep a fallback. Those conditions have to be designed around the program; a temporary filename or a short prompt doesn't provide them.
In the inventory example, an experiment could read a copy of the source data and produce a proposed update for another process to validate. If the experiment fails, the existing workflow and authoritative records remain available. That's a different situation from giving an untested script direct permission to rewrite shared records.
In a real system, access restrictions, validation and the fallback would all need to work as intended. The talk does not verify a particular implementation.
NIST's Secure Software Development Framework describes choosing development practices with risks, requirements, feasibility and resources in mind. Singapore's Cyber Security Agency, in an April 2026 supply-chain advisory, discusses dependency controls, least privilege, secrets and the separation of development and production responsibilities. These sources address development risk; they don't demonstrate that any particular AI-generated utility is safe.
Temporary tools can become dependencies
A tool's role can change without its code becoming more complicated. Imagine a temporary dashboard that gets shared with colleagues. Its numbers begin appearing in weekly discussions, someone links to it in a document, and another process expects an export every Monday.
The dashboard may still be small, but removing it now affects other people's work. It has become something they depend on, regardless of whether anyone intended to maintain it indefinitely.
A shared tool can become easier to retire again if it has a reliable replacement, its data can be handed over and people no longer depend on the old version.
Disposability can change as the surrounding work changes; the label attached when the tool was created doesn't settle it.
The durable parts behind disposable software
Later in the talk, Kanat-Alexander discusses reducing the effort involved in careful engineering. Shared standards, reliable automated checks and common test infrastructure can make necessary safeguards less burdensome. He also notes that checks producing too many false alarms are harder to make unobtrusive.
An experimental component can remain relatively simple and replaceable when trusted systems protect authoritative data, control access, validate outputs and provide a working fallback. Those shared systems still need maintenance, though. Their rules, tests, permissions and recovery paths must remain reliable, and an automated check is not proof that every boundary is safe.
Whether software can be discarded depends on what it leaves behind: changes to important records, access to shared systems, people relying on its output and a way to recover when it fails.
AI may make another version easy to generate without resolving any of those obligations. The exit can still be expensive.
// End of transmission. Leave a way out — ZYANE
