From Scratch: The Case for Peeling the Veneer

In 2009, a British designer named Thomas Thwaites set out to build a commercial toaster from scratch. Not to assemble one from a kit, but to smelt iron ore in a chimney, refine crude oil into plastic resin, and draw copper wire from scrap metal. Nine months and over a thousand pounds later, he produced a grotesque, melted contraption that functioned for five seconds before destroying its own element.

Thwaites was not trying to become a competitive appliance manufacturer. He was demonstrating a fundamental condition of modernity: human beings now live surrounded by artefacts whose origins they can neither comprehend nor replicate.

Civilisation advances by extending the number of important operations we can perform without thinking about them. But in doing so, we have built a world of impenetrable veneers.

The furniture of our minds

Strip the white melamine coating from an IKEA desk and you do not find wood; you find compressed shavings held together by urea-formaldehyde resin. Trace the shavings backward and you do not find a forest; you find an industrial timber plantation, synthetic fertiliser supply chains, and bulk shipping logistics.

What appears to be a solitary domestic object is in fact the temporary intersection of a thousand global contracts.

In the physical realm, this abstraction is merely humbling. In the digital world, it has become dangerous.

When a software engineer types a query into a browser, the request cascades through dozens of distinct layers of abstraction: DOM events, JavaScript runtimes, virtual memory managers, TCP/IP handshakes, operating system kernels, bootloaders, and microcode executing on silicon switches etched at nanometre precision.

Every layer was designed by brilliant minds to liberate the next generation from having to understand what lies beneath. But abstraction is a Faustian bargain. When you cannot see the layers below, you mistake the interface for reality.

The illusion of software competence

For twenty years, tech culture celebrated “plug-and-play” agility. We built businesses out of API calls and open-source libraries stitched together with digital duct tape. In an era of stability, this was efficient. In an era of generative AI, it is fatal.

When large language models can generate functional frontend code from a casual prompt, the developer who understands only the top layer of the stack is obsolete. Anyone can invoke an API; anyone can copy an interface. The competitive advantage of the next decade belongs to those who understand the primitives: how compute actually moves, where latency originates, how state is preserved, and why systems fail at their boundaries.

Understanding the wheel requires the discipline of re-inventing it—not out of vanity, but out of necessity.

Peeling the onion

To learn “from scratch” is not an antiquarian hobby. It is an act of intellectual self-defence.

It means resisting the temptation to accept the packaged framework, the vendor solution, and the convenient abstraction. It means asking what electrical switches are doing beneath the operating system, what economic incentives lurk behind standard protocols, and what human intentions are codified into our tools.

This blog is dedicated to that excavation. We will peel back the surface layer by layer—across code, physical hardware, and economic institutions. In an age of synthetic abundance, real power belongs to those who know how things are built from the dirt.