Quantum computing doesn’t have a performance problem. It has a honesty problem. And a small, quietly viral GitHub commit just made that case better than any academic paper could.
In 2026, a developer replaced the IBM Quantum backend in a project with /dev/urandom — the Unix pseudorandom number generator that ships on essentially every Linux system ever built — and the project kept working. Not degraded. Not broken. Working. That single swap became a flashpoint on Hacker News and Reddit, not because it was a stunt, but because it exposed something the quantum computing community has been reluctant to say out loud: in a surprising number of real-world implementations, quantum hardware isn’t doing anything that a cheap source of entropy can’t replicate.
What Actually Happened
The project in question was using IBM’s quantum backend as a component in a larger pipeline. When the backend was swapped for /dev/urandom, the outputs were functionally equivalent for the task at hand. The Hacker News thread was quick to clarify the intent — this wasn’t a critique of quantum computing as a field. It was a critique of the specific project, and possibly of a broader pattern where quantum components get bolted onto systems more for optics than for necessity.
One commenter put it plainly: the point isn’t even about speed. The point is that the quantum computer component of the original solution wasn’t doing anything that justified its presence. That’s a very different kind of criticism, and a much more uncomfortable one.
The Architecture Problem Nobody Wants to Name
From an agent architecture perspective — which is the lens I spend most of my time looking through — this incident is a case study in what I’d call prestige components. These are system elements chosen not because they solve a specific technical problem better than alternatives, but because they signal sophistication to stakeholders, reviewers, or the market.
We see this pattern in AI systems constantly. Teams will route a task through a large frontier model when a fine-tuned smaller model, or even a lookup table, would perform identically. The cost is real: latency, API spend, architectural complexity, and a false sense of what’s actually driving results. Quantum backends are just the latest surface where this tendency shows up.
When you can replace a component with /dev/urandom and nothing breaks, you haven’t proven that quantum computing is useless. You’ve proven that your architecture didn’t need what quantum computing actually offers. Those are very different claims, and conflating them is how bad engineering decisions get made in both directions.
What Quantum Computing Actually Offers
To be clear about where I stand: quantum computing has genuine, specific strengths. Certain optimization problems, cryptographic applications, and simulation tasks at molecular or chemical scales represent areas where quantum approaches have real theoretical and emerging practical advantages. None of that is in dispute.
But those use cases are narrow, technically demanding, and require hardware that is still maturing. The gap between “quantum computing can theoretically do X” and “this production system needs a quantum backend to do X” is enormous, and that gap is where a lot of current quantum integration lives.
The Signal in the Noise
What makes the /dev/urandom swap so useful as a diagnostic tool is its bluntness. It’s a stress test for necessity. If your quantum component can be replaced by a kernel-level random number generator without consequence, you have a documentation problem at minimum and an architecture problem at worst. You need to be able to answer, precisely, what the quantum layer is contributing that nothing else can.
This is the same question good agent system designers ask about every component in a pipeline. What is this doing that is irreplaceable? If the answer is vague, the component is probably load-bearing for the wrong reasons.
Why This Matters for How We Build
The teams building serious AI and agent systems right now are making long-term architectural bets. Quantum integration is being discussed in those rooms. The lesson from this incident isn’t to dismiss quantum computing — it’s to demand specificity. What problem, exactly, does the quantum component solve? What does the system do differently with it versus without it? Can you measure that difference?
If those questions don’t have solid answers, /dev/urandom is waiting patiently in /dev/, ready to do the job for free.
The most useful thing this commit did wasn’t replace a backend. It gave engineers a new question to ask before they add any component to a system: could I swap this out for something trivial and still ship? If yes, start there and work backwards to justify the complexity. That’s not cynicism about new technology. That’s just good engineering.
🕒 Published: