A 2,000-Year Overnight Success

You talk to math every day. When you ask ChatGPT a question, you’re conversing with statistics, lists of numbers connected to words stored in a vast multi-dimensional digital space controlled by computer chips.

In the future, we’ll have to explain Google.com to our kids.

And when we are done explaining it to them, they’ll say:

‘You mean you had a question, and a machine just gave you a long list of websites? And you had to click through them one by one, dodging all the ads and junk, just to piece together the answer yourself? That sounds broken.’

The scale we use AI tools today would have sounded impossible just a few short years back, yet we’ve already normalized it, like we normalize every impossible thing, then promptly forget it was ever impossible.

In conversations with academics and clients, I’ve noticed something that led to me to write an article such as this:

Most believe artificial intelligence emerged with Turing, or perhaps ENIAC(Electronic Numerical Integrator and Computer) in the 1950s, some only think of ChatGPT if they’re particularly disconnected from history.

They don’t know about the steam-powered pigeons of ancient Alexandria. They’ve never heard of medieval Arabic robots that could be reprogrammed daily. They’re unaware that Victorian looms wove patterns from punched cards, the first stored programs, decades before anyone imagined electronic computers.

Even if they do know of some of these history factoids, they forget to connect it to today’s modern Ai Hub Bub.

This amnesia matters. When we think AI is seventy years old rather than two thousand, we miss the pattern…and patterns are everything.

We fail to see that every generation has built thinking machines of their own, each time believing they’d either achieved the impossible or hit the absolute limit of what machines could do, the edge of abstraction.

Yet we always found a way to abstract further.

In Alexandria, around 62 CE—we know the date because Heron references a lunar eclipse visible from Alexandria on March 13 of that year—an inventor built what we’d now recognize as the world’s first programmable robot.

Heron of Alexandria’s automatic theatre wasn’t just clever mechanics; it was programmed entertainment. A ten-minute performance of Dionysian myths unfolded through acts of movement, fire, liquid pouring, and dancing figures. The programming language was rope, knots, and falling weights. Binary-like systems of wrapped and unwrapped cord around rotating drums determined which actions triggered when.

A millet-seed timer controlled the tempo, sand would have been too fast, water too unreliable in the Egyptian heat.

Think about what this means.

Before Rome fell, before the Dark Ages, before the Renaissance, someone had already solved the fundamental problem of programmable automation. Heron didn’t just make machines that could move; he made machines that could follow instructions, that could be reprogrammed by changing the arrangement of knots and pegs. The syntax was mechanical rather than digital, but the logic was identical to what runs in your smartphone: if this condition, then that action.

Yet Heron’s theatre was primitive compared to what Greek mechanics had achieved two centuries earlier.

Yes, I tricked you, 67 CE isn’t the earliest!

The Antikythera mechanism, pulled from a shipwreck in 1900 and dated to around 100-150 BCE, computed astronomical positions with shocking sophistication.

This wasn’t just gears; any clock has gears. This was epicyclic gearing, gears mounted on other gears, creating complex motions from simple rotations. The device calculated ecliptic longitudes for the Moon, Sun, and all five visible planets. It predicted eclipses using the 18.2-year Saros cycle. It even accounted for the Moon’s elliptical orbit, a mathematical subtlety that wouldn’t be formally described until Kepler, seventeen centuries later.

The mechanism employed differential gearing, a technology we credit to the Industrial Revolution. When researchers finally decoded its full functionality in 2021, they concluded it “mechanized the predictions of scientific theories” and could have “automated many of the calculations needed for its own design.”

In other words, the ancient Greeks built a computer that could have helped design itself (within reason).

All though in this context saying it “helped design itself” is like saying “the brain named itself”

Perspective becomes important.

When mechanical knowledge re-emerged, it came from Baghdad, not Athens.

In 850 CE, the Banū Mūsā brothers described something extraordinary in their Book of Ingenious Devices: a flute player that could be programmed by its user. Steam powered the mechanism, but the user controlled which melodies emerged.

Different configurations produced different songs. Now the goal was not a simple automation trick, it was user-programmable automation, the conceptual leap from “machine that does one thing” to “machine that does what you tell it.”

A very important nuance to note (pun intended) as we move forward.

Making songs is interesting but a production line of machines is needed to really start making progress.

This is where Al-Jazari, chief engineer to the Artuqid dynasty, comes into play.

