Let's start with Qubits

You've heard the pitch a hundred times: quantum computers will break encryption, cure diseases, and solve problems "classical computers never could." Then you look for an explanation and get a wall of bras, kets, and Bloch spheres that reads like it was written for people who already have a PhD.

Let's not do that.

You already know what a bool is. You already know what a matrix multiplication does in code. That's genuinely most of the machinery you need. This article gives you the mental model — the next ones in this series will get into entanglement, gates, circuits, and eventually post-quantum cryptography, which is the part that should actually worry (or excite) you as an engineer.

Start with what you already know: the bit

A classical bit is boring by design. It's 0 or 1. Full stop. Every program you've ever written, every database row, every network packet — underneath it all, definite 0s and 1s sitting still, waiting to be read.

That stillness is a feature. It's why classical computers are reliable. But it's also a ceiling. If you want to know "what happens for every possible input," you run your function once per input. Ten booleans means 1,024 combinations, and you check them one at a time (or in parallel, if you have 1,024 cores lying around).

Enter the qubit

A qubit is the quantum version of a bit, and it breaks that stillness on purpose.

A qubit can be |0⟩, it can be |1⟩ (that pipe-and-angle-bracket notation is just physicists' way of writing "the state labeled 0" — treat it like a fancy variable name), or — and this is the whole show — it can be something a classical bit can never be: both at once.

Superposition

That "both at once" state is called superposition, and it's worth its own moment.

Here's the closest programming analogy: imagine a variable that isn't storing a value, but is storing a small probability distribution over its possible values, along with some extra "phase" information (we'll get to why that matters). Instead of one int, you've got something closer to a weighted, complex-valued array of possibilities — and every operation you apply reshapes that whole distribution at once, not just one branch of it.

That's superposition. It's not "the qubit is secretly 0 or 1 and we just don't know which yet" — it genuinely holds both possibilities, with their own weightings, until something forces it to decide.

If you have read a bit about quantum physics and/or computing, you might have heard about the Schroedinger's cat analogy, which for non-experts leads to confusion. So the suggestion is to set it aside or directly forget it.

The catch: you can never just "read" a qubit

Here's the part that trips people up, and it's also the most important rule in the whole field: you cannot inspect a qubit's full state. No console.log(qubit).

The only way to get information out of a qubit is to measure it, and measuring:

• always returns exactly one classical bit — 0 or 1, never "a bit of both"
• is probabilistic — which value you get depends on the weights (the amplitudes) baked into the superposition
• collapses the qubit — the moment you look, the superposition is gone, and the qubit is now just plain 0 or 1, like a classical bit again

So a qubit is rich and full of information while it's computing, and gives you exactly one boring bit the instant you check. This is arguably the single biggest source of confusion about quantum computers: people assume you get to read out some exotic quantum answer. You don't. You get a 0 or a 1, same as always — the magic happened before you looked, in how that answer's odds got shaped.

Where this leaves you

The mental model to keep, stripped of anything else:

That's genuinely the core of a single qubit: a value that can be both 0 and 1 at once, right up until the moment you check — and the moment you check, it isn't anymore.

But a single qubit on its own isn't where the power comes from. The interesting part starts when you put several of them together, and they stop behaving like independent variables altogether. That's entanglement, and it's where this series picks up next — along with the gates: the matrix operations that actually let you steer a qubit's odds before you measure it.