§ Trackr.Live

Quantum Error Correction

Quantum error correction is the engineering discipline that bridges noisy physical qubits to reliable logical qubits capable of executing useful algorithms. Without it, the entire quantum computing enterprise is bounded by the coherence times and gate fidelities of individual physical qubits — which in 2026 limits useful computation to circuits a few hundred to a few thousand gates deep. With error correction working at practical overhead, arbitrary-depth computation becomes possible, and the major quantum algorithms (Shor’s, useful quantum simulation, large-scale Grover) become reachable rather than merely theoretical.

The discipline has spent thirty years moving from “theoretically possible” to “experimentally demonstrated.” The December 2024 Google Willow result was the moment the field crossed the threshold — the first experimental demonstration that increasing the code distance reduces the logical error rate, which is the structural test for whether error correction is working as a real engineering tool rather than as a theoretical construct. The transition from “we believe error correction will work” to “we have shown error correction works” happened in 2024, and the next decade will determine whether the engineering can scale to cryptographically-relevant and chemistry-relevant problem sizes.

This page is the deep-dive companion to the Quantum Computing umbrella page and the layer that sits between the physical-qubit world of Qubit Architectures and the logical-qubit world that Quantum Algorithms require. The framework rests on the physics covered in Quantum Mechanics Fundamentals, particularly the decoherence model and the no-cloning theorem.

The problem in concrete terms

Physical qubits in 2026 have error rates per gate operation in the range of 0.1% to 1% — meaning that roughly one in a hundred or one in a thousand gate operations produces an incorrect result. For a useful quantum algorithm running thousands or millions of gates, those errors compound to the point where the output is statistically indistinguishable from random.

The Google Willow result hit a per-gate error rate of about 0.5% for two-qubit gates. Quantinuum H2 has demonstrated two-qubit gate fidelities above 99.9%, putting it at 0.1% error per gate. IBM Heron sits in the 0.5-1% range. Neutral atom systems are roughly comparable. These are the best numbers in the field — most published quantum hardware operates with worse error rates.

For comparison, useful applications need:

Shor’s algorithm against RSA-2048 requires roughly 10⁹ to 10¹² gate operations. At a per-gate error rate of 0.5%, the probability of even one error during the algorithm is essentially 1. The algorithm cannot complete.
Useful quantum chemistry simulation typically requires 10⁶ to 10⁹ gates. Same problem.
Most NISQ-era algorithms that have been demonstrated work because they run at depths the hardware can tolerate, not because the hardware has the depth needed for advantage over classical methods.

The gap between current per-gate error rates and what useful algorithms need is roughly 10⁻³ to 10⁻¹² — somewhere between three and twelve orders of magnitude. Closing the gap through better physical qubits alone is implausible. Closing it through error correction is the only known path.

Why classical error correction doesn’t translate directly

Classical computers handle errors through replication. A noisy bit can be encoded as three bits — 0 → 000, 1 → 111 — and the original value recovered by majority vote even if one of the three bits flips. The encoding can be made arbitrarily reliable by using more copies; modern hard drives use sophisticated error correction codes that recover from millions of bit errors per terabyte.

The classical approach breaks down for quantum information for three reasons:

The no-cloning theorem prevents direct replication. A quantum operation that takes an unknown state |ψ⟩ and produces |ψ⟩|ψ⟩|ψ⟩ does not exist, as established in the Quantum Mechanics Fundamentals page. The naive “copy the bit three times” approach is not a legal quantum operation.

Measurement destroys quantum information. Classical majority vote works by reading all three bits and computing the majority. In the quantum setting, reading the bits collapses them to classical values, destroying any superposition. The protected logical state would not survive the act of checking for errors.

Errors come in more flavors. A classical bit can only flip (0 ↔ 1). A qubit can experience bit-flip errors, phase-flip errors, combined bit-and-phase errors, leakage out of the computational subspace, and continuous rotation errors — all of which behave differently and need different correction strategies.

Quantum error correction had to develop its own framework. The key insight, due primarily to Peter Shor in 1995 and refined by many others since, is to encode the logical qubit in an entangled state across many physical qubits, then detect errors through measurements that reveal whether an error has occurred without revealing what the encoded state is. The measurements are designed to project the system onto subspaces corresponding to specific error syndromes; the act of measurement collapses the noise (which was a continuous mixture of possible errors) into a discrete classical outcome that says “an error of type X happened on qubit Y,” and the correction can then be applied without ever touching the encoded logical state.

This is the structural innovation that makes quantum error correction possible: measurements designed to extract error information without extracting state information. The mathematical framework that systematizes this is the stabilizer formalism.

Pedagogical entry: the bit-flip and phase-flip codes

Two simple codes serve as the standard entry point into the discipline.

The three-qubit bit-flip code encodes one logical qubit in three physical qubits using a structure analogous to the classical repetition code:

|0⟩_L = |000⟩
|1⟩_L = |111⟩

A logical state α|0⟩_L + β|1⟩_L is encoded as α|000⟩ + β|111⟩ — an entangled superposition, not three copies. (The encoding circuit uses CNOT gates; the no-cloning theorem applies to copying unknown states, but here we are entangling three qubits in a specific structure determined by the encoder.)

If a single qubit experiences a bit flip — say the second one — the state becomes α|010⟩ + β|101⟩. The error can be detected by measuring the parities Z₁Z₂ and Z₂Z₃ (the products of the Z Pauli operators on neighboring qubit pairs). These measurements reveal whether qubits 1 and 2 agree, and whether qubits 2 and 3 agree, without revealing the actual values of any individual qubit. The pair of parity measurements gives a two-bit syndrome that uniquely identifies which qubit (if any) experienced a bit flip, and the appropriate correction (an X gate on the affected qubit) restores the original logical state.

The three-qubit bit-flip code protects against single-qubit bit-flip (X) errors. It does not protect against phase-flip (Z) errors, and is in fact more vulnerable to phase errors than the unencoded state — a phase error on any of the three qubits causes the same effect on the logical state.

The three-qubit phase-flip code uses the same structure in a rotated basis:

|0⟩_L = |+++⟩
|1⟩_L = |−−−⟩

where |±⟩ = (|0⟩ ± |1⟩)/√2. This code protects against single-qubit phase errors and fails against bit-flip errors.

Neither code alone is useful — real noise produces both types of errors. The next step is combining them.

The Shor code

Peter Shor’s 1995 paper introduced the first full quantum error correction code, encoding one logical qubit in nine physical qubits in a structure that protects against arbitrary single-qubit errors. The construction is hierarchical:

Encode the logical qubit in the phase-flip code: |0⟩_L → |+++⟩, |1⟩_L → |−−−⟩.
Each of those |+⟩ or |−⟩ states is itself encoded in the bit-flip code: |+⟩ → (|000⟩ + |111⟩)/√2, |−⟩ → (|000⟩ − |111⟩)/√2.
The total encoding uses 9 physical qubits, with the structure of three blocks of three qubits each.

The Shor code protects against arbitrary single-qubit errors because any quantum error can be decomposed into a combination of bit-flip and phase-flip errors (since {I, X, Y, Z} form a basis for the space of single-qubit operators, and Y = iXZ). The bit-flip layer handles X errors within each block of three; the phase-flip layer handles Z errors across the three blocks; Y errors are corrected as combinations of both.

The structural lesson from the Shor code: protecting against arbitrary single-qubit errors requires encoding in a 9-qubit (or more) entangled structure with multiple layers of redundancy. There is no shortcut — the no-cloning theorem and the variety of error types both contribute to the overhead.

Stabilizer codes — the unifying framework

The Shor code is the prototype for a much broader family of codes called stabilizer codes, introduced by Daniel Gottesman in 1997. A stabilizer code is defined by a set of commuting Pauli operators (the stabilizers) whose simultaneous +1 eigenspace is the code space — the logical states live in this subspace, and the stabilizer operators provide the parity-check measurements that detect errors.

The stabilizer formalism is the mathematical backbone of essentially all practical quantum error correction codes in use today. Three categories of stabilizer codes are worth knowing:

CSS codes (Calderbank-Shor-Steane) are stabilizer codes constructed from classical linear codes using a specific procedure that produces quantum codes from pairs of classical codes. The Shor code is a CSS code; the Steane code (encoding one logical qubit in 7 physical qubits) is another. CSS codes have the operational advantage that bit-flip and phase-flip errors can be corrected separately, simplifying decoder design.

Topological codes encode logical qubits in the topological properties of a 2D (or higher-dimensional) lattice of physical qubits. The dominant example is the surface code, covered in the next section. Topological codes have the advantage of requiring only nearest-neighbor interactions, which fits well with the physical connectivity of most qubit hardware architectures.

