Joel Spolsky

In the [YOU] on AI Field Guide

The cycle that began with [YOU] on AI celebrates the collapse of the imagination-to-artifact ratio: the developer describes what the software should do in natural language and receives working implementation in hours. Spolsky’s law does not dispute this liberation. It predicts what comes after. If every non-trivial abstraction leaks, and if the severity of the leak is proportional to the gap between the abstraction level and the underlying complexity, then AI-generated code will produce the most consequential leaks in computing history—not because AI is worse than previous abstractions but because it is better, because the gap it spans is every layer deep rather than one.

The cycle identifies tacit knowledge—the understanding that only accumulates through productive failure, the feel for a codebase that the senior engineer described as the way a doctor feels a pulse—as the thing the AI transition most threatens. Spolsky’s framework names the mechanism precisely. The developer who describes a function and receives an implementation has not debugged the function. She has not written the first version that did not work, examined why, corrected it, and discovered through that specific failure the non-obvious technique that the obvious approach could not reach. Each of those experiences deposits a stratum. The strata are thin; individually, almost invisible. But thousands of them, accumulated over years, produce the diagnostic competence that leaks demand: the ability to look at a failing system and know, before analysis, approximately where the problem lives.

Spolsky also stands in the cycle as the figure who built and then watched the erosion of the most important shared diagnostic institution the software profession ever created. Stack Overflow—the platform he co-founded with Jeff Atwood in 2008—was a collective response to leaky abstractions: when developers encountered failures they could not explain, they went to Stack Overflow and received diagnoses from practitioners who had encountered the same failures through direct experience. The platform’s 32.5% decline in new questions in a single year (March 2023 to March 2024), as developers migrated to AI for answers, is the recursive irony of his career: the diagnostic memory the profession accumulated over fifteen years is being absorbed into the very abstraction whose failures will most need that memory to diagnose.

Origin

Spolsky’s intellectual formation was at the intersection of computer science and a disposition—equally rare in the field—for clear prose about hard things. His years at Microsoft, where he worked as a program manager on Excel and contributed to the early specifications for Visual Basic for Applications, gave him direct experience of the gap between a system’s designed behavior and its actual behavior under production conditions. The gap is where the law was born: not as an abstract principle but as the accumulated scar tissue of someone who had been wrong, in specific ways, about specific systems, and had paid the cost of the wrongness.

His blog, Joel on Software, launched in 2000, became one of the most widely read documents in software engineering within a few years. The posts were remarkable for their combination of technical precision and moral seriousness—a refusal to separate the question of how software works from the question of what kind of work software development is and what it demands of the people who do it. “The Law of Leaky Abstractions,” published in November 2002, distilled into a single formulation a pattern that every experienced developer recognizes but that no one had previously named with sufficient generality. The essay entered textbooks, was taught in universities, and became shorthand across the profession within a generation. When Spolsky co-founded Stack Overflow in 2008, he created the institutional infrastructure that would allow the law’s implications—what to do when the leak occurs and understanding is needed—to be addressed collectively rather than individually. The platform’s subsequent decline is the second act of the same story.

His later essay “Artisanal Coding”—the argument that AI-generated code, for all its fluency, lacks the elegance, efficiency, and intentionality that only a skilled human developer can provide—extended the law into the era it had been waiting to describe. Artisanal coding is Spolsky’s term for the practice of writing code that a human engineer has thought through, not just generated—code that documents its own decisions, handles its own edge cases, and can be modified by someone who understands why it is the way it is.

Key Ideas

The Law of Leaky Abstractions. Every layer of technology designed to hide complexity will, at unpredictable moments, fail to hide it. When the failure occurs, the user must understand the very complexity the layer was designed to conceal. TCP hides network unreliability until latency spikes; the developer must then understand routing topology and packet loss. SQL hides storage mechanics until a query runs slowly; the developer must then understand execution plans and index strategies. AI-generated code hides every layer simultaneously: the law applies with proportionally greater force because the gap is proportionally greater. Concealment is not elimination. Complexity that is hidden is not complexity that has been resolved.

The ultimate abstraction. Previous abstractions hid one layer from the layer above it. Assembly hid machine code from C. SQL hid storage from application logic. Frameworks hid HTTP from web developers. AI-generated code hides the entire staircase. The developer operating at the level of natural language intention is further from the executing code than any developer has ever been from the system she depends on. When the elevator stops between floors, the developer is stranded in a shaft she has never seen, surrounded by machinery she does not understand, with no staircase access because she never knew the staircase existed. The developer who climbed the stairs may be slower; she is also the one who knows the way down.

The diagnostic gap. Diagnostic competence—the ability to look at a failing system and know where the problem lives before analysis—is built through the specific experience of being wrong, at the implementation level, repeatedly, over years. AI-mediated development eliminates the experiences that build that competence. The developer who describes a function and receives an implementation has not gone through the productive failure that deposits the strata. A 2025 academic paper applied the law directly to this dynamic: “Because the simplified interfaces of AI will inevitably fail or ‘leak,’ practitioners who do not understand the underlying principles will be unable to diagnose or solve critical problems.” The diagnostic gap compounds generationally.

The integration leak. The most consequential class of failure in AI-generated systems is the integration leak: not a bug in any single component but a failure in the interaction between components generated in separate contexts under separate assumptions. The authentication service assumes sessions are stored in memory; the load balancer distributes requests across instances; the system logs out authenticated users because the two components’ assumptions were never negotiated. In human-designed systems, there was a conversation to reconstruct. In AI-generated systems, the assumptions are embedded in the code, implicit, and discoverable only through the failure they produce.

Artisanal coding. Spolsky’s term for the practice that the law implies is non-negotiable: code written by a human engineer who has thought through not just what the code does but why it is structured the way it is, which decisions are load-bearing and which are cosmetic, how it will behave at scale, and how it will need to evolve. Artisanal coding is not rejection of AI tools; it is the standard against which AI-generated code must be evaluated and, when necessary, corrected. The developer who treats AI output as a first draft produced by a talented but unreliable collaborator—who reviews, understands, and owns the result—is practicing artisanal coding in the AI era. She is slower. She is also the one who will be standing, still functional, when the abstraction leaks.