In 1206, the year he died, he completed a manuscript describing fifty mechanical devices. His castle clock, standing eleven feet tall, did more than tell time. It could be reprogrammed daily to account for the changing length of days and nights throughout the year.

The clock’s musical automaton band, four robot musicians floating in a boat, took programmability further. By adjusting pegs on rotating cylinders, you could change what the robots played. Move a peg, change a note. Rearrange the pattern, compose a new song. Al-Jazari had invented the mechanical equivalent of a music sequencer, where the program was physical pins and the output was sound.

He even documented the first systematic use of camshafts, converting rotary motion to linear action—the same principle that would drive the Industrial Revolution five hundred years later.

His manuscript survives in multiple copies, the earliest at Istanbul’s Topkapi Palace. You can see reconstructions at the Science Museum in London, where in 1976 they successfully built his scribe clock from his eight-hundred-year-old instructions. It worked perfectly. Donald Hill, who translated Al-Jazari’s work, wrote that it was “impossible to over-emphasize the importance of Al-Jazari’s work in the history of engineering.” Yet most people have never heard his name.

By the 18th century, Europe had caught up to where the Middle East had been five centuries earlier. But now the automata came with philosophical implications.

René Descartes had written in 1637 that animal bodies were “machines which, having been made by the hands of God, are incomparably better ordered” than anything humans could build.

He imagined machines that could speak when touched, cry out when hurt, but never “think”.

At least not like humans did, but he left us with a “test” to really be sure it was a robot and not a Human in case it ever became too hard to distinguish the difference.

In his Discourse on The Method he outlined a ‘Turing Test’ that predates the Alan Turing’s own test (we go over later in the article) by over 300 years (again, he was thinking about this in the 1600s !?):

For the first part of his test, many AI models have actually passed as of 2025.

Recent papers show our best language models have fooled humans consistently enough to make us believe we’re conversing with another person. The words are arranged appositely, the replies are contextual, the conversation flows naturally.

Even Descartes would have to concede this point, machines can now “declare thoughts” convincingly enough that we can’t tell the difference.

But his second test cuts deeper, into territory we still can’t navigate perfectly.

He argued that machines would “inevitably fail in certain others from which it could be discovered that they did not act from knowledge, but solely from the disposition of their organs.”

In other words, they’d be exposed as mechanisms, not minds.

Yet here’s the uncomfortable question Descartes didn’t pursue: are human actions fundamentally different? When we build, create, or respond, are we exercising some transcendent faculty, or are we just executing an incomprehensibly complex cascade of if-then statements written in neurons and chemistry?

Our organs—our brains, our nervous systems—have dispositions too. The difference between us and machines might not be that we’re not silicone and metal, but that we’re mechanical in ways so intricate we can’t recognize our own programming.

Unfortunately, this particular part of the conversation is out of the scope of this article however I explore what it “means to think” a but deeper here in this article if you want to continue reading.

Moving on from Descartes and continuing this “challenge of automation” we continue forward in history.

Jacques de Vaucanson and his Flute Player of 1737 actually played the flute—real breath from leather bellows, real fingers (covered in leather for pliability) covering real holes, a moving tongue controlling airflow. It knew twelve songs. Musicians complained it played shrilly, but it played.

His follow-up, the Digesting Duck, seemed even more miraculous: it ate grain, drank water, digested food in what Vaucanson called a “chemical laboratory,” and defecated through “the usual passage.”

The duck was a fraud. When magician Jean-Eugène Robert-Houdin examined it in 1844, he discovered the trick: pre-stored fake feces (green-dyed breadcrumbs) released while eaten grain collected in a separate compartment. Yet even as fraud, it advanced the conversation.

Voltaire wrote, “Without the voice of le Maure and Vaucanson’s duck, you would have nothing to remind you of the glory of France.”

The duck burned in a museum fire in Krakow around 1879, leaving only heat-warped wings in the ruins.

The era’s most sophisticated automata came from Pierre Jaquet-Droz and his son.

Their Writer, completed in 1772, contains over 6,000 parts and remains programmable today, you can still make it write any text up to forty characters by adjusting a wheel where each character is selected individually. It dips its quill in ink, shakes its wrist to prevent dripping, and its eyes follow the text as it writes.

At Switzerland’s Musée d’Art et d’Histoire, on the first Sunday of each month, it still writes messages. Sometimes it writes “I think therefore I am.”

Here was Descartes’s test made mechanical: a machine arranging words. Yet it wasn’t thinking—it was following instructions encoded in wheels and cams.

The question had fully shifted from “can machines think?” to “what’s the difference between thinking and perfectly imitating thought?”

The answer came from an unexpected source: the textile industry. Joseph Marie Jacquard’s loom, patented December 23, 1801, transformed weaving, but more importantly, it transformed the concept of instructions.

Before Jacquard, complex patterns required a master weaver’s constant attention, reading the design and manually selecting threads. Jacquard’s innovation was radical: the pattern became the program.

Chains of punched pasteboard cards fed through the loom. Each card controlled one row of the pattern.

Where there were holes, pins passed through to activate hooks that raised specific threads.

Where there were no holes, the pins pressed against the card, leaving threads in place.

The weaver just operated the loom; the cards contained the intelligence.

By 1812, France had 11,000 of these looms. Patterns that once took months to weave now took days. The cost of complex textiles plummeted. Lyon weavers rioted and attacked Jacquard, burning looms in fear of unemployment, the first tech backlash against automation.

When his Difference Engine project stalled in 1834, he conceived something far more ambitious: the Analytical Engine.

Not just a calculator but a general-purpose computer, capable of any calculation that could be described.

He adopted Jacquard’s punched cards wholesale but separated them into three types: operation cards (what to do), variable cards (what numbers to use), and number cards (data storage).

The architecture he designed, a Mill for processing, a Store for memory, input devices, output devices, is exactly what sits on your desk today, just made of brass and steel instead of silicon.

The machine was never built. The British government had already spent £17,500 on the failed Difference Engine—enough money to buy twenty-two steam locomotives. Babbage kept refining designs for forty years rather than building, creating what Tim Robinson’s 2021 analysis calls “120,000 words” describing six phases of evolution.

But the Science Museum proved it would have worked: they built his Difference Engine No. 2 between 1985 and 1991 using only techniques available in Babbage’s time.

It calculates perfectly.

What Babbage designed mechanically, Ada Lovelace understood conceptually.

In 1843, translating and annotating Luigi Menabrea’s article about the Analytical Engine, she added notes three times longer than the original.

Note G contained what everyone agrees was the first computer algorithm, a method for calculating Bernoulli numbers that demonstrated loops, conditional branching, and storage of intermediate results.

But more crucially, she saw what Babbage hadn’t fully articulated:

“The Analytical Engine has no pretensions whatever to originate anything. It can do whatever we know how to order it to perform.” - A. Lovelace

This became known as “Lady Lovelace’s Objection,” and it seemed definitive.

Machines followed instructions. They couldn’t create, couldn’t originate, couldn’t think.

They were, in her words, incapable of doing anything we didn’t know how to order them to perform. For a century, this settled the matter.

Until Alan Turing pointed out the flaw in 1950: what if we ordered them to learn?

Alan Turing’s 1950 paper “Computing Machinery and Intelligence” didn’t just propose the famous test, it systematically demolished nine objections to machine intelligence.

The sixth was Lady Lovelace’s.

Turing knew her statement well, quoted it directly, then observed something she couldn’t have foreseen: “The Analytical Engine has no pretensions to originate anything” only holds if we program machines to be predictable.

What if we programmed them to surprise us?

He proposed teaching “child machines” rather than programming adult intelligence directly.

“Instead of trying to produce a programme to simulate the adult mind, why not rather try to produce one which simulates the child’s? If this were then subjected to an appropriate course of education one would obtain the adult brain.”

The machine would learn, making mistakes, adjusting, improving. Its eventual behavior would be something we enabled but didn’t directly program, origination through education rather than explicit instruction.

But Turing understood something deeper about the nature of computing itself. In 1947, he’d written,

“If a machine is expected to be infallible, it cannot also be intelligent. There are several mathematical theorems which say almost exactly that.”

The quest for perfect determinism was the enemy of intelligence. Machines would need to guess, to be wrong, to work probabilistically—just like humans.

This insight becomes more profound when you realize that all our computers already work this way, we just pretend they don’t.

Computer Engineers reading this bear with me and give me the slightest philosophical reach here please.

Your CPU doesn’t execute instructions in order. It guesses what you’ll do next.

