Cory Doctorow doesn't just argue for better coding practices; he makes a startling claim about the erosion of human intuition in the digital age. He suggests that our relentless drive for abstraction has stripped us of the ability to understand, repair, and truly own the tools we rely on every day. In an era where "vibe coding" promises instant results without understanding, this piece serves as a vital corrective, warning that convenience comes at the cost of legibility.
The Lost Art of Fingertip Feeling
Doctorow anchors his argument in personal history, recalling how he first grasped computation not through screens, but through cardboard tokens and paper memory cells. He describes the CARDiac, a 1968 Bell Labs teaching tool, as the moment computing "snapped into place" for him. "All an electronic computer does is repeat these crude mechanical operations, millions of times per second, using microscopic transistors," Doctorow writes, noting that while we can't see this dance today, we must be able to imagine it.
This framing is powerful because it grounds high-level software concepts in physical reality. By invoking the German term Fingerspitzengefühl—literally "fingertip feeling"—Doctorow argues that true mastery requires a tactile connection to the machinery beneath the surface. He recalls typing BASIC programs line-by-line from magazines, a slow process that forced him to invent his own debugging tools. "Figuring out the need for a debugger and then rolling my own (crude, inefficient) one made all debuggers more legible to me," he explains.
The argument here is that struggle breeds understanding. When we bypass the friction of learning—when we skip the cardboard tokens and go straight to the black box—we lose the mental models necessary for innovation. Critics might argue that modern developers are too busy building complex systems to waste time on toy computers, but Doctorow counters that without this foundational intuition, we become helpless when those complex systems inevitably break.
No matter how many levels of abstraction sit between me and the nanoscale transistors ranked in their billions beneath my fingertips, they are all undertaking those familiar operations I painstakingly performed on my child's desk all those years ago.
Peeling Back the Membrane
The piece then pivots to the concept of "legibility," defining it as the ability to move up and down layers of abstraction to inspect internals when necessary. Doctorow draws a parallel between the early web's "View Source" feature and his childhood experience with BASIC listings, describing the browser function as "a velcro tab for the membrane that separated rendered web pages from their underlying instructions."
He suggests that this affordance was crucial for a generation of developers who learned by ripping apart other people's code. "I could even laboriously trace the operations of that program using my toy debugger," Doctorow notes, emphasizing that the ability to flip between effects and instructions is what creates true competence. He extends this logic to modern tools like Minecraft mods or macro recorders, arguing that these are simply different entry points into the same funnel of understanding.
This perspective challenges the current trend toward opaque, AI-generated code. While high-level abstractions are necessary for scale, Doctorow warns that they become dangerous when users lose the ability to "decap the sealed package and inspect and manipulate its internals directly." The loss of this capability means we are building a civilization where fewer people understand how their digital infrastructure actually works.
The Vibe Coding Trap
Doctorow addresses the rise of "vibe coding"—creating software through natural language prompts or automated tools without understanding the underlying logic. He distinguishes between production-grade code and "personal software," acknowledging that for individual use, the lack of maintenance or deep understanding is a fair trade-off. "There's nothing wrong with code that solves your problem, even if you don't know how that code works," he concedes.
However, he warns that this approach creates a fragile ecosystem. When automated code fails, users who have never learned to open the membrane are left stranded. Doctorow frames modern automation not as an endpoint, but as a gateway: "Automated code — whether from an LLM, View Source, Stack Overflow, or a macro recorder — is the top of a funnel."
The strength of this argument lies in its optimism about human potential. He believes that even if most people stop at the surface level, having more people at the top of the funnel increases the odds that some will slip further down to become skilled artisans who can repair and improve the system. "Every time you do [open the membrane], you have a better chance of making a realization that improves your grasp on the whole system," he writes.
With great abstraction comes great power comes great responsibility comes great loss of fidelity.
A counterargument worth considering is whether the sheer complexity of modern software stacks makes this "fingertip feeling" impossible to achieve for anyone outside of specialized hardware engineers. Perhaps the gap between the cardboard token and the billion-transistor chip has become too wide to bridge with nostalgia alone. Yet, Doctorow's insistence on maintaining a mental model of the underlying physics remains a compelling defense against total dependency on opaque systems.
Bottom Line
Doctorow's most potent contribution is reframing "legibility" not as an academic exercise, but as a survival skill for the digital age. The piece's greatest vulnerability is its reliance on individual curiosity to solve systemic opacity; without structural changes in how software is taught and built, the "funnel" may remain too narrow to sustain true understanding. Readers should watch for how the next generation of AI tools either preserves or destroys this crucial ability to inspect the machinery beneath the membrane.