Quantum Computing Basics: Qubits, Gates, and

Quantum computing is about 30 to 40 years old, depending on where you plant your flag, and it has spent most of that time being largely theoretical — a playground for physicists with unusually high tolerance for abstraction. That's shifting. In a new video from the official Qiskit channel, Dr. Katie McCormick makes the case that the shift has gotten specific enough to matter for university curricula right now: "Today's university students may encounter quantum computers in their future careers. Whether they're physics majors, computer scientists, chemists, or even economists, quantum computing is no longer something reserved for specialists."

It's a confident claim. Worth examining what the actual on-ramp looks like — and what the video's approach reveals about where quantum education is heading.

Starting from bits, not hype

One of the more interesting structural choices McCormick makes is refusing to start with quantum at all. The video opens with a methodical refresher on classical computing — bits, gates, circuits, the half adder. The NOT gate, the AND gate, the XOR gate. Ground you've probably covered before.

The pedagogy here is intentional and it works. Quantum computing borrows the vocabulary of classical computing — gates, circuits, registers — while fundamentally changing the rules underneath. If you go straight to superposition without grounding students in what a gate actually does, you're teaching magic, not mechanics. McCormick's instinct to anchor the quantum in the classical gives learners a scaffold rather than a spectacle.

The pivot lands harder because of it. With classical bits, an m-bit system is in exactly one of 2ᵐ possible states at any moment. With m qubits — McCormick's term is "cubits" throughout, reflecting spoken pronunciation rather than standard spelling — the superposition principle means a system can be in a combination of all 2ᵐ classical states simultaneously, each weighted by a complex coefficient. That exponential gap between what classical and quantum systems can represent is the whole ballgame, and the video earns the reveal by not rushing it.

