What Swiss Watchmaking Taught Me About Software Quality

On a trip to Copenhagen I stood in front of a Patek Philippe pocket-watch movement made in 1889. Still running, 134 years later. What struck me wasn't that it kept time — plenty of cheap watches keep time. It was that you could open the caseback and see why it worked. Every wheel, every jewel, every spring was laid out so a watchmaker a century later could look in, understand the mechanism, and know precisely what to replace if it ever stopped.

Patek Philippe store @ Copenhagen.

That's the one idea from watchmaking that genuinely changed how I think about software, and it's not the obvious one. The obvious lesson is "precision" or "attention to detail" — true, but shallow, the kind of thing you nod at and forget. The deeper principle is inspectability: a great movement is designed so that someone who didn't build it can understand it. Function is table stakes. Legibility under the hood is the craft.

Most software is the exact opposite. We optimize relentlessly for function — does the feature work, does the test pass, did it ship — and treat the question of whether anyone can see why it works as a luxury for later. So we get systems that run beautifully right up until the night they don't, and then a team stares at a stack trace from a service nobody fully understands, trying to reverse-engineer a mechanism that was never built to be opened.

Built to be opened, or built to be replaced

Here's where the analogy earns its place, because it reveals a choice we usually make without noticing. When a watchmaker designs a movement, they assume someone will service it in fifty years. That assumption changes every decision: parts are accessible, tolerances are documented, the layout follows a logic a stranger can follow. The watch is built to be opened.

Most software is built to be replaced. We assume the code will be rewritten before it needs deep servicing, so we don't invest in making it legible from the inside. Sometimes that's the right call — a throwaway script doesn't need a caseback. But we make that bet by default, on systems we then run for a decade, and we're surprised when servicing them is agony.

The practical translation isn't "write more comments" or "add more documentation," both of which rot. It's the same thing the watchmaker does mechanically: make the system's behavior visible at the point where someone will need to see it. In software that means structured logs you can actually trace a request through, error messages that carry the context of what failed and why, names that tell the next reader what a thing is for, and boundaries clear enough that you can reason about one part without holding the whole in your head. Observability isn't an ops feature you bolt on — it's the caseback. It's the decision to build something a stranger can open.

What the analog reveals that a software argument wouldn't

I could have made all of this as a straight engineering argument — "invest in observability, it pays off." You've heard that, and it slides off, because it sounds like eating your vegetables. The watch makes it land differently, because the watchmaker isn't trading off inspectability against velocity. There's no version of haute horlogerie where someone says "we'll skip making it serviceable this quarter and add that in the next movement." Serviceability is the movement. The two aren't separable, because the people who built these things were building for a timescale where the distinction collapses.

That's the uncomfortable mirror. We treat inspectability as separable from function because we're optimizing for a quarter, and on a quarter's timescale you really can ship something that works and is impossible to open, and look productive doing it. The watch is built by people optimizing for a century, and on that timescale the corner you cut on legibility isn't a saving — it's a debt that comes due with interest, paid by whoever opens the case after you're gone.

You don't have to build everything to last 134 years. Most software shouldn't. But it's worth knowing which of your systems you're quietly building to be replaced and which you're actually going to run for a decade — and making sure the second kind has a caseback. The 1889 movement is still running not because it was made perfectly, but because it was made to be understood by the people who'd keep it running. That's a quality decision, made up front, and it's the one we skip most.