Modern branch predictors achieve 95% accuracy on typical applications, using neural networks—yes, the AMD Ryzen processor in your computer uses perceptron-based neural branch prediction—to anticipate which code will run.

When wrong, the penalty is severe: 10-20 clock cycles wasted. The 2018 Spectre vulnerability exposed that virtually every modern CPU could be exploited through these predictions.

We built our entire digital infrastructure on machines that guess. (grain of salt with this statement of course).

However, that’s not the only guessing that goes on.

Your computer gets hit by cosmic radiation constantly. (Stick with me here I promise this is important to the entire article and AI more importantly)

High-energy particles from distant supernovae slam into Earth’s atmosphere, creating cascades of secondary particles.

At ground level, 95% of particles capable of causing soft errors are neutrons.

They penetrate your computer case, your chip packaging, and when one hits just right—neutron capture by a silicon nucleus, releasing an alpha particle—it flips a bit.

IBM calculated one error per 256 megabytes of RAM per month for a typical desktop.

Google’s 2009 study found one bit error per gigabyte of RAM per 1.8 hours in the worst case.

Seriously, your computer needing to be turned off an back on again because “something stopped working” could have actually been a solar flare millions of miles away.

These aren’t uncommon errors.

In the 2003 Belgian election, data error led to a bit flip at position 13 gave candidate Maria Schauvliege exactly 4,096 extra votes—2^13, the smoking gun of a binary error.

A documented Super Mario 64 speedrun captured the moment an error flipped a bit at memory address 0xC5837800, teleporting Mario upward.

The Cassini spacecraft reported 280 single-bit errors per day in normal conditions, quadrupling during solar storms.

At airplane cruising altitude, the error rate increases 300-fold.

Every kilometer up doubles the neutron flux.

We’ve built an entire infrastructure of redundancy and error correction to pretend our computers are deterministic when they’re actually under constant bombardment from the probabilistic world we live in.

This is the reality we’ve abstracted away: your computer is not deterministic.

It’s probabilistic. It makes millions of guesses and corrections every second. Electrons tunnel randomly through transistors, quantum mechanics, not classical physics.

We’ve just gotten very good at hiding the chaos, creating the illusion of reliability from unreliable physics. Every computer is a voting machine where billions of unreliable components vote on the right answer, and through redundancy and statistics, they usually get it right.

If we can make random electrons look deterministic, why should anyone be surprised that we can make statistics look intelligent?

In March 2016, at Seoul’s Four Seasons Hotel, humanity realized something had changed.

The board game Go was supposed to be safe from computers—10^170 possible board configurations, more than atoms in the observable universe.

Experts at the 2012 Turing Centenary said a breakthrough would take twenty-plus years. Lee Sedol, one of the game’s greatest players, predicted he would win in a landslide.

He lost 4-1 to AlphaGo, a Machine Learning based AI system that was trained to play Go

But it wasn’t the victory that stunned observers—it was Move 37 in Game 2.

AlphaGo calculated this move had a 1 in 10,000 chance of being played by a human and then played it.

Commentators thought it was an error. Then they realized it was genius.

Lee Sedol left the room for fifteen minutes. When he returned, he played poorly for the rest of the game.

Later he said, “I thought AlphaGo was based on probability calculation and that it was merely a machine. But when I saw this move, I changed my mind. Surely, AlphaGo is creative.”

Lee got his revenge with Move 78 in Game 4—the “God’s Move” that AlphaGo calculated also had a 1 in 10,000 chance of being played.

The machine’s evaluation function plummeted from 70% win probability to below 50% and never recovered. But it was humanity’s only victory.

By November 2019, Lee retired from professional Go, stating he could never be the top player due to AI—”an entity that cannot be defeated.”

A year later, AlphaGo faced Ke Jie, who had held the world number one ranking since 2014.

It won 3-0.

Ke Jie cried after losing: “After humanity spent thousands of years improving our tactics, computers tell us that humans are completely wrong. I would go as far as to say not a single human has touched the edge of the truth of Go.”

Then DeepMind did something more unsettling. They released AlphaZero.

AlphaGo had learned from 160,000 human games before improving through self-play.

Just the rules and play against yourself. It mastered chess in four hours. Not four years or four months—four hours to surpass Stockfish, the world’s strongest traditional engine. Two hours to dominate shogi. Thirty hours to exceed the original AlphaGo at Go.