LDPC (Low-Density Parity-Check) codes are stabilizer codes where each stabilizer involves only a constant number of qubits (low weight) and each qubit is involved in only a constant number of stabilizers. Quantum LDPC codes are an active research area because they can achieve much better encoding efficiency than topological codes — more logical qubits per physical qubit, with comparable error correction capability — at the cost of requiring longer-range connectivity.

The surface code

The surface code, introduced by Alexei Kitaev in the late 1990s and developed extensively by Robert Raussendorf and others through the 2000s, is the dominant quantum error correction code in 2026. Every published large-scale fault-tolerant architecture proposal — from IBM, Google, AWS, PsiQuantum, and most academic groups — uses the surface code or a close variant.

The construction

A surface code encodes a logical qubit in a 2D grid of physical qubits with a specific stabilizer structure. The most common variant uses a square lattice with two types of qubits:

Data qubits that hold the encoded logical state.
Measurement qubits (also called ancilla or syndrome qubits) that perform the stabilizer measurements.

The stabilizers are products of four neighboring data qubits, alternating between “X-type” stabilizers (products of X Pauli operators) and “Z-type” stabilizers (products of Z Pauli operators) in a checkerboard pattern. Each measurement qubit is responsible for one stabilizer and is repeatedly measured to detect when its associated stabilizer changes value — a change indicates that an error has occurred somewhere in its support.

The code distance d is the minimum number of physical errors that can occur without being correctable. A distance-d surface code can correct ⌊(d-1)/2⌋ errors and detect d-1 errors. Increasing the distance increases both the physical qubit overhead and the error correction capability.

For a distance-d surface code:

Total physical qubits per logical qubit ≈ 2d² (counting data qubits and measurement qubits)
Errors correctable: ⌊(d-1)/2⌋
Logical error rate scales as (p/p_th)^((d+1)/2) where p is the physical error rate and p_th is the threshold

The surface code’s central virtue is that it requires only nearest-neighbor interactions between physical qubits. This fits well with the connectivity of superconducting and neutral-atom platforms. Long-range entangling gates are not needed, which substantially simplifies the hardware design.

Connectivity matters

The surface code’s nearest-neighbor connectivity is both a virtue and a limitation. For architectures with longer-range or all-to-all connectivity (trapped ions, reconfigurable neutral atoms), more efficient codes are possible — the encoding overhead can be reduced if the code can use stabilizers involving more distant qubits. This is one of the reasons trapped-ion systems and the newer LDPC codes have received increased attention: they can potentially achieve fault tolerance with substantially less physical qubit overhead than surface-code-based architectures.

For the dominant superconducting and neutral-atom architectures, however, the surface code remains the best-understood and best-implemented approach in 2026.

The threshold theorem

The quantum threshold theorem, proved in various forms throughout the late 1990s, states that if the physical error rate per gate is below some threshold p_th, then arbitrarily reliable quantum computation is possible with overhead polylogarithmic in the desired accuracy.

The theorem is the structural reason error correction is believed to work in principle. The proof construction shows that concatenated codes — applying error correction recursively, with each layer correcting errors below it — can achieve exponentially small logical error rates with only polylogarithmic overhead in physical qubits, provided the physical error rate is below threshold.

For the surface code, the threshold is approximately 1% per gate — meaning that physical hardware with two-qubit gate fidelities above 99% should be able to operate the surface code in a regime where increasing the code distance reduces the logical error rate. Hardware with two-qubit gate fidelities below 99% — most quantum hardware in production through about 2023 — is above threshold and cannot benefit from increasing the code distance, because errors accumulate faster than the code can correct them.

The threshold for other code families varies. Concatenated CSS codes have lower thresholds (around 10⁻⁴ to 10⁻³) but better scaling once above threshold. The surface code’s relatively high 1% threshold is one of the reasons it has become dominant — it makes useful error correction reachable at physical error rates that real hardware has demonstrated.

The threshold theorem is what makes quantum computing engineering possible. Without it, error correction would be a defensive measure against a problem that always wins as systems get larger; with it, error correction is a tool that becomes more effective as hardware improves and as the code distance increases.

The Google Willow result — what it actually demonstrated

In December 2024, Google announced the Willow processor and a series of experiments demonstrating below-threshold quantum error correction for the first time. The result was the most significant quantum computing milestone of 2024, and it deserves its own treatment because of what it specifically proves and what it does not.

