The electron argument. Why the "deterministic vs probabilistic" framing misunderstands the entire history of computing.
Electrons are not little balls orbiting a nucleus. They are probability clouds. Wave functions. You cannot know exactly where an electron is. You can only know the probability of finding it in a particular location.
This is not uncertainty due to our instruments being imprecise. This is fundamental to reality. The Heisenberg uncertainty principle is not a limitation of measurement. It is a property of nature. The electron genuinely does not have a definite position until measured.
Transistors work by controlling the flow of these probabilistic particles through semiconductor junctions. When you shrink transistors small enough (modern chips are at 3-5 nanometers, approaching the scale of individual atoms), quantum tunneling becomes a real engineering problem. Electrons can "tunnel" through barriers they should not be able to cross, purely due to their wave-like nature.
The entire deterministic computing stack, everything from your Python code down to the machine instructions, every single layer from 1 to the bottom, is built on a probabilistic particle called the electron.
Technically, it is all probabilistic. We made it deterministic by collapsing the complexity into architecture and steps.
The trick is not eliminating probability. The trick is managing it. Working with enough electrons that the statistical behavior becomes predictable. Building tolerances into transistor designs. Adding redundancy where it matters.
Electrons: Transistors use voltage thresholds. A signal above a certain voltage is a 1, below it is a 0. The exact voltage does not matter. This is the first abstraction: continuous, probabilistic analog signals become discrete digital ones.
Memory: ECC memory detects and corrects single-bit errors. Cosmic ray flips a bit, ECC fixes it. You never know it happened.
Storage: Checksums verify data integrity. Every file transfer, every database write, every network packet has error detection built in.
Software: Type checking, exception handling, input validation, automated testing. Layers of defense against incorrect behavior.
Systems: Redundant servers, failover clusters, distributed consensus algorithms. The entire cloud computing infrastructure is designed around the assumption that individual components will fail.
The pattern is the same at every level. Accept that the substrate is unreliable. Build architecture that produces reliable behavior anyway.
This critique is widespread and understandable. Large language models sample from probability distributions. They can give different answers to the same question. They can produce confident-sounding text that is factually wrong. These are real concerns.
The punched card loom was deterministic, but the cards tore and the holes were punched wrong. Early computers were deterministic, but moths got stuck in relays. The Pentium was deterministic, but someone forgot five entries in a table. Your RAM is deterministic, but cosmic rays flip bits anyway.
Electrons are fundamentally probabilistic, but we engineered around that too.
Every layer started unreliable. Every layer became reliable through architecture, through error handling, through redundancy, through validation, through decades of engineering effort.
AI is following the same pattern. We are in the early phase. We are finding the bugs. We are taping them into logbooks. We are building systems to catch mistakes, to verify outputs, to create redundancy.
The technical walkthrough of the computing stack is standard computer science. The history is documented fact. But the argument that AI is "just the next layer" in this pattern is my own framing. I understand if there is pushback.
There are legitimate differences between the kind of probability in electron behavior and the kind of probability in language model outputs. The error modes are different. The engineering challenges are different. I am not claiming they are identical.
What I am claiming is that the pattern, taking something unreliable and making it reliable through architecture, is the same pattern. And that dismissing AI as "merely probabilistic" without considering that the entire computing stack beneath it is also probabilistic, just at different scales, is an incomplete analysis.
The question is not whether AI is probabilistic. It is. The question is whether we can engineer reliability on top of that probability. Based on the history of every other layer in the stack, the answer is likely yes. It just takes time and effort.
Ada Lovelace saw it in 1843. The loom weaves patterns. The engine weaves algebra. The computer weaves logic.
And now AI weaves language.
Same pattern. Different layer. The only question is how long it takes us to build the architecture that makes it reliable.
Based on history, we will figure it out. We always do.
That one line of Python. Twenty-two characters.
Built on the shoulders of every engineer who ever taped a moth into a logbook.
For those who want to go deeper.
The Jacquard Loom
Science and Industry Museum: Programming Patterns
Grace Hopper's Moth
Smithsonian: Log Book With Computer Bug
Pentium FDIV Bug
Ken Shirriff: Intel's $475 million error
Cosmic Ray Bit Flips
John D. Cook: Documented case of a cosmic bit flip
Soft Errors in Computing
Wikipedia: Soft error
CPython Source Code
github.com/python/cpython