The chess community was particularly shaken.

AlphaZero searched 80,000 positions per second while Stockfish searched 70 million—nearly 900 times fewer positions—yet played stronger.

It wasn’t calculating more; it was understanding better.

Garry Kasparov, who had lost to Deep Blue in 1997, said:

“I can’t disguise my satisfaction that it plays with a very dynamic style, much like my own! It’s like discovering the secret notebooks of some great player from the past.”

Peter Heine Nielsen, coach to world champion Magnus Carlsen, put it differently: “I always wondered how it would be if a superior species landed on earth and showed us how they play chess. I feel now I know.”

AlphaZero rediscovered centuries of human chess knowledge, openings, endgames, positional play, in an afternoon.

Then it kept going, finding patterns humans had missed despite studying the game since medieval times. It sacrificed material for long-term advantage in ways that looked insane until twenty moves later when the opponent’s position collapsed.

It played with what observers called “purpose,” “feeling,” “intuition”—words we use when we can’t explain why something works, just that it does.

With AlphaZero and others like it, we built a machine that could abstract the process of abstraction itself.

Humans are quite good at this; in fact, it might be our best skill.

Every breakthrough in computing has done the same thing: taken something complex and made it simple to use without removing the output of complexity.

Assembly language didn’t replace machine code, it added a readable layer on top.

High-level languages didn’t replace assembly, NVIDIA still writes it for performance.

Compilers don’t replace programming, they translate human intent into machine action.

AI is the next compiler in this stack.

But instead of compiling code into instructions, it compiles human intentions into outcomes.

When you ask ChatGPT to write a poem, you’re invoking abstraction layers stretching back to those cosmic rays flipping bits in your RAM, up through error correction, through branch prediction, through operating systems, through neural networks trained on the entire internet.

Each layer exists simultaneously. We use the one appropriate to our task.

Every generation thinks they’ve invented thinking machines because every generation has added a new layer of abstraction.

Heron’s ropes and knots abstracted human performance into mechanical action. Al-Jazari’s cylinders abstracted musical knowledge into pin patterns. Jacquard’s cards abstracted weaving patterns into programs. Babbage abstracted calculation into general computation. Turing abstracted learning into algorithms. And now we’ve abstracted cognition into statistics.

The mistake is thinking these layers replace each other.

They don’t. They stack.

Right now, as you read this, errors are flipping bits in your device’s memory. Error correction is fixing them. Your CPU is guessing what instruction comes next.

Assembly code is managing memory allocation.

High-level languages are handling your browser.

JavaScript is rendering this page.

And if you ask an AI to summarize it, you’ll add another layer—one that can parse meaning from symbols, extract patterns from text, and respond in natural language.

Each layer seems impossible until it exists. Then we normalize it, forget the complexity beneath, and declare the next layer impossible.

When Ke Jie said no human had touched the edge of Go’s truth, he was wrong about one thing. Humans built the machine that found that truth. We wrote the algorithm that discovered what we couldn’t discover ourselves.

We abstracted our own limitations into a system that could transcend them.

The academics and clients who don’t know this history—who think AI appeared from nowhere or is a sham—miss the pattern.

They see ChatGPT as either a breakthrough or a waste of time instead of a continuation. They don’t realize they’re talking to math that runs on statistics that runs on matrices that run on code that runs on electrons that tunnel probabilistically through silicon that gets bombarded by cosmic rays.

They don’t see the stack of abstractions, each one impossible until it wasn’t.

The question has never been “can machines think?” That’s like asking if submarines swim.

The question is “what patterns will we abstract next?” What complexity will we compress into simplicity? What impossible thing will we make normal, then forget was ever impossible?

We’ve been building thinking machines for two millennia. We’re just getting better at pretending they’re not built on chaos, uncertainty, and approximation—the same foundation as human thought itself.

Every generation thinks they’ve hit the ceiling because they can’t see the next floor being built above them.

What’s impossible today that our children will find mundane? What ceiling are we staring at that’s actually just tomorrow’s floor? The one thing history teaches us about the limits of computing: they’re always closer than pessimists think and farther than optimists imagine. And someone, somewhere, is already building a machine to transcend them.

Everyone knows AI started in the 1950s. Everyone is wrong by about 2,000 years.

And everyone who thinks we’ve reached the limit now is about to be wrong again.