The experimental setup: Willow is a 105-qubit superconducting processor with two-qubit gate fidelities around 99.5% (about 0.5% error per gate), which is below the surface code threshold. Google implemented surface codes at distances 3, 5, and 7 (using 17, 49, and 97 physical qubits respectively to encode a single logical qubit) and measured the logical error rate at each distance.

The key result: as the code distance increased from 3 to 5 to 7, the logical error rate decreased by approximately a factor of 2.14 per distance step. This is the signature of below-threshold operation — increasing the code distance is supposed to suppress errors exponentially when the physical error rate is below threshold, and that is what was observed.

What this proves:

The surface code works as theory predicted at the relevant physical error rates. This had been demonstrated at distance 3 (and arguably distance 5) before, but the distance 7 result extends the demonstration to a regime where the scaling behavior is unambiguous.
Physical error rates of 0.5% are sufficient for useful error correction. The threshold theorem’s prediction is now experimentally validated, not just theoretically established.
The path from noisy physical qubits to reliable logical qubits is engineering, not theoretical breakthrough. The remaining work is scaling up the code distance and the number of logical qubits, both of which are quantitative engineering challenges rather than open scientific questions.

What this does not prove:

A complete useful logical qubit was not demonstrated. The Willow experiment used the surface code in a “memory” mode — preserving a stored quantum state for some time period. Performing logical gate operations between logical qubits at distance 7 with full fault tolerance is a separate (and more demanding) engineering problem.
The full magic state distillation overhead was not demonstrated. The Willow result handles Clifford operations (which the surface code supports natively) but not non-Clifford operations, which require magic state distillation with additional overhead.
The physical-to-logical qubit ratio achieved was not what fault-tolerant computing requires. Distance 7 with ~97 physical qubits per logical qubit corresponds to a logical error rate of roughly 10⁻⁶, which is reasonable for a memory experiment but well above what large algorithms need. Useful applications require distance 17 or higher, with hundreds to thousands of physical qubits per logical qubit.

The Willow result is the milestone that crossed the field from “we believe error correction can work” to “we have shown error correction can work at the relevant scale.” The remaining engineering is to extend the demonstration to (a) larger code distances, (b) multiple logical qubits operating together, (c) full logical gate operations including the non-Clifford gates that magic state distillation provides, and (d) a complete fault-tolerant algorithm execution. None of these are believed to be theoretically problematic; all of them require substantial additional engineering work.

Other recent demonstrations

Several other recent experimental results extend the error correction picture:

Quantinuum (trapped-ion platform) has demonstrated fault-tolerant logical qubit operations in their H2 system, with logical operation fidelities exceeding the underlying physical fidelities. The Quantinuum results use different codes than the surface code (better suited to the all-to-all connectivity of trapped-ion systems) and demonstrate the principle in a different physical platform than Google’s superconducting result.

Atom Computing and QuEra Computing (neutral atom platforms) have demonstrated logical qubit operations and have published roadmaps targeting larger-scale error-corrected systems. The reconfigurable connectivity of neutral atom arrays gives the platform flexibility to implement codes other than the surface code, including LDPC-style codes with better encoding efficiency.

IBM has been pursuing the bivariate bicycle codes introduced in their late-2024 publications. These are LDPC-style codes that achieve substantially better encoding efficiency than the surface code — IBM reports approximately 12 logical qubits in 288 physical qubits at a logical error rate around 10⁻⁶, compared to roughly 1 logical qubit in 288 physical qubits for the equivalent surface code distance. The catch is that the bivariate bicycle codes require longer-range qubit connectivity than the surface code, which complicates the hardware design. The architectural tradeoff is not yet settled.

AWS Quantum (operating cat qubits on the Ocelot architecture) has demonstrated bosonic error correction approaches that use the structure of the underlying superconducting cavities to provide intrinsic protection against certain error types. The architecture is a hybrid between standard error correction and physical-layer error suppression.

The breadth of recent demonstrations reflects a field that has moved from “error correction is a research direction” to “multiple platforms are demonstrating different versions of error correction in production-relevant scales.” The next few years will determine which approaches scale best.

Magic state distillation — the non-Clifford overhead

A subtle and important property of stabilizer codes: they support Clifford operations (the group of gates generated by Hadamard, CNOT, and phase gates) natively through the code structure, but they do not support non-Clifford operations directly. Universal quantum computing requires at least one non-Clifford gate — typically the T gate (a π/4 rotation) — and the T gate cannot be implemented transversally in the surface code or most other stabilizer codes.

The standard workaround is magic state distillation: prepare a special quantum state (a “magic state”) that encodes the action of a T gate, then use it through a procedure called gate teleportation to apply T gates within the error-corrected computation. Magic states themselves are produced through a distillation protocol that takes many noisy magic states and produces fewer higher-fidelity ones.

The overhead of magic state distillation is substantial. For high-quality magic states suitable for large algorithms:

Each T gate consumes one distilled magic state.
Producing one high-fidelity magic state requires hundreds to thousands of noisy magic states as input.
The distillation factories occupy substantial space in the layout — for some algorithms, magic state factories use more physical qubits than the rest of the computation combined.

For algorithms with many T gates — which includes Shor’s algorithm and most useful quantum chemistry simulations — the magic state overhead dominates the total resource cost. The Litinski 2023 resource estimates for breaking RSA-2048 explicitly account for magic state distillation overhead and find it to be a significant fraction of the total.

Recent algorithmic improvements have been reducing the magic state cost. Better distillation protocols, alternative non-Clifford gate implementations, and codes that support non-Clifford gates more naturally are all active research areas. The 2024 paper on “lattice surgery” optimizations and various magic state factory designs have collectively reduced the magic state overhead by perhaps an order of magnitude over the past five years.

Resource estimates revisited

The resource estimate table from the Quantum Algorithms page can now be put in context. The numbers there assume surface-code error correction with standard parameters:

Application	Logical qubits	Physical qubits (at 0.1% physical error)	Runtime
Break RSA-2048	4,000-10,000	5-20 million	Hours to days
Break ECC P-256	2,000-5,000	3-10 million	Hours
Simulate FeMoco	2,000-5,000	3-10 million	Hours to days
Useful materials simulation	1,000-3,000	2-6 million	Hours

The physical-to-logical ratio of roughly 1,000-2,500 in these estimates comes from:

Code distance of ~15-25 (to achieve logical error rates around 10⁻¹⁰ to 10⁻¹⁵)
Surface code overhead of 2d² physical qubits per logical qubit at distance d
Magic state distillation factories adding additional physical qubits

Improvements in any of these factors reduce the resource requirements. The bivariate bicycle codes mentioned above could reduce the physical-to-logical ratio by roughly an order of magnitude if they can be implemented at scale, which would bring RSA-2048 within reach at perhaps 500,000 to 2 million physical qubits instead of 5-20 million. Better magic state distillation could shave additional factors. The trajectory of resource estimates has been favorable — every few years, the number of physical qubits needed to break RSA-2048 has been revised downward by improvements in either the algorithms or the error correction.

The current gap to capability remains substantial. State of the art in 2026 is roughly 1,500 noisy physical qubits with active error correction development. The applications require millions of physical qubits with full error correction. The gap will be closed through some combination of qubit count scaling, qubit quality improvements, error correction code improvements, and algorithm optimization. No single contribution is enough; collectively they have been advancing the field steadily.

Fault tolerance

Fault tolerance is the property of an error-corrected computation that errors during the error correction itself do not catastrophically corrupt the encoded state. The naive implementation of error correction can fail to be fault-tolerant: if the syndrome extraction circuit introduces correlated errors across multiple data qubits, a single physical error during the extraction can propagate into multiple errors on the encoded state, defeating the correction.

The fault-tolerant implementation of error correction uses careful circuit design to ensure that errors during syndrome extraction can propagate to at most one data qubit error per fault location. The technique is called flag qubits or fault-tolerant syndrome extraction, and it adds modest overhead beyond the basic error correction code.

For the surface code, fault-tolerant operations include:

Memory (preserving an encoded state): the simplest fault-tolerant operation, demonstrated by Google Willow.
Clifford gates (Hadamard, CNOT, S): can be implemented transversally in some surface code variants or through lattice surgery in the standard formulation.
Non-Clifford gates (T gate, controlled-T): require magic state distillation as described above.
Measurement in the logical basis: implemented by measuring all physical data qubits and decoding the result.

A complete fault-tolerant computation chains these operations together with careful management of the encoded state’s evolution. The full machinery is substantial and is the subject of ongoing engineering work; the December 2024 Willow demonstration handled the memory operation at distance 7, and demonstrating the remaining operations at the same scale is the obvious next step.

