Every codebase you’ve inherited had the same problem. Complexity that accrued over years through well-intentioned additions, each one reasonable in isolation, interacting in ways nobody planned. The people who wrote it could navigate it. Everyone else was lost.

Political systems have the same problem. Laws, regulations, tax codes — they accrete the way legacy software does. A provision gets added to solve a real problem. Another gets bolted on to handle an edge case. A lobbying effort nudges a clause in a direction that benefits someone specific. A decade later, the system is a sprawling artifact that mostly serves the people who had a hand in shaping it. Look at any country’s tax code. Engineers would recognize it immediately: thousands of interacting rules, undocumented dependencies, behavior that nobody fully understands, maintained by specialists whose expertise is the complexity itself.

In a codebase, complexity creates information asymmetry. The people with institutional knowledge — the ones who were there when the decisions were made — can navigate the system. Newcomers can’t. They depend on the incumbents, which gives the incumbents structural power regardless of whether their original decisions were good. Institutions work the same way. Every loophole in the tax code has a constituency that benefits from it and will fight to keep it. Every regulation, however outdated, has someone whose workflow depends on it. Simplification threatens someone’s position. This is why legacy systems survive long past their usefulness, in code and in law.

And the failure modes are the same. Engineers know three: the ground-up rewrite, the freeze, and the feature creep. The rewrite is seductive — throw it all away, start clean, build it right this time. It almost never works. The old system’s complexity wasn’t arbitrary; it encoded real requirements, and the rewrite ends up reproducing them, often worse. The freeze is the conservative instinct — don’t touch what works, even if “works” means “hasn’t visibly broken yet.” It delays the reckoning but makes it worse. The feature creep is the bureaucratic default — keep adding, never removing, until the system collapses under its own weight.

Political movements map onto these failure modes more cleanly than their proponents would like to admit. The revolutionary impulse is the rewrite. The traditionalist impulse is the freeze. The technocratic impulse is the feature creep. Each one has a diagnosis that’s partly right and a prescription that mostly fails.

There’s a fourth option. Engineers know it as refactoring.

Refactoring works within the existing system. It simplifies where complexity has become accidental rather than essential, and it keeps the system legible — because a system that its users can’t understand is a system they can’t trust, and a system they can’t trust loses legitimacy whether it works or not.

The hard part is the same in both domains. Refactoring requires someone willing to remove things that benefit specific people for the sake of the whole. Every simplification is someone’s loss. Every removed provision had a beneficiary. The courage to refactor is the courage to tell a constituency that their exception doesn’t justify the complexity it imposes on everyone else.

It’s not glamorous work. Nobody gets elected on a promise to make the tax code slightly more coherent. But it’s the work that actually maintains systems across time — in code, in institutions, in the basic infrastructure that lets a society function.

Refactoring isn’t revolution. It’s the opposite.