Disposable vs Durable: When Code Quality Still Matters with AI Agents
AI coding agents changed the volume of code teams can produce. They did not remove the need for judgment about which code deserves investment.
Max Kanat-Alexander’s recent keynote at AI Engineer NYC 2026 gives a clean decision rule: code quality always existed for two reasons — understanding a system and safely changing it. Everything else (structure, tests, readability, review) is in service of those two goals.
When those two goals stop mattering, quality stops mattering.
Disposable software is now the default volume
Kanat-Alexander describes a category that has always existed but is about to become vastly more common: disposable software.
It has:
- Minimal or zero consequences if it fails
- Few (or no) human or system dependents
- Near-zero cost to throw away and regenerate
- Essentially no long-term maintenance burden
In that world the cumulative risks that quality practices were designed to prevent largely disappear. You can treat the output as temporary. Agents make this category practical at scale because regeneration is cheap.
Durable software is the opposite: long-lived, many dependents, real production consequences, high cost of lost understanding. For that software, quality still matters — and in some ways matters more, because the cost of opacity compounds non-linearly.
The practical question for teams is no longer “does quality matter?” It is “which parts of our system are disposable, and which are durable?”
Watch the keynote: Does Code Quality Still Matter? — Max Kanat-Alexander
Software factories fit the distinction
Recent talks on agentic workflows point the same direction.
David Ondrej’s framing of software factories (collections of agent loops with triggers, skills, checks, and human gates) is most useful when the factory is allowed to produce a lot of disposable intermediate work while protecting the durable core. Scheduled checks, bug triage, exploratory prototypes, and one-off analysis can run with lighter standards. Architectural changes, shared libraries, and production control planes cannot.
Kerim Satirli (HashiCorp) describes treating agents more like a constrained CI/CD pipeline than a free junior engineer. Prompt rules are requests; hard constraints and deterministic checks are the real guardrails — especially on infrastructure that is durable by nature.
Carlos Kelkboom’s rule — throw away generated code the moment you do not understand it — is a direct application of the disposable/durable split. If you cannot explain it, it does not belong in the durable surface.
Practical rules that follow
- Classify before you generate. For any non-trivial piece of work, decide up front: expected lifespan, blast radius, number of dependents, replacement cost. Write it down.
- Keep a safety floor everywhere. Even disposable code should not leak credentials, open destructive operations without confirmation, or leave secrets in logs. Security and privacy are not optional just because the code is temporary.
- Concentrate rigor on the durable surface. Tests, ownership, observability, review, and clear structure belong on the parts that will still be there in a year and that other systems depend on.
- Make rigor cheap. Kanat-Alexander’s second lever is reducing the cost of doing the right thing: standards, in-workflow tooling, easy testing, and maximum strictness so the path of least resistance is the safe one. That keeps durable work from becoming a bottleneck.
- Design for disposability where it helps. Isolate experiments, keep coupling low, prefer regeneration over heroic maintenance of throwaway scripts, and avoid accidentally promoting disposable code into the durable core.
How this sits next to the bottleneck view
An earlier post covered how the bottleneck has moved from writing code to review, trust, and verification. The disposable/durable frame adds the missing classification: not every generated change deserves the same verification budget. Teams that treat everything as durable will drown in review. Teams that treat everything as disposable will accumulate opaque, high-risk systems.
The high-leverage skill is correctly sorting the two, then running agent factories that generate freely on the disposable side while protecting understanding and change safety on the durable side.
Sources: