How AI Was Actually Born: From Dumb Spreadsheets to Neural Networks

An essay from 9horsemen's founder. For practical help running a business, see the blog.

Part 1 of 4 in the AI for Founders series. See all parts.

Listen to this episode of Why Your Software Sucks on Spotify.

TL;DR:

1. Early AI was not synthetic intelligence; it was an elaborate decision tree where human programmers had to manually write rules for every single scenario.
2. Neural networks flipped computing on its head: instead of writing explicit instructions, engineers fed machines massive datasets and let algorithms adjust numerical “dials” via trial and error.
3. Stripping away the marketing reveals that a neural network is not an artificial brain, but a massive web of statistical weighted averages designed to match patterns.

The history of AI starts in 1956, when scientists tried to write intelligence down as rules, and runs through decades of dead ends to today’s neural networks, which learn patterns from data instead. Here’s that story in plain words, without the sci-fi.

What is AI, really?

A very fast pattern-matching calculator, not a mind: it learns patterns from examples and applies them to new inputs.

Every time mainstream media talks about Artificial Intelligence, they show an image of a metallic humanoid skull glowing with blue light or a synthetic baby reaching for a human hand.

Silicon Valley loves this imagery. It lets tech executives price their software like magical alchemy, encouraging the public to believe that scientists have breathed life into silicon chips.

Strip away the marketing, and modern artificial intelligence is not an alien consciousness waking up in a server farm. It is a mathematical calculator that has gotten extraordinarily fast at recognising patterns.

To understand how we arrived at modern AI, you have to throw out the idea of “thinking” entirely.

Think about a standard mechanical vending machine.

• You insert two one-dollar bills.
• You press the buttons for “C-4”.
• The internal mechanism turns a metal coil, and a bag of salted peanuts drops into the tray.

Did the vending machine “know” you were hungry? Did it make a conscious decision to sell you peanuts instead of pretzels?

Of course not. It followed an unbending chain of physical rules.

Early computer programming operated on the exact same logic, scaled up to millions of electrical circuits. Humans wrote every rule by hand. If the user does X, execute Y. If event Z occurs, trigger A.

For decades, that approach built our modern world—from banking spreadsheets to space shuttles. But it had a massive limitation: the computer was completely helpless whenever it ran into a situation its human programmer forgot to write down.

When did AI start?

In 1956, at a summer workshop at Dartmouth College, where scientists coined the term and set out to write intelligence down as rules.

In the summer of 1956, a small group of mathematicians and scientists gathered at Dartmouth College in New Hampshire. They coined the term “Artificial Intelligence” with an audacious proposal: they believed that every aspect of learning and human intelligence could be described so precisely that a machine could be built to simulate it.

They assumed that cracking human intelligence would take a single summer of intense collaboration. It took more than seventy years, and we are still not there.

The early era of AI is known as Symbolic AI or Rule-Based Systems. The philosophy was straightforward: human intelligence is built on formal logic. If we want a machine to act smart, we just need to translate human knowledge into code using strict conditional logic:

• IF an animal has feathers and flies, THEN it is a bird.
• IF a patient has a fever of 102 degrees and a sore throat, THEN test for strep.
• IF a chess opponent moves their pawn to square E4, THEN respond by moving a pawn to E5.

+-------------------------------------------------------------+
|              TRADITIONAL RULE-BASED COMPUTING                 |
|                                                               |
|   [Human Rules]  +  [Input Data]  ===>  [Deterministic Output]|
+-------------------------------------------------------------+ |

These early systems worked well for closed environments with strict boundaries. If you fed a computer the official rulebook of chess, it could calculate future moves faster than an average human.

In business, companies built massive “Expert Systems.” An expert system was essentially an enormous corporate manual turned into code. A loan approval system, for instance, might consist of ten thousand nested rules written by senior underwriters:

• Is the applicant’s credit score above 650?
• Has the applicant been employed at their current job for more than two years?
• Does their monthly debt payment exceed 40% of their gross income?

If all the boxes checked out, the screen flashed a green approval. If any condition failed, the application hit a rejection screen.

It felt revolutionary at the time, but these systems were fundamentally brittle. They possessed zero common sense. If a borrower had an atypical financial profile that the human programmers never anticipated, the software had no ability to improvise. It either crashed or spit out an answer that made no practical sense.

Why did early AI fail?

Because many things people do easily, like recognising a cat, can’t be written down as rules, so rule-based systems hit a wall and funding dried up.

By the late 1970s and 1980s, the initial funding for AI dried up, kicking off what computer scientists call the first “AI Winter.” Billions of dollars had been poured into expert systems, but computers still couldn’t handle tasks that a three-year-old child accomplishes effortlessly.

Consider how you recognise a domestic cat.

• You can identify a cat whether it is a fluffy Persian lounging on a sofa, a hairless Sphynx walking across a dark room, or a rough cartoon sketch drawn on a napkin.
• You recognise it if it is missing a leg, curled into a tight ball, or seen from behind in bad lighting.

How would you write an explicit rulebook for that?

If you write a rule stating: “A cat has two triangular ears, four legs, whiskers, and a tail,” the computer immediately fails when shown an image of a cat that lost an ear in a fight, or a cat facing directly towards the camera with its tail hidden behind its body.

Attempted Rule: "Two triangular ears + four legs + whiskers + tail"

Image 1: Cat curled into a ball       --> Fails (No legs visible)
Image 2: Cat facing camera directly   --> Fails (Tail hidden behind body)
Image 3: Manx cat                     --> Fails (Naturally born without a tail)
Result: The rule-based engine crashes against reality.

Human programmers spent decades trying to manually code edge cases for real-world perception. They wrote rules for shadows, rules for fur textures, and rules for ear angles.

It was an impossible engineering dead-end. The physical world is far too messy, chaotic, and nuanced to be described entirely in static IF/THEN statements.

To get past this barrier, researchers had to abandon the idea of writing rules altogether.

What is machine learning?

Instead of giving a computer the rules, you give it examples with the right answers and let it work out the rules itself.

The breakthrough came from an ideological pivot. Instead of handcrafting rules and feeding them into a machine alongside data, what if we gave the machine the data alongside the final answers, and forced the machine to figure out the rules on its own?

+-------------------------------------------------------------+
|              MACHINE LEARNING PARADIGM SHIFT                |
|                                                             |
|   [Input Data]  +  [Known Answers]  ===>  [Discovered Rules]|
+-------------------------------------------------------------+

Imagine teaching a child how to bake chocolate chip cookies.

• The Rule-Based Approach: You sit the child down and force them to memorise a 400-page chemistry textbook detailing heat convection, gluten protein binding, and sugar caramelisation temperatures before they ever touch an oven.
• The Machine Learning Approach: You put the child in a kitchen with flour, butter, sugar, and chocolate. You show them ten batches of world-class cookies and ten batches of burnt, salty disasters. You let them bake hundreds of experimental batches, tasting the result after each attempt and tweaking their ingredient ratios until the cookies match the gold standard.

That transition—from hardcoding logic to statistical trial and error—is the birth of Machine Learning.

The computer was no longer treated as a clerk following a rigid manual. It was treated as an automated optimisation engine, running thousands of numerical adjustments until its output aligned with real-world examples.

How does a neural network work?

Think of a huge sound mixing desk with millions of dials: training nudges each dial until the output matches the right answers.

To pull off this trial-and-error learning, researchers returned to an idea first proposed in the 1940s: the Artificial Neural Network.

The name is responsible for an enormous amount of modern confusion. Early researchers called them “neural networks” because they drew loose theoretical inspiration from how biological neurons fire in animal brains.

In reality, a neural network is not a synthetic brain. It does not think, feel, or experience epiphanies.

A neural network is best understood as a massive, multi-layered sound mixing console—the kind you see in a high-end music recording studio.

[INPUT LAYER]           [HIDDEN LAYERS]          [OUTPUT LAYER]
(Raw Pixel Data)       (Knobs & Dials)           (Prediction)

   Pixel 1  -------> [ Dial ] --- [ Dial ] ------> [ Cat: 89% ]
   Pixel 2  -------> [ Dial ] --- [ Dial ]
   Pixel 3  -------> [ Dial ] --- [ Dial ] ------> [ Dog: 11% ]

Picture an enormous audio mixing board that contains millions—or even billions—of tiny mechanical knobs and slider switches:

• The Input Layer: On the far left, you plug in raw sensory data. For an image, this means converting every individual pixel’s brightness and colour into numbers.
• The Output Layer: On the far right, you have a set of labelled indicator lights. One light says “Cat,” another says “Dog,” and a third says “Bicycle.”
• The Hidden Layers: In the middle sit layers upon layers of interconnected knobs. In computer science, these knobs are called Weights and Biases.

When you first construct the network, all the knobs are set completely at random.

• You feed the system a digital photo of a golden retriever.
• The pixel numbers travel through the cables, pass through the randomly positioned knobs, and multiply against whatever values the dials happen to be set to.
• Because the dials are random, the light on the far right flashes: “This is a Cat with 94% confidence.”

The machine made a wild, incorrect guess. In a traditional program, that would be the end of the line. But a neural network uses a mathematical mechanism called Backpropagation.

The computer compares its erroneous answer against the true label provided by a human (“Golden Retriever”). It measures the margin of error between its guess and reality.

Then, it works backward across the entire mixing board, from right to left. It nudges every knob a fraction of a millimeter in the direction that would make the “Dog” light glow slightly brighter and the “Cat” light slightly dimmer.

Step 1: Input image of a Dog.
Step 2: Dials are currently random. Output flashes: "Cat (94%)".
Step 3: Error detected. The true label was "Dog".
Step 4: Backpropagation runs backward through the board.
Step 5: Every knob is nudged slightly to make "Dog" more likely next time.
Step 6: Repeat this process across 50,000,000 images.

If you perform that calibration loop once, nothing useful happens.

If you run that loop across tens of millions of photos over weeks of computing time, those dials slowly settle into mathematically optimal positions.

The dials in the early layers learn to react to high-contrast edges and straight lines. The dials in the middle layers begin reacting to textures, curves, and basic geometric shapes. The dials in the final layers react to complex combinations—like two pointed shapes sitting above a patch of fur.

When you show that trained network a brand-new photo of a cat it has never encountered before, the pixel values flow through those carefully calibrated dials and illuminate the correct label.

The computer does not know what a cat is. It does not know that cats purr, shed fur, or chase mice. It simply knows that this particular arrangement of pixel numbers successfully matches the mathematical pathway that triggers the “Cat” light.

Why did AI take until the 2010s to work?

Because neural networks needed three things the 1990s didn’t have: huge amounts of data, fast specialised chips and better training maths.

If the theoretical maths behind neural networks was established decades ago, why did it take until the 2010s for AI to become practical?

Building useful neural networks requires three distinct resources that were impossible to secure in the twentieth century:

1. Massive Datasets (The Raw Material): A neural network cannot self-calibrate using five or six examples; it requires millions of labelled samples to prevent the dials from locking into narrow coincidences. Until the internet, digital photography, and platforms like ImageNet became ubiquitous, researchers simply did not have enough digital data to feed hungry algorithms.
2. Specialised Computing Power (The Engine): Calculating mathematical adjustments across millions of interconnected dials requires immense compute resources. Traditional central processing units (CPUs) were designed to execute complex tasks one step at a time. The revolution occurred when researchers realised that Graphics Processing Units (GPUs)—the silicon chips built to render 3D video games—were uniquely optimised to run thousands of simple maths problems simultaneously.
3. Refined Maths Architectures (The Fuel): Early networks suffered from technical stumbling blocks, such as the “vanishing gradient problem,” where adjustments to knobs in the early layers faded out before they could take effect. Breakthroughs in mathematical optimisation finally allowed researchers to stack dozens of layers deep without the maths breaking down.

Did AI exist before ChatGPT?

Yes: for decades it quietly ran spam filters, card fraud checks, mail sorting and factory inspections behind the scenes.

Before Silicon Valley launched large language models into everyday consumer products, this style of statistical pattern-matching was quietly running behind the scenes of global commerce.

It wasn’t writing poetry or debating philosophy. It was deployed as an unglamorous, high-speed sorting engine for structured industrial problems:

• Spam Filters: In the early 2000s, email services shifted from manual blacklists to naive Bayesian pattern matching. The software scanned thousands of incoming emails, noticed that messages containing combinations like “wire transfer,” “inheritance,” and “pharmacy” had a 99.2% statistical correlation with fraud, and routed them straight to the spam bin.
• Credit Card Fraud Detection: Banking systems processed millions of real-time transactions, establishing a statistical baseline for your spending habits. If your card was swiped at a gas station in Chicago and twelve minutes later attempted to purchase electronics in Miami, the anomaly detection dials tripped, freezing the account before human analysts could review the charge.
• Optical Character Recognition (OCR): Postal systems deployed early neural networks to read messy, handwritten ZIP codes on physical envelopes, using pixel-classification dials to automatically route letters through conveyor belts.
• Factory Defect Inspection: High-speed cameras mounted over bottling lines used image-classification models to inspect bottle caps at a rate of fifty units per second, identifying hairline fractures faster and more reliably than any tired human eye.

These early wins had one thing in common: they were narrow, specialised, and verifiable.

The software did not try to write the email; it decided whether the email was trash. It did not try to manage the bank; it flagged an unusual numerical spike.

Does AI actually think?

No: it matches inputs to outputs using patterns, like a clerk following a rulebook in a language they don’t understand.

The modern temptation to anthropomorphise software is strong because we are psychologically wired to see agency wherever we encounter complex behaviour. When a program correctly flags a malignant tumor on an X-ray, we assume the machine “understands” human health.

In 1980, philosopher John Searle proposed a thought experiment called the Chinese Room that remains the definitive answer to this illusion.

+-------------------------------------------------------------+
|                     THE CHINESE ROOM                        |
|                                                             |
|   [Native Chinese Speaker]                                  |
|            |                                                |
|            v  (Passes paper with Chinese characters)        |
|   +-----------------------------------------------------+   |
|   |  LOCKED ROOM                                        |   |
|   |  - A person who speaks only English.                |   |
|   |  - A massive English rulebook of symbol matching.   |   |
|   |  - Looks up symbol shapes; copies matched symbols.  |   |
|   +-----------------------------------------------------+   |
|            |                                                |
|            v  (Hands back perfectly matched response)       |
|   [Native Chinese Speaker]                                  |
|   Conclusion: "The person inside understands Chinese!"      |
|   Reality: The person understands zero Chinese.             |
+-------------------------------------------------------------+

Picture an English-speaking clerk locked inside a windowless room. The clerk understands only English—not a single word of Chinese.

Outside the room stands a native Chinese speaker who writes questions on slips of paper and slips them under the door.

Inside the room, the clerk has access to a massive filing cabinet filled with instruction manuals written in English:

• “When you see a squiggly line shaped like 人 followed by a box shaped like 口, look up Rule 4,219.”
• “Rule 4,219 says: Grab a piece of paper, draw the symbol 吃, and slide it back under the door.”

The clerk follows the instructions mechanically. To the person standing outside the room, the answers coming under the door make perfect sense. The person outside concludes: “Whoever is inside that room speaks fluent Chinese.”

Yet the clerk inside does not know what those symbols mean. The clerk has no idea if they are discussing the weather, poetry, or a recipe for duck soup.

They are simply matching arbitrary shapes according to a reference manual.

A neural network is the Chinese Room operating at millions of operations per second.

• It does not understand that an image is a dog.
• It does not understand that a financial alert represents real money.
• It does not understand that a medical scan shows a living human being.

It matches numerical inputs to numerical outputs via statistical pathways tuned by previous data.

When you understand that foundational reality, the marketing mysticism dissolves. Modern AI is not an emerging digital mind. It is a powerful, highly capable, and occasionally fragile statistical pattern matching engine.

What does the history of AI teach businesses?

That AI works best inside firm rules: the breakthroughs came from scale plus structure, not from trying to copy a human mind.

The history of artificial intelligence proves one enduring truth: breakthroughs don’t happen when models attempt to replicate human consciousness; they happen when computational scale meets structured, deterministic constraints. Today, neural networks have solved the raw generation problem, but translating high-dimensional statistical weights into reliable, revenue-generating software still demands disciplined architecture.

That principle drives how we build at 9horsemen.

Our first product, Gallop, uses AI to understand a description of a local service business, then builds its website, online booking and business app from fixed, tested parts. The AI decides what to build; tested code does the work. If you run a service business, it’s free to build and takes a few minutes.

If you’re building software of your own, Gallop isn’t that tool. I write about building it in the other essays, talk about it on the podcast Why Your Software Sucks, and tell the long version in my story.