• 15 Nov, 2025 *

The recurrent laryngeal nerve connects the brain to the vocal cords. In a giraffe, this nerve is more than four meters long.

Instead of running straight from the brainstem to the larynx, it travels all the way down into the chest, loops around a major artery, and then returns to the vocal cords. The giraffe is an extreme case: it even has to compensate for the delayed signal transmission. But every mammal has this design. At some point, evolution devised that design in a fish-like ancestor and never revisited it. Evolution, after all, is a pragmatic sort of engineer.

So the next time you stare at a mess of legacy code, take comfort: evolution isn’t so different. Evolution doesn’t plan. It produces countless variations each generation, and some of those reproduce better than others. Over time, these small, local changes accumulate into whole new species.

One extreme in evolution is death before reproduction. Evolution doesn’t distinguish between bad genes or bad luck. Death means you’re out of the game. The only metric that matters is whether the organism lives and reproduces, or whether the system runs. Put differently: a working system beats an optimal design.

In evolution, every organism is always a production system. There are no staging environments, no rollbacks. Big sweeping changes only increase the odds of dropping out of the game entirely.

All of this isn’t a rule book for running a software company. But we can derive some principles:

Your codebase doesn’t mean much if it doesn’t support the business. It may be ugly or written in an esoteric language, but it’s paying your salary. It serves real customers. It runs the business and provides you with a foundation to evolve further.

Big Rewrites rarely work. Evolution always carries forward legacy. The odds of producing a functioning organism from scratch are practically zero. The process of evolution can only move forward incrementally with refinements. It reminds me of all these messy functions we dislike in our codebase. They seem messy because we needed to patch them after long hours of bug hunting. With big rewrites, we might lose such hard work have a worse product.

Survive first, optimize later. The recurrent laryngeal nerve may be ridiculous, but it works. Similar to your 𝒪(n2) routine, or the three extra network hops. It’s not elegant, but as long as it delivers results reliably and keeps the product alive, it’s doing its job. Any good enough and running system beats an efficient one that is still not merged and deployed.

Predict how the design will evolve. Unlike evolution, we can look ahead. By understanding how a system is growing, we can foresee the next architectural bottleneck. That lets us evolve intentionally. We can incrementally reshape the codebase to an intended structure. Then, final refactoring becomes less risky and far less complex.

Respond when the environment changes drastically. Nature or business both face extinction events: asteroids, competitors, and technological shifts. When the environment changes drastically, nature doesn’t crank up the mutation rate. By letting species become extinct, it opens space for new ones. In the same way, sometimes the right move is to free your team from the old codebase entirely and let them build something for the new reality.