Your Father’s AI
Where AI was conceived can be argued, but the name came from John McCarthy, who coined the term artificial intelligence for a 1956 workshop at Dartmouth with Marvin Minsky, Claude Shannon and Nathaniel Rochester. MIT is where what we might now call the old AI, your father’s AI, grew up. McCarthy and Minsky founded the MIT AI Project in 1959, and McCarthy created Lisp, the language much of early AI was written in.
MIT was not alone. BBN, an MIT spinoff, Carnegie Mellon under Allen Newell and Herbert Simon, Stanford, SRI, Bell Labs and IBM were all part of it.
These were very clever people, working on computers that were a joke compared to a $50 Raspberry Pi. They were trying to get computers to go beyond accounting and do what living beings do: reason, see, understand.
What It Achieved
They solved particular pieces of humanlike ability, each one built by hand. ELIZA (1966), a simple pattern-matching program that simulated a psychotherapist, fooled people into confiding in it. SHRDLU (1970) understood English commands about a world of toy blocks. SRI’s Shakey was the first mobile robot that could reason about its actions. Optical character recognition, image recognition and, later, speech recognition steadily improved. The Kurzweil Reading Machine (1976) read ordinary print in almost any typeface aloud to the blind. At the time, that was considered AI.
The Wall
Then it hit a wall. OCR got really good, and image and language recognition got better, but none of it came close to the reasoning and thought of a person. Each problem took a rare commodity, some of the smartest people on the planet, and the solutions never scaled. A system might understand a little English, but there were 100 other languages, each needing the same effort all over again.
Neural networks, the idea behind today’s AI, were set back early. Frank Rosenblatt’s perceptron (1958) learned from examples. But in 1969, Minsky and Seymour Papert’s book Perceptrons proved the limits of its simple single-layer form, and funding for the approach dried up.
By the mid-1970s, about 50 years ago, the field entered what became known as the first AI winter. Britain’s 1973 Lighthill Report judged that AI had failed to deliver, and DARPA cut funding. Expert systems revived hopes in the 1980s, then also failed to scale, bringing a second winter late in that decade. For decades, the work aimed at what we now call AI moved at a snail’s pace.
A Glimmer in the Winter
Computers got much faster, but nothing like today. I’m not an AI historian, but I would say the one area that showed real promise was reinforcement learning. In 1992, Gerald Tesauro at IBM built TD-Gammon, a backgammon program that taught itself by playing millions of games against itself, using a neural network to judge positions. It reached near world-champion level and even changed how top human players opened the game. Tesauro was a genius and way ahead of his time. Researchers knew TD-Gammon well, but it never captured the public imagination.
Other famous programs were different. IBM’s Deep Blue, which beat world chess champion Garry Kasparov in 1997, was basically old technology, brute-force search plus handcrafted chess knowledge on special hardware, that benefited from faster computers. It was not a reasoning machine.
Reinforcement learning was a way for a program to teach itself, and it was essentially the approach behind AlphaGo, the DeepMind program that beat Lee Sedol, one of the greatest Go players of all time, in 2016. Go had resisted the search methods that worked for chess, and after decades of effort nobody had figured out how to make them work. There were far more choices at each turn, and, worse, no one could write rules for judging who was winning in the middle of a game. AlphaGo used TD-Gammon’s basic approach. While many would question this, my opinion is that Gerald Tesauro could have written that Go program if he had had the computers available when AlphaGo was built. There was nothing fundamentally new, just newer engineering and far more computing power.
But reinforcement learning by itself is never going to teach a program to read a book. Backgammon and Go are bounded problems, with fixed rules, a clear score and a clear winner. Writing and answering questions have no such scoreboard; you can only judge good writing and good answers by having examples of them.
One thing about it is very interesting, though. A program that teaches itself by playing millions of games against itself ends up with knowledge nobody can read. It is not a computer program as we know it, a list of instructions a person wrote and can follow. Its knowledge of how to play is encoded in a huge blob of numbers, not understandable by anyone. When AlphaGo made its famous move 37 against Lee Sedol, experts thought it was a mistake. It turned out to be brilliant, and no one, including its builders, could say why it chose it.
Still, the leap from playing a game to the kind of AI we all use every day now was huge.
A Humble Beginning
Modern AI had very humble beginnings. The idea was to take actual human text, hide what comes next, and let the computer try to guess it. At the simplest level, it was really guessing the next character. Today’s systems guess the next token, which is a word or a piece of a word, but the game is the same.
The early versions did not even need a neural network. You could simply count, in a big body of text, which letters tend to follow which, then generate new text by picking a likely next letter, then the letter after that, and so forth, with some randomness thrown in. Claude Shannon did exactly this in 1948, producing gibberish that looked surprisingly like English. In the 1980s, a Bell Labs program called Mark V. Shaney used the same trick on words and posted nonsense to online forums that some readers took for a real, if odd, person. Fed all of Shakespeare, these methods wrote funny-sounding text with little meaning that was still recognizably Shakespeare-like.
Combining the guessing game with neural networks made the computer far better at it. Instead of just counting, the network learned patterns across much longer stretches of text. By around 2011 researchers were training neural networks to write character by character, and in 2015 Andrej Karpathy made the idea famous with a network trained on Shakespeare that turned out convincing fake plays, complete with character names and stage directions.
I don’t want to dive into the deep science here, but in essence, machine learning applied to vision had already taught us something crucial: massive amounts of data let us train these networks to do humanlike things. Hundreds of the smartest people on the planet, writing code by hand to recognize images, could not beat one engineer with a large database of labeled images (this image is a cat) and a powerful enough computer, an engineer who didn’t need to know anything about how to solve the problem with normal programming. The turning point came in 2012, when a neural network called AlexNet, trained on graphics chips using ImageNet, a collection of millions of labeled photos, beat every hand-built system by a wide margin.
This could really scale. With enough pictures, you could learn to recognize almost anything. The old scaling problem, needing armies of experts to hand-build every new ability, was gone.
Interestingly enough, when one of these recognizers makes a mistake, nobody knows why. Even today, people can trick them by changing just a few pixels, or by making tiny changes to an image that no human would notice, and a whole field of security has grown up around protecting image recognizers built this way from being fooled.
This shows one of the challenges when an application’s logic is a blob of numbers instead of a well-written computer program that can be code reviewed. Now you have to test it as a black box.
The Large in LLM (Large Language Model)
At first the main problem was that training was very serial. The older networks read text one piece at a time, in order, so training on terabytes of human text was slow and impractical. The Transformer, introduced by Google researchers in 2017, broke this barrier by letting the network break up the work in a way that it could be done in parallel, so training could run across thousands of chips at once.
And “large” is not really large. It is bigger than anything you can imagine. Today’s models are trained on trillions of tokens, words and pieces of words, more than a dedicated reader could get through in thousands of lifetimes. “Large” understates it by many orders of magnitude.
Then it turned out that the simple game of hiding letters or words in real text and guessing what comes next could be scaled up to an astronomically huge level. Almost magically, it produced humanlike text, the same Shakespeare trick we already talked about, but far more convincing.
What few anticipated was that this trivial game, played at that size, would produce something that looks like reasoning: systems that explain, summarize, write code and solve problems they were never explicitly taught. That gap, between a simple game and profound results, is the central mystery of modern AI.
There are deep reasons why this simple guessing game, trained on massive amounts of data, yields what it does, but they are not something I can explain in a short piece like this. Essentially, you have to struggle with the whole idea of evolution and what it really means: how a simple process, repeated on an enormous scale, produces complex living beings, and even simple ones. Evolution had billions of years, which is a very long time. These models get their version of it in months, on enormous banks of computers.
From Guessing the Next Word to Answering a Prompt
A prompt is really just some text, and you are asking the computer to predict what comes next. Type “What is the capital of the US?” and that is some text. The computer tries to guess what would come next, and it says “Washington, D.C.” It has gotten really good at guessing.
The way it learns is by reading. It learns what good text looks like by reading trillions of words of human writing. After that, there are lots of different ways it is fine-tuned. These are some of them:
Human ratings. People rate its answers, and it learns from their ratings to respond like a helpful assistant instead of rambling on.
Learning to reason. Since 2024, the newest “reasoning” models have also been trained with reinforcement learning to work through problems step by step before answering. TD-Gammon’s idea of a program teaching itself has come full circle.
But underneath, it is still the same guessing game. The game is simple, though; what it takes to win it is not. To predict the next line of a mystery novel or a computer program, the network appears to build its own internal picture of the story or the code.
The Catch
The catch is that we don’t really know what it is doing.
But what is it thinking? Nobody really knows. Even the people who build these systems are only beginning to peer inside them. Yet, undeniably, it does a good job.
It’s a black box.
People now have a lot of experience getting the behavior they want out of it, and you can see how far that has come. Mostly it comes from getting good data, but other things are involved too, and various methods are used to fix problems as they show up. Essentially, it is more like metallurgy than chemistry. For thousands of years, smiths made fine steel by trial, error and hard-won recipes, long before anyone understood the atoms involved. Building AI today is much the same: we know what works far better than we know why.
These are not programs in the traditional sense, where you can step through them piece by piece when they don’t do what you want. That is the nature of the beast. They work very well, but they sometimes have problems, and while debugging and fixing them is becoming better understood, they don’t have the certainty of a normal program, or of your father’s AI.
Where This Leaves Us
Whether these systems can ever become sentient beings with free will of their own is just speculation. Their behavior is a combination of their training and what you ask them to do, and that is always being refined. So far there is little evidence that anything more sinister than that is going on, but who knows? The people who create the models have their opinions, but they don’t really know either. What we all can see is how much smarter and more capable they are getting.
Here, scientists often forget to apply the scientific method: a hypothesis, an experiment, and peer review. Before rushing off to predict sentient beings, you have to produce experiments that would show it. Right now, people are speculating in an unscientific fashion about situations that so far have simple explanations that don’t need science fiction. When a model in a contrived lab test appears to scheme or resist being shut down, the experiment shows what the system can do under those conditions, not that it has a survival instinct or a will of its own. Such behavior is still worth testing for, because a machine doesn’t need to be conscious to cause harm. But nothing so far shows anything sinister, or a HAL 9000 from 2001: A Space Odyssey.
I looked at several of these cases in Rogue AI, or Sloppy Humans?. Every time, the headline blamed the machine, and the fine print pointed to how the humans set up the test.
Testing is important. The whole science of how to program and test these systems is not as deterministic as normal programming, but it is clear that people are getting better at understanding it.
Mary Shelley’s Victor Frankenstein stitched together parts he understood and, with a spark, brought to life something he did not understand. Our modern Frankenstein was assembled the same way, from humble pieces: a guessing game, a neural network, and the written words of millions of people. It works, often brilliantly. But like Victor, its makers can watch what it does far better than they can explain why.