The Open Source Illusion Why Availability Does Not Guarantee Sovereignty

I have always smiled at the twin dogmas of Open Source: that you can simply take over any project, and that public code is inherently more secure. AI is currently exposing the cracks in both.

The Open Source Illusion: Why Availability Does Not Guarantee Sovereignty

For years, sovereign software was assumed to be strictly Open Source. The arguments were always identical. First, you avoid vendor lock-in because you have access to the source code and can step in to maintain the project whenever you need to. Second, public code is supposedly safer by definition—after all, anyone can audit the code.

I have always smiled at both claims. Vendor lock-in with proprietary software is very real, and you must weigh alternatives that might even complement one another. But the notion that an organization can casually take over and maintain an upstream Open Source project is pure fantasy. When a complex tool dies or diverges, almost nobody has the spare engineering capacity to maintain a full-blown fork. In practice, it remains wishful thinking.

The Myth of Free Audits

The second selling point—that Open Source software is rigorously scrutinized for security vulnerabilities simply because the code is public—has failed to materialize just as clearly. If “many eyes make all bugs shallow,” then nobody was actually looking.

Recent history made that painfully obvious long before the current AI wave. The XZ Utils backdoor (CVE-2024-3094) showed how an attacker could socially engineer a lone, burned-out maintainer over several years to inject an obfuscated payload into the core Linux plumbing—caught only by pure chance due to anomalous CPU latency, not because the community was auditing the source.

Now AI enters the arena, surfacing one supposed vulnerability after another across mission-critical repositories. But instead of clean, verifiable security, it frequently delivers a deluge of hallucinated noise. Maintainers of critical infrastructure like curl were forced to shut down their public bug-bounty programs after being swamped by AI-generated reports—intimidating write-ups complete with fabricated stack traces and non-existent functions that burned hours of human triage time.

A Promise Unkept

All software has bugs. Yet not every flaw an automated scanner flags is genuinely critical, and many turn out to be artificially constructed edge cases that carry negligible operational risk. What surprises me is how this dynamic is suddenly twisted into another victory lap for Open Source: the idea that AI will finally fulfill the promise and make the code safe.

This exact software was already sold to us as superior long before AI arrived, precisely on the premise of being Open Source. That original promise was never kept.

This is not a defense of proprietary software. My point is simpler: Open Source is not, by definition, the solution to every sovereignty problem.

Further Exploration

Source Code: MPL-2.0 · Content: CC BY-SA 4.0 · Credits & AI Disclosure