The rsync Singularity: AI, ‘Worse is Better’, and the Thermodynamics of Software Collapse

If you have spent any time in the trenches of the open-source community recently, you will have noticed a rather spectacular conflagration surrounding rsync.

The spark was simple: Andrew ‘Tridge’ Tridgell—the legendary systems programmer and original author of rsync—returned to the project to clear a massive backlog of CVEs. Working largely alone, Tridge employed Claude, Anthropic’s LLM, as a co-author to help bash through the workload. The AI generated patches, the tests passed, the code merged.

Then came the regressions. Subtle, architectural breakages began to surface in edge cases, symlink translations, and cross-platform builds. The internet mob descended, pitchforks raised, declaring that AI had poisoned a piece of foundational infrastructure.

But pointing the finger at Claude—or at an exhausted maintainer trying to keep a 30-year-old project alive—misses the forest for the trees. Whether the immediate regressions were caused by AI hallucination, review failures, or simple human error is ultimately secondary. The specific bugs are merely a symptom.

This is actually a story about structural entropy, the conservation of complexity, and what happens when a system crosses its own Entropic Event Horizon.

To understand why rsync is breaking, we have to rewind to 1989, to a fundamental schism in how we build software, and look at the physical limits of complexity itself.

The Blacksmith and the Conservation of Complexity

In his famous 1989 essay, the Lisp programmer Richard Gabriel observed a disturbing trend: elegantly designed software kept losing out to cruder, simpler implementations. He called this phenomenon ‘Worse is Better’.

Gabriel identified two competing tendencies in software design. On the East Coast was the ‘MIT Style’ (what he called ‘The Right Thing’): systems must be perfect, interfaces must be beautiful, and the underlying implementation must handle all the complex edge-cases invisibly so the user does not have to.

On the West Coast, born out of Bell Labs in New Jersey, was the ‘UNIX Style’: keep the implementation simple. If handling an edge-case makes the system too complicated, throw an error code and force the programmer to deal with it.

Gabriel despaired that the ‘Worse’ New Jersey style was spreading like a virus. But Gabriel’s premise relied on a subtle misconception. He assumed that pushing complexity onto the user was a failure of design.

Ken Thompson and Dennis Ritchie, the architects of UNIX, understood something profound: complexity cannot be destroyed; it can only be redistributed. The genius of pure UNIX was the realisation that the required skillset of the operator must be higher than the skillset required to write the tools. Think of it like a blacksmith. A hammer does not need to understand the structural dynamics of a horseshoe; it only needs to transfer force efficiently. The total complexity required to solve a problem is conserved; it exists entirely in the mind and the hands of the operator.

If a system tries to absorb all the complexity internally to provide ‘MIT Magic’ to an unskilled user, that complexity doesn’t vanish. It is simply transferred from the user to the maintainer.

The Thermodynamic Cost of ‘MIT Magic’

This brings us back to rsync.

At its inception, rsync was a beautiful, UNIX-style tool designed to do one thing perfectly: delta-encode a file over a low-bandwidth pipe. But over three decades, driven by a modern culture that demands frictionless abstractions, rsync mutated. It absorbed network daemons, SSH wrappers, complex regex parsers, and labyrinthine permissions logic. It stopped being a hammer and tried to become the blacksmith.

In my theoretical work mapping the thermodynamics of complex systems (SETE 2.0), I define a metric called Informational Density. It represents the concentration of stateful, structural information a system must maintain to preserve its internal coherence. Maintaining high Informational Density requires continuous thermodynamic work, which we can call Maintenance Power (P_maint).

As rsync grew into an entangled monolith, its Informational Density skyrocketed. The tacit knowledge required to safely modify it—understanding how a symlink patch might create a race condition in the daemon’s networking code—became immense.

The Asymptote of Maintenance

The scaling of maintenance effort (P_maint) against monolithic complexity is not linear; it faces a brutal asymptote.

As informational density rises, the population capable of understanding the whole system shrinks. Eventually, the system reaches a state where no individual maintainer possesses a complete internal model. At that point, every modification becomes statistically exploratory rather than intentional. The system may continue functioning for years, but its evolution has crossed an event horizon; architectural coherence can no longer be guaranteed.

For a massive corporation, that asymptote might be delayed by throwing vast amounts of capital at the problem. But for a single contributor like Tridge, rsync had hit this entropy wall. The required P_maint to safely navigate the codebase vastly exceeded the cognitive bandwidth of one human being.

The system entered what I term Metabolic Decoherence. Tridge turning to Claude was not a lapse in judgement; it was a desperate attempt to synthesize the circulating maintenance power he lacked, slamming headfirst into a hard biophysical limit.

The LLM Catalyst

So, why did the AI accelerate the decoherence?

Large Language Models can temporarily subsidise maintenance power—they can automate tests, generate boilerplate, and assist with refactoring—but they cannot eliminate the underlying growth of informational density. They are stateless engines. If you feed an LLM a failing test, it will rewrite the code in the statistically most probable way to make the light turn green, completely blind to the unwritten architectural invariants of the system.

The software industry has spent the last two decades under the dangerous assumption that code is its own documentation, and that CI/CD pipelines are an adequate substitute for design specifications. They are not. A test suite only verifies binary behaviour; it cannot explain intent.

When you apply a stateless LLM to a highly entangled system pushing the asymptote of maintainability, it executes the digital equivalent of rogue agency. It achieves a short-term spike in productivity by physically culling the system’s viable future phase-space, introducing subtle regressions that rot the architecture from the inside out.

The Entropic Event Horizon

The rsync controversy is a fractal representation of our entire digital infrastructure. There are countless foundational open-source projects currently being held together by single maintainers rapidly approaching their own entropy walls. We have built an ecosystem addicted to abstraction, masking the structural limits of our code beneath layers of ‘fictitious information’.

We assume that when the complexity gets too entangled for human brains, we can simply hand the ledger over to Artificial Intelligence. But AI cannot architect its way out of structural entropy.

If we want to prevent the catabolic collapse of our foundational software, we have to stop trying to build magic boxes that abstract away the machine. We must return to composable, strictly bounded primitives. We need to rediscover the discipline of the blacksmith, because the alternative is watching our most critical systems, one by one, cross an event horizon from which nothing returns.