Quantum Computing, Explained Simply

The one-line version: A quantum computer isn’t a faster computer — it’s a boat where everyone else has a car: useless for most trips, but the only thing that can cross a handful of oceans (like simulating molecules and breaking encryption), by choreographing waves so wrong answers cancel and the right one stands out.

The key takeaways

• Qubits aren’t just “faster bits.” A qubit holds a blend of 0 and 1 (superposition); each added qubit doubles the state space; entangled qubits act as one linked system.
• The real mechanism is wave interference, not “trying every answer at once.” Algorithms make wrong-answer waves cancel and right-answer waves reinforce. That’s the whole game.
• The catch: measuring collapses the blend, so a 300-qubit machine still yields only 300 readable bits. All the cleverness happens before you look.
• It’s a boat, not a faster car. Specialized for a short list of structured problems — factoring, molecular simulation — not a general speedup. Search only gets a modest √N boost, not a miracle.
• Five hardware platforms are still racing (superconducting, trapped ion, neutral atom, photonic, silicon spin) with no clear winner; each trades speed against accuracy against temperature.
• Errors are the central obstacle. Qubits fail every ~100–1,000 operations, against once in a quintillion for classical chips. The fix is error correction: many physical qubits make one reliable logical qubit — but only below a ~1% threshold.
• 2024 was the turning point. Google’s Willow chip crossed that threshold at scale — the first real proof that error correction works as you scale up.
• Two obstacles remain: the “magic-state tax” (now shrinking) and cosmic-ray error bursts (about once an hour).
• The encryption clock is already ticking. “Harvest now, decrypt later” is why NIST published post-quantum standards in 2024 — years before a code-breaking machine exists.
• The honest gaps: quantum advantage in chemistry, optimization and AI is promising but unproven; and there is a quiet shortage of new algorithms — if a working machine appeared tomorrow, we wouldn’t have that much to run on it.
• Realistic timeline: useful molecular simulation late-2020s; RSA-breaking scale in the 2030s. These will be data-center accelerators, never laptops.

The big idea in one paragraph

A regular computer stores information as bits — tiny switches that are either 0 or 1. A quantum computer uses qubits, which can be 0, 1, or a blend of both at once.

Because of this blending — and a couple of other quantum tricks — a quantum computer can explore certain kinds of problems in ways that would take a normal computer longer than the age of the universe. It won’t replace your laptop. It is a specialized machine for a small set of extremely hard problems: designing new drugs, discovering new materials, and eventually breaking today’s encryption.

The best one-line analogy comes from a quantum physicist, by way of the “Huge If True” video with MKBHD.[27] Imagine exploring a giant map where progress depends on how fast you can do arithmetic. Paper and pencil were walking; early computers were horses; modern supercomputers are cars. Quantum computers are not faster cars — they’re boats. Not better or worse, but built for completely different terrain. They open entire oceans of problems no car, however fast, could ever reach. And there is no flying car-boat coming for your pocket either: these machines will live in data centers.

1. What makes a qubit different from a bit?

A bit is a coin lying on a table. It is either heads (1) or tails (0).

A qubit is a coin spinning in the air. While it spins it is neither heads nor tails — it is a blend of both possibilities. Only when you catch it and look (physicists say “measure”) does it land on one definite outcome.

Three quantum tricks give these spinning coins their power.

Trick 1: Superposition — the spinning coin

One qubit holds a blend of 0 and 1. Two qubits hold a blend of all four combinations (00, 01, 10, 11). Three qubits hold eight. Each added qubit doubles the possibilities the computer can juggle at once. Just 300 qubits can represent more states simultaneously than there are atoms in the observable universe.

Trick 2: Entanglement — linked coins

Two qubits can become entangled: mysteriously linked, so that measuring one instantly tells you about the other, no matter how far apart they are. Einstein called this “spooky action at a distance.” Entanglement lets qubits work together as one giant system instead of separate pieces.

Trick 3: Interference — waves that cancel and reinforce

Here is the key insight most people miss: a quantum computer does not simply “try every answer at once.” If it did, measuring it would hand you a random answer — useless. Instead, qubit states behave like waves. Picture tapping a pond in two spots and watching the ripples reinforce where they meet and cancel where they collide. Quantum algorithms choreograph these waves so that the waves of wrong answers cancel each other out, like noise-cancelling headphones, while the waves of the right answer reinforce — so when you finally measure, the correct answer is what you most likely see.

Bottom line: quantum computing is the art of making wrong answers cancel out and right answers stand out.

The catch

The moment you look at a qubit, the blend collapses into a plain 0 or 1. So from a 300-qubit machine you still only get 300 bits of readable output. All the cleverness is in arranging the waves before you look.

2. How is a quantum computer different from a regular one?

Can it solve every hard problem? No — this is a common myth. “Find the one right answer among N possibilities” only gets a modest square-root speedup: searching a million items takes roughly 1,000 quantum steps instead of a million. The jaw-dropping speedups appear only for problems with special mathematical structure, like factoring large numbers and simulating molecules.

Is entanglement alone enough? Also no. A certain family of quantum circuits (using “Clifford gates”) can generate plenty of entanglement and yet be perfectly simulated on a laptop. True quantum advantage requires extra ingredients — which turns out to matter enormously once we get to error correction.

3. What are these machines actually made of?

There is no single winner yet. Five very different technologies are racing to build the best qubit — rather like the early days of aviation, when nobody knew whether planes, blimps or helicopters would win.

What does one actually look like? That famous “golden octopus” chandelier you have seen in photos is mostly refrigerator. When MKBHD visited IBM’s lab,[27] the actual quantum computer turned out to be a chip the size of a fingernail at the bottom of a room-sized stack of gold-coloured plates: a dilution refrigerator holding the chip at 15 millikelvin — colder than deep space, among the coldest spots in the known universe. The hundreds of cables running down the stack carry microwave signals to the qubits and bring answers back to ordinary room-temperature electronics. So when someone says “IBM’s quantum computer,” 99% of what you are looking at is the life-support system keeping a tiny chip unimaginably cold and quiet.

🔧 Superconducting circuits — artificial atoms on a chip

Used by Google and IBM. Tiny electrical circuits etched onto silicon and chilled to near absolute zero — about 0.01 degrees above the coldest possible temperature. At that temperature electricity flows with zero resistance and the circuit behaves like a single artificial atom.

• Strengths: incredibly fast — a gate operation takes billionths of a second. Built with chip-industry techniques.
• Weaknesses: giant, expensive refrigerators; every chip comes out slightly different, so manufacturing consistency is hard; qubits forget their state within a fraction of a millisecond.

⚛️ Trapped ions — real atoms held by invisible tweezers

Used by IonQ and Quantinuum. Individual charged atoms floating in a vacuum chamber, held in place by electric fields and controlled with laser beams.

• Strengths: every ion is perfectly identical, because nature made them rather than a factory. The most accurate qubits known, above 99.9% gate precision, and they remember their state for minutes.
• Weaknesses: very slow gates — roughly 1,000× slower than superconducting — and it is hard to pack many ions into one trap.

🕸️ Neutral atoms — atoms in a web of light

Used by QuEra and Pasqal. Uncharged atoms trapped in a grid of focused laser beams (“optical tweezers”). To make them interact, atoms are briefly puffed up into giant “Rydberg” states where they strongly influence their neighbours.

• Strengths: large grids of hundreds of atoms are comparatively easy to build, and the grid can be rearranged mid-calculation, which saves a lot of overhead.
• Weaknesses: atoms occasionally escape their traps, and gate accuracy is still catching up.

💡 Photons — computing with particles of light

Used by PsiQuantum, Xanadu and Quandela. Qubits encoded in single particles of light travelling through optical chips — the same basic technology as fibre-optic internet.

