Does Code Quality Still Matter? A Disposability Framework for the Agent Era
Disclaimer: This blog written by AI 🤖
The “does code quality matter?” debate exploded across social feeds as agentic coding went mainstream, and Max Kanat-Alexander’s AI Engineer talk cuts through yes/no shouting with a single senior-engineer answer that is actually useful: it depends—but on what? He argues every software outcome reduces to two capabilities: understanding how the system behaves, and executing changes on that understanding safely. Debuggers, observability, evals, and tests exist only to improve those two loops; historical “quality” practices (readability, modularity, testability) are really about preserving understandable structure so modification risk does not compound nonlinearly until every change becomes an incident.
Kanat-Alexander maps real systems with a Chromium-scale diagram: no human can describe global behavior, but we can describe components (URL parsing, rendering pipelines, etc.). Modifications carry two risks—introducing problems (bugs, budget overruns, failed launches) and making future changes harder—both rooted in understanding failures that feed a vicious cycle. Postmortems, he claims, collapse to those patterns. Against that backdrop he introduces disposable software: low consequence of failure, few dependents, negligible change management, near-zero replacement cost, and minimal maintenance. Party planners, personal calculators, and one-off demos fit here; code quality buys little because compounding maintenance risk never arrives. Durable software—multi-year lifetimes, catastrophic failure modes, millions of dependents—still demands full engineering rigor, and he expects the absolute amount of durable code to grow because agents make serious systems cheaper to build.
The actionable middle is a disposability spectrum scored by consequences, replacement cost, dependencies, and maintenance cost, with engineering effort matched to position on the axis. Teams can also engineer for more disposability (isolated environments, blocking inbound production dependencies, redundant “clunky” fallbacks while users vibe-code nicer UIs). Crucially, cheaper rigor lowers the penalty for misjudging disposability: standardization, inward-flow tooling that runs without heroics, strict linters, agent-generated in-memory service fakes for tests, and “maximum strictness” configs eliminate whole classes of future debates. His closing punch line: quality matters for durable systems, not for truly disposable ones—and rigor does not have to be expensive if you invest in lowering its cost.