What superposition actually means (and what it doesn't)

McCormick is careful here in a way that a lot of quantum explainers aren't. On superposition: "A superposition state is sometimes described as being in both states at once. Analogies kind of fail here, but it's a bit more like being partly in one state and partly in the other."

That hedge matters. The "both states at once" framing is seductive and technically imprecise — it elides the role of measurement, which is where quantum weirdness actually bites. When you measure a superposition, it collapses to a classical state. The probability of landing on any particular outcome is the square of the magnitude of its coefficient. This is not a detail; it's the entire reason quantum algorithms are hard to design. You can't just ask a quantum computer for the answer — you have to engineer the interference of amplitudes so the right answer is more probable when you look.

This is also where the phase enters, and McCormick flags it clearly as something students will return to repeatedly: the coefficients aren't just magnitudes, they're complex numbers with a phase component. That phase has no classical analog. It's what makes gates like the Hadamard interesting — the H gate doesn't just create superposition, it creates superposition with specific phase relationships that downstream gates can exploit.

Entanglement gets similar treatment. Two qubits are entangled when the state of one cannot be described independently of the other. McCormick walks through the canonical example: measure one qubit of an entangled pair, and the outcome of measuring the other is instantly determined, regardless of distance. "This correlation exists no matter how far apart the cubits are. Which is why the act of measuring an entangled state is sometimes referred to as spooky action at a distance." The Einstein reference is earned rather than dropped for effect — it signals that this correlation bothered some very serious people for good reason.

The gate zoo

The quantum gate section is where the video earns its place as a genuine technical primer rather than a pop-science tour. McCormick covers:

X gate: the quantum NOT, flips |0⟩ to |1⟩ and vice versa, but also works on superpositions
Hadamard (H) gate: no classical analog; creates equal superposition from a basis state; the workhorse of quantum algorithm initialization
Phase gates: manipulate the complex phase of qubit states; no classical counterpart
CNOT (controlled-NOT): two-qubit gate; applies X to the target only if the control is |1⟩; essential for entanglement creation
Toffoli gate: controlled-controlled-NOT; two controls, one target; the quantum AND gate made reversible

That last point is worth sitting with. Reversibility isn't a minor technical footnote — it's a structural requirement of quantum circuits. In the classical world, gates like AND are irreversible: you can't reconstruct the inputs from the output alone. Quantum mechanics doesn't permit that kind of information loss. Every quantum gate must be reversible, which is why the quantum AND needs that extra qubit as a target. The circuit remembers what happened.

Any multi-qubit gate, McCormick notes, can be decomposed into single-qubit gates and CNOTs. That's a fundamental result, and it's the reason the CNOT is so central to quantum computing — it's the universal two-qubit primitive.

Running something real

The practical payoff comes in the second half of the video, where McCormick demonstrates building a quantum half adder in Qiskit and running it on actual IBM hardware. The circuit implements the classical half adder's logic — XOR for the sum, AND for the carry — using four qubits: two inputs (A and B) and two outputs (sum and carry), with the XOR realized via CNOT gates and the AND via a Toffoli.

This is a good choice for a first circuit. The half adder is pedagogically clean — students already know what it should do — and it bridges classical intuition to quantum implementation without requiring any genuinely quantum algorithm behavior (no superposition in the inputs, no entanglement in the outputs for the 0+0 case shown).

What's more instructive is what happens next: the logical circuit gets transpiled before it runs. Real quantum hardware has constraints that the abstract circuit ignores — qubits aren't fully connected, gates have error rates, and each processor has a specific native gate set. The Qiskit transpiler handles the translation automatically, mapping logical qubits to physical ones and rewriting the circuit in the hardware's native language. The transpiled circuit looks substantially different from what was written.

This gap between logical and physical is where a lot of quantum tutorials gloss over the hard part. McCormick doesn't. The circuit runs 100 times (100 "shots"), and the results are probabilistic — you get a histogram, not a single answer. In an ideal noiseless system, every shot would return the same result. On real hardware, noise introduces errors, and you see a spread. The dominant result is correct, but it's not alone.

That honest representation of noisy hardware is, frankly, more useful than tutorials that demo against simulators and imply the real thing behaves the same way. IBM's move toward open hardware access makes this kind of ground-truth education possible at scale — students aren't just learning theory, they're seeing the actual error distribution from a real processor.

The Qiskit patterns framework

Underlying the whole workflow is what McCormick calls the "Qiskit patterns" framework: map the problem to a circuit, optimize for hardware, execute, post-process. For a half adder, this is admittedly more scaffolding than the problem needs. But the video explicitly acknowledges that — "for the simple circuit that we're going to build here, this might seem like overkill" — and makes the argument that building the habit now pays off later.

That argument is sound. Quantum algorithm development at scale, where circuits are deep and hardware noise matters, requires exactly this kind of structured thinking about the pipeline. The relationship between quantum and classical systems in production environments is itself a pipeline problem — quantum processors don't operate in isolation, they're typically embedded in classical compute workflows for setup, error mitigation, and result interpretation.

Starting students with the full framework, even on trivial circuits, is the right instinct.

What this approach assumes

There's one tension worth naming: the video sits at an interesting access level. It's positioned as introductory, but it requires comfort with complex numbers, linear algebra notation (Dirac bra-ket), and some tolerance for equations that aren't fully derived. A student who hasn't seen complex exponentials will hit a wall with the phase discussion. An educator hoping to use this with undergraduates in, say, economics — one of the groups McCormick explicitly mentions — will need to think carefully about prerequisites.

That's not a criticism of the video; it's a genuine question about where "quantum literacy" actually starts. McCormick is aiming for university students who may already have the mathematical machinery; whether quantum computing education can meaningfully reach below that level remains an open and contested question in the field.

What the video does well, it does quite well. The classical-to-quantum architecture is smart. The hardware honesty is refreshing. The decision to build something real — and run it on real hardware, noise and all — rather than hide behind simulators reflects a pedagogical maturity that's been absent from too many quantum tutorials for too long.

The field is about 30 to 40 years old. The on-ramp is finally starting to look like it was built for more than specialists. Whether the curriculum catches up before the students need it is a different race entirely.

— Dev Kapoor, Open Source & Developer Communities Correspondent, Buzzrag