Alternative approaches

A few error correction approaches outside the standard stabilizer-plus-surface-code paradigm:

Bosonic codes encode logical qubits in the structure of an infinite-dimensional harmonic oscillator rather than in many discrete qubits. GKP (Gottesman-Kitaev-Preskill) codes encode information in superposed lattices in phase space; cat codes encode information in coherent state superpositions. Bosonic codes can provide intrinsic protection against certain error types and have been pursued by AWS Quantum (Ocelot), Alice & Bob, and several research groups.

Color codes are stabilizer codes related to the surface code but with different geometric structure. Color codes support transversal implementation of the full Clifford group (the surface code supports only some Clifford gates transversally) and may have advantages for certain applications.

Subsystem codes generalize stabilizer codes by including “gauge” degrees of freedom that don’t carry logical information but provide additional flexibility in error correction. The Bacon-Shor code is the canonical example.

Quantum LDPC codes more generally are the active frontier. The bivariate bicycle codes are one example; many others are under investigation. The promise is substantial reduction in physical-to-logical qubit overhead at the cost of more complex connectivity requirements.

The dominant approach in 2026 remains the surface code, primarily because it is best-understood and best-suited to current superconducting and neutral-atom hardware. The alternatives may displace it in specific applications or platforms over the coming decade.

The road from here

The path from current capability to practical fault-tolerant quantum computing involves several distinct work streams that are running in parallel:

Physical qubit quality improvements. Reducing the physical error rate below 0.5%, then 0.1%, then 0.01% directly reduces the required code distance and the physical-to-logical ratio. Every order of magnitude improvement in physical error rate roughly halves the required code distance.

Qubit count scaling. Operating useful logical qubits requires thousands of physical qubits per logical qubit. Building systems with millions of physical qubits is an engineering scale-up problem, with vendors targeting it on roadmaps extending into the late 2020s and 2030s.

Code improvements. Better error correction codes (qLDPC, bivariate bicycle, and others) could reduce the physical-to-logical ratio by an order of magnitude or more. The engineering tradeoff between code efficiency and required connectivity is not yet settled.

Magic state distillation improvements. The non-Clifford gate overhead currently dominates many algorithm resource estimates. Better distillation protocols and alternative non-Clifford gate implementations are active research areas.

Decoder algorithms. The classical algorithms that interpret syndrome measurements and determine what corrections to apply are themselves a significant engineering component. Fast, accurate, low-latency decoders are required for real-time error correction in large systems. The leading decoders use union-find algorithms, neural networks, or specialized hardware implementations.

System-level integration. Connecting noisy physical qubits to a working fault-tolerant logical layer requires control electronics, classical communication, real-time decoder hardware, and substantial software infrastructure. The full system-level engineering is comparable in complexity to the qubit hardware itself.

The 2024 Willow result is widely considered the first decisive evidence that this entire program is feasible — that error correction works as theory predicted at the relevant physical error rates. The remaining work is substantial but consists of engineering scaling rather than scientific breakthroughs. The next decade should see the field move from “demonstrated below-threshold error correction at distance 7” to “demonstrated fault-tolerant logical qubits in algorithm-relevant configurations” to “demonstrated useful quantum algorithms running with full error correction.”

Where to go next on this site

Adjacent material on this site:

Quantum Computing — the umbrella overview.
Quantum Mechanics Fundamentals — the physics underlying decoherence, the no-cloning theorem, and the density matrix formalism that error correction works within.
Qubit Architectures — the physical platforms that error correction sits on top of, with platform-specific implications for which codes are practical.
Quantum Algorithms — the algorithms that the logical qubits produced by error correction will eventually run.
Quantum Hardware: State of the Art — current production systems and their error correction capabilities.
Post-Quantum Cryptography — the cryptographic response to the algorithms enabled by fault-tolerant quantum computing.

Quantum error correction is the part of quantum computing where the science is settled and the engineering is ongoing. The physics works; the codes work; the threshold theorem holds; the December 2024 Willow result demonstrated all of it experimentally at meaningful scale. What remains is the long climb from distance-7 logical memory to fault-tolerant algorithm execution at distance 20+ with thousands of logical qubits. That climb will take a decade or more. The trajectory has finally moved decisively from “uncertain” to “ongoing.”