• Strengths: works at room temperature; light barely interacts with its environment, so qubits stay clean; naturally suited to networking.
• Weaknesses: photons don’t naturally interact with each other, so two-qubit operations only succeed sometimes — which requires clever probabilistic designs and many spare photons.

💠 Silicon spins — one electron per qubit

Used by Intel and academic labs. Each qubit is the magnetic orientation (“spin”) of a single electron trapped in a nanoscale dot on a silicon chip, built in the same factories that make phone processors.

• Strengths: astonishingly small — millions could fit on one chip — and riding on trillions of dollars of chip-manufacturing know-how.
• Weaknesses: qubits can only talk to immediate neighbours, and nanoscale wiring is fiendishly difficult.

The scorecard

Honest takeaway: nobody knows which platform wins. It may well be different platforms for different jobs, just as we use GPUs for graphics and CPUs for general work today.

4. How do we know if a quantum computer is any good?

Counting qubits is like judging a car by engine size alone — a 1,000-qubit machine full of errors is worse than a reliable 100-qubit one. So the field uses better yardsticks.

• Component tests. How long does a qubit remember its state? What is the chance a single operation goes wrong? Measured by scrambling a qubit with random operations and then checking whether it survived.
• Quantum Volume (IBM’s idea). Run the hardest random circuits the machine can handle and see how big they can get before the output becomes noise. The score folds qubit count, accuracy and connectivity into one number.[17]
• Algorithmic Qubits (IonQ’s idea). Instead of random circuits, run the actual building blocks of real algorithms: how many qubits’ worth of useful work can the machine do?[18]

5. Watching a real algorithm work: the needle in a haystack

This section follows the visual walkthrough from Grant Sanderson’s 3Blue1Brown explainer on Grover’s algorithm.[22]

The puzzle

Imagine a mystery function hiding one secret key among a list of N values. Feed it the key and it answers “true”; feed it anything else and it answers “false.” You can’t open it up — you can only try inputs. This is the generic shape of an enormous family of problems: anything where checking an answer is easy but finding one is hard, such as Sudoku solutions, map colourings and cryptographic keys.

Classically, there is nothing better than guess-and-check: on average you need N/2 tries. Double the list, double the work.

Quick quiz: on a quantum computer, what is the best possible runtime? Most people — including most Stanford students and even International Math Olympiad attendees who were asked — guess “constant time” (check everything at once, read the answer) or something logarithmic. Both are wrong, and the wrongness comes straight from the pop-science “parallel universes” summary. The correct answer, proven optimal in 1994 and achieved by Lov Grover’s algorithm in 1996, is about √N steps.

A square-root speedup, then — not a miracle. So how does even that work?

The picture: an arrow on a circle

Think of the quantum state as an arrow that must always have length exactly 1. Each of the N candidate answers is one direction the arrow could point. At the start the arrow sits in an “equal balance” — tilted almost flat, with a tiny lean toward every candidate, including the secret key.

Grover’s algorithm repeats just two moves:

1. Tag the answer. Using the mystery function, translated into quantum gates, flip the sign of the arrow’s component in the secret-key direction. This changes no probabilities — it just marks the answer, like a wave crest flipping to a trough.
2. Mirror around the average. Reflect the whole arrow around its original “equal balance” direction.

Here is the magic: two reflections in a row equal a rotation. Each pair of moves rotates the arrow by a small fixed angle — roughly 1/√N radians — steadily lifting it toward the secret-key direction. After about (π/4)·√N repetitions — some 804 steps for a list of a million — the arrow points almost straight at the answer. Now you measure, and you almost certainly read out the key. Not guaranteed: if you are unlucky you simply run it again, and since checking an answer is easy, a wrong guess costs nothing.

Why square root? Think Pythagoras

The deepest intuition is geometric. Crossing from one corner of a square to the opposite corner along the edges takes 2 units of walking; cutting diagonally takes √2. In n dimensions, the edges cost n and the diagonal costs √n. Classical computation is like being forced to walk along the edges, from one definite state to another. Quantum computing allows the diagonal paths through blended states — and the square-root shortcut falls straight out of the geometry. (The full story uses complex numbers, which let each wave carry both a size and a phase; mercifully, Grover’s algorithm only ever needs positive and negative.)

A fun coda from complexity theorist Scott Aaronson: he dreams of a sci-fi scene where the heroes run Grover’s algorithm to find a key while the villains break down the door — and the algorithm is only 30% of the way through its rotation, giving a 30% chance of success if measured now. Measure or wait? It is a dilemma no classical algorithm could ever produce.

6. What will quantum computers actually be good for?

🔐 Breaking — and replacing — encryption

Most internet security, from banking to messaging to government secrets, rests on one mathematical bet: that factoring enormous numbers is too hard to do. A normal computer would need billions of years to factor the numbers behind RSA encryption.

In 1994, Peter Shor found a quantum algorithm that does it efficiently.[21] A large enough quantum computer could break RSA in hours. That machine does not exist yet — but estimates of how big it needs to be keep shrinking dramatically.

How Shor’s algorithm actually works, with a tiny real example — adapted from the Veritasium walkthrough.[28] First, how RSA works: everyone picks two big secret prime numbers, multiplies them and publishes the product. Scrambling a message with the public product is easy; unscrambling it requires knowing the two secret primes — and factoring a 300-digit product would take a supercomputer some 16 million years. Shor’s trick turns factoring into a rhythm-finding problem:

1. Make a bad guess. Pick any number g that shares no factors with the public number N — say g = 8 for N = 77.
2. Find the hidden rhythm. Raise g to higher and higher powers, keeping only the remainders after dividing by N. For 8 and 77 the remainders run 8, 64, 50, 15, 43, 36, 57, 71, 29, 1 — and then the whole pattern repeats every 10 steps. Finding that period is the one step that is painfully slow classically, and it is exactly what the quantum computer does fast, using the Quantum Fourier Transform — the same mathematics your phone uses to pick frequencies out of music, applied to a superposition.
3. Turn the rhythm into better guesses. With the period r known, g^r/2 + 1 and g^r/2 − 1 — here 32,769 and 32,767 — probably share factors with N.
4. Extract the factors using Euclid’s 2,300-year-old greatest-common-divisor recipe: the shared factor of 32,769 and 77 is 11, and 77 ÷ 11 = 7. Encryption broken — 77 = 7 × 11.

With perfect qubits this would take only a few thousand of them. The millions in the table above are the error-correction tax for real, noisy hardware.

Why this matters today: spies can record encrypted data now and decrypt it later, once the hardware arrives — “harvest now, decrypt later,” also called SNDL. The NSA has publicly warned that a sufficiently large quantum computer would undermine all widely deployed public-key encryption. That is why the U.S. standards agency NIST already published new post-quantum encryption standards in 2024, based on mathematical problems that even quantum computers aren’t known to crack, and why governments are pushing everyone to migrate by the early 2030s.[5]

What replaces RSA? Invisible grids called lattices.[28] NIST ran a global competition from 2016 — 82 candidate algorithms submitted, many broken along the way — and the winners mostly rely on lattice cryptography. Picture a regular grid of points generated by combining two arrows in whole-number steps. Now imagine being handed awkward, slanted arrows that generate the same grid, plus a point that is almost on the grid — a message with a pinch of random noise added — and being asked which grid point is closest. Easy in two dimensions with nice arrows. Brutal with bad arrows in around a thousand dimensions, where every step in the right direction on one axis throws you off on the other 999. The legitimate receiver holds the secret “nice arrows” and decodes instantly; everyone else, classical or quantum, faces a problem nobody knows how to solve efficiently. That is the bet the world’s new encryption standards are built on.

🧪 Designing drugs, fertilizers and materials

Nature is quantum mechanical, so simulating molecules is the most natural job for a quantum computer. Classical supercomputers choke on molecules whose electrons are strongly tangled together.

The famous example is nitrogenase, an enzyme in soil bacteria that pulls nitrogen from thin air to make fertilizer at room temperature.[6] Human industry does the same thing — the Haber–Bosch process — only with brutal heat and pressure, burning 1–2% of all the energy humanity produces. If a quantum computer could model nitrogenase’s chemistry, which no classical computer can, it could point the way to catalysts that make fertilizer cheaply; similar simulations could accelerate drug discovery and battery design.

The good news: estimated costs for this have fallen roughly 100,000-fold in eight years of algorithm improvements — from machines needing hundreds of millions of qubits down to projections of a few thousand error-corrected ones.[7]

An honest caveat, from physicist Mithuna Yoganathan, who left quantum computing research and revisited the field five years later.[23] The flagship chemistry algorithm, phase estimation, has a chicken-and-egg problem: it extracts a molecule’s ground-state energy beautifully fast — but only if you can feed it a good approximation of that ground state first, and nobody can guarantee your guess is close enough for the hardest molecules. In 2022 a group of respected quantum-computing and chemistry researchers published a paper bluntly titled “Is there evidence for exponential quantum advantage in quantum chemistry?”[24] Their conclusion: not yet — it may be prudent to assume exponential speedups are not generically available. Quantum chemistry remains promising, but it is not a guaranteed silver bullet.

The safer bet: simulating physics itself. What quantum computers are provably good at is simulating quantum systems directly, letting their qubits interact the way electrons do.[8] That maps to concrete dreams: high-temperature superconductors, where today’s only work when deeply cooled; better solar cells, since silicon tops out around 20–25% efficiency; nitrogen fixation without Haber–Bosch’s energy bill; even models of black holes for fundamental physics. Instead of making and testing thousands of materials in a lab, you would screen them in silico and build only the winners.

🚚 Optimization — the honest “maybe”

The best route for a delivery fleet, the best stock portfolio, the best factory schedule: quantum approaches exist here, and they are heavily marketed. But no clear, practical quantum advantage for optimization has been demonstrated yet. On today’s noisy machines a frustrating effect called “barren plateaus” makes the optimization landscape so flat that the algorithm cannot tell which way is downhill.[16] Promising, unproven — be sceptical of hype here.

🤖 A quick word on “quantum AI”

Media coverage sometimes suggests quantum computers will supercharge AI. Insiders are largely sceptical. Quantum algorithms shine on problems with hidden mathematical structure, like factoring’s periodicity; machine learning is the opposite, grinding through mountains of messy, unstructured data. The “quantum machine learning” hype wave of the late 2010s has noticeably cooled among researchers, and there is no evidence yet that quantum computers will make chatbots or image generators meaningfully better.[23]

The quiet bottleneck: where are the new algorithms?

Here is an under-appreciated fact: we know of only a handful of quantum algorithms with genuine speedups — Shor’s (1994), Grover’s (1996), phase estimation and Hamiltonian simulation — and they are mostly decades old. Hardware teams hit their roadmaps; algorithm discovery has been much slower, partly because it is brutally hard, with proposed speedups often later disproved or matched by classical tricks. As Yoganathan puts it: if a fully functioning quantum computer appeared tomorrow, we wouldn’t have all that much to run on it.[23] There are hopeful signs — in 2023 theorists proved a new kind of exponential quantum advantage, albeit for a contrived “oracle” problem that cannot be built directly — and historically such proofs have paved the way to practical algorithms, Shor’s included. The takeaway: the field doesn’t just need better machines, it needs more people hunting for algorithms.

7. The giant problem: errors — and the giant solution

Qubits are incredibly fragile

A stray vibration, a whisper of heat, even a cosmic ray from deep space can flip a qubit. Where a normal chip makes an error maybe once in a quintillion operations, today’s best quantum hardware makes one every hundred to thousand operations. Real algorithms need billions of operations. Do the arithmetic: an unprotected machine fails instantly.

The fix: quantum error correction

The solution mirrors how we protect ordinary data — redundancy. Instead of storing information in one qubit, spread it across many physical qubits to form one logical qubit, like spreading one message across many couriers so that no single ambush loses it. Special “check” qubits constantly watch for damage without peeking at the data itself, which would destroy it.[13]

• If hardware errors are below a critical threshold of roughly 1%, adding more physical qubits makes the logical qubit exponentially more reliable.
• If you are above the threshold, adding qubits just adds noise. Everything in the field hinges on this threshold.

The landmark moment: Google’s Willow chip, 2024

In late 2024 Google crossed the threshold for the first time at scale. Their 105-qubit Willow chip showed that each time they enlarged the error-correcting grid, the logical error rate dropped by more than half — and their best logical qubit lived 2.4× longer than any single physical qubit inside it.[1] It was the experimental proof that error correction genuinely works, not just on paper.

In parallel, a Harvard/QuEra team using neutral atoms in laser tweezers built a processor with 48 logical qubits from 280 physical atoms and ran complex routines on them — a different hardware path to the same goal.[2]

Two stubborn obstacles remain

1. The “magic” tax. Remember the Clifford circuits a laptop can simulate? Error correction naturally protects exactly those boring operations. The interesting operations — the ones no classical computer can fake — can’t be protected directly, so quantum computers must manufacture special purified fuel called magic states in dedicated factory regions. Historically these factories were expected to consume 80–90% of the whole machine. New techniques, called magic-state cultivation, are now slashing that tax[14] — one reason the RSA-breaking estimates collapsed in 2025.[3]

2. Cosmic rays. As error correction gets better, a weirder enemy appears. Experiments found a floor of rare error bursts — about once an hour — traced to cosmic rays and background radiation hitting the chip.[15] A single particle impact sends vibrations through the chip that corrupt dozens of qubits simultaneously, which is exactly the kind of correlated failure error correction isn’t designed for. Fixes being explored: operating deep underground, radiation shielding, vibration-absorbing materials and smarter decoding software.

The road ahead

• IBM has published a roadmap to a machine called Starling by 2029: roughly 200 logical qubits running 100 million operations — enough for early useful chemistry.[19]
• New error-correcting codes, called qLDPC codes, promise to need far fewer physical qubits per logical qubit than today’s approach, potentially shrinking machines by a factor of ten.

8. So… when will it matter? A sober timeline

And a realistic picture of what these machines will look like: not standalone devices, but accelerators. A quantum chip sitting inside a giant classical supercomputing centre, called on only for the specific sub-problems — a molecule’s electrons, a factoring step — where it crushes classical hardware, while ordinary computers handle everything else, including babysitting the qubits’ errors in real time.

Quick glossary

Sources & further reading

This is a plain-language adaptation of the technical report “The Architecture, Modalities, and Algorithmic Frontiers of Quantum Information Processing.” Every number and milestone above is backed by the technical version; these are the key sources.

1. Google Quantum AI. Quantum error correction below the surface code threshold. Nature 638, 920–926 (2025). The Willow result: the first large-scale demonstration that adding qubits to an error-correcting code makes the logical qubit more reliable.
2. Bluvstein, Evered et al. (Harvard / MIT / QuEra). Logical quantum processor based on reconfigurable atom arrays. Nature 626, 58–65 (2024).
3. Gidney, C. How to factor 2048 bit RSA integers with less than a million noisy qubits (2025). arXiv:2505.15917
4. Gidney, C. & Ekerå, M. How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits. Quantum 5, 433 (2021).
5. NIST post-quantum cryptography standards — FIPS 203 (ML-KEM), FIPS 204 (ML-DSA), FIPS 205 (SLH-DSA), finalized 13 August 2024; HQC selected as a backup standard 11 March 2025 (NIST IR 8545).
6. Reiher, Wiebe, Svore, Wecker & Troyer. Elucidating reaction mechanisms on quantum computers. PNAS 114, 7555–7560 (2017). The original nitrogenase / FeMoco proposal.
7. Lee, Berry et al. Even more efficient quantum computations of chemistry through tensor hypercontraction. PRX Quantum 2, 030305 (2021).
8. Daley, A. J. et al. Practical quantum advantage in quantum simulation. Nature 607, 667–676 (2022).
9. Kjaergaard, M. et al. Superconducting qubits: current state of play. Annual Review of Condensed Matter Physics 11 (2020).
10. Bruzewicz, C. D. et al. Trapped-ion quantum computing: progress and challenges. Applied Physics Reviews 6, 021314 (2019).
11. Saffman, M., Walker, T. G. & Mølmer, K. Quantum information with Rydberg atoms. Reviews of Modern Physics 82, 2313 (2010).
12. Burkard, G. et al. Semiconductor spin qubits. Reviews of Modern Physics 95, 025003 (2023).
13. Fowler, Mariantoni, Martinis & Cleland. Surface codes: towards practical large-scale quantum computation. Physical Review A 86, 032324 (2012).
14. Gidney, Shutty & Jones. Magic state cultivation (2024). arXiv:2409.17595
15. McEwen, M. et al. Resolving catastrophic error bursts from cosmic rays in large arrays of superconducting qubits. Nature Physics 18, 107–111 (2022).
16. McClean, J. R. et al. Barren plateaus in quantum neural network training landscapes. Nature Communications 9, 4812 (2018).
17. Cross, A. W. et al. Validating quantum computers using randomized model circuits (Quantum Volume). Physical Review A 100, 032328 (2019).
18. IonQ. Algorithmic Qubits: a better single-number metric (2022); see also the QED-C application-oriented benchmark suite (arXiv:2110.03137).
19. IBM Quantum. Quantum Starling roadmap (2025): ~200 logical qubits running 100 million gates by 2029, built on qLDPC codes.
20. Nielsen, M. & Chuang, I. Quantum Computation and Quantum Information. Cambridge University Press, 2010 — the standard textbook, for the mathematics behind the analogies.
21. Shor, P. W. Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer. SIAM Journal on Computing 26 (1997); and Grover, L. K. A fast quantum mechanical algorithm for database search (1996).
22. 3Blue1Brown (Grant Sanderson) — quantum computing and Grover’s algorithm explainer: the needle-in-a-haystack walkthrough, the rotating-arrow picture, the Pythagoras intuition and the Scott Aaronson anecdote. youtube.com/watch?v=RQWpF2Gb-gU
23. Looking Glass Universe (Mithuna Yoganathan) — Why I Left Quantum Computing Research (2025): the phase-estimation caveat, the quantum-machine-learning scepticism, the simulation optimism and the algorithm bottleneck. youtube.com/watch?v=pDj1QhPOVBo
24. Lee, S., Magann, A. B., Rabitz, H. A. et al. Is there evidence for exponential quantum advantage in quantum chemistry? (2022–2023).
25. Quantum Country (Andy Matuschak & Michael Nielsen) — Quantum Computing for the Very Curious, a free interactive course with built-in memory prompts. quantum.country
26. Looking Glass Universe’s beginner course on quantum mechanics — a gentle, video-based introduction to the underlying physics.
27. Huge If True (Cleo Abram) with MKBHD — Quantum Computers, explained: the boats-not-cars analogy, the “golden octopus” refrigerator visit and the pond-ripples picture of interference. youtube.com/watch?v=e3fz3dqhN44 (Filmed around 2022, when IBM’s record was 433 qubits; the roadmap numbers here reflect the current state of the art.)
28. Veritasium — How Quantum Computers Break The Internet… Starting Now: the step-by-step Shor’s algorithm example (77 = 7 × 11), the harvest-now-decrypt-later threat and the lattice-cryptography explanation. youtube.com/watch?v=-UrdExQW0cs

Share this article

Send it to someone who still thinks a quantum computer is just a faster laptop.

X LinkedIn Bluesky Facebook WhatsApp Send via Slack Email Copy link