Software is, at its core, instructions written by humans for machines to follow. Every app on your phone, every search result you get, every autocorrect that embarrasses you — all of it is code: long sequences of logical commands telling a computer exactly what to do. The machine follows those instructions perfectly. That's actually the problem.
When a programmer writes code, they have an intention in their head. 'When the user taps this button, send the message.' Simple enough. But translating that intention into code means spelling out every single step, in a language that has no tolerance for ambiguity, written by a human brain that is extremely tolerant of ambiguity. You read a sentence with a typo and your brain fills in the gap. A computer reads a typo and crashes, or worse — does something completely wrong without crashing at all.
Make your call
A programmer writes code to calculate a shopping cart total. It works perfectly in testing. Then a customer adds 0 items and checks out. What happens?
A
The cart shows $0.00 and the order goes through fine
B
The app crashes or returns a nonsense number
C
The programmer gets an alert and fixes it instantly
That's the core of it. The programmer imagined a user who adds items, reviews the cart, and checks out. They did not imagine a user who checks out with nothing. So they wrote code for the world they pictured — and the world they pictured is always smaller than the world that actually exists. Every bug is the same story: reality showed up somewhere the programmer's imagination didn't reach.
This is called an edge case. But 'edge' is misleading — it implies rare. In practice, the space of things users can do is enormous. Real people check out with 0 items. They type emojis into fields expecting plain text. They lose internet connection halfway through a transaction. They use your app on a seven-year-old phone running an OS version you never tested. Each of those is a gap between what the programmer intended and what the code actually handles.
A bug is not a mistake in the code. It's a mistake in the imagination. The code does exactly what it was told. The problem is that 'what it was told' didn't cover enough of the real world.
The Mariner 1 hyphen wasn't a typo someone overlooked — it was a transcription error when converting handwritten equations into code. The equation existed in a human document, with human notation, interpreted by a human. Then it had to become machine instructions. In that translation, one character got dropped. The rocket's guidance system then made decisions based on slightly wrong math, veered off course, and had to be destroyed.
Modern software has billions of lines of code, written by hundreds of engineers, across years, often inheriting old code nobody fully understands anymore. The gap between intent and code doesn't shrink as software gets bigger — it compounds. Which is why the apps you use every day are simultaneously impressive and quietly broken. Both things are true, and neither is going away.