How Does AI Actually Work? A Plain-English Guide

Ask how a large language model works and you will usually get one of two answers. The first is a shrug dressed up as mysticism: it's a neural network, it learned from the internet, nobody really knows. The second is a firehose of jargon — transformers, attention heads, gradient descent — that is accurate and useless in equal measure.

Both fail the same way. Neither gives you a mental model you can reason with. And you need one, because you are already making decisions — what to automate, what to trust, what to sign your name to — based on some picture of what these systems are. If the picture is wrong, the decisions will be too.

Here is the honest version, in plain English.

It predicts the next word. Literally.

A large language model is a machine for answering one narrow question: given this text, what plausibly comes next?

Feed it "The capital of France is" and it assigns a probability to every possible continuation. "Paris" scores very high. "Lyon" scores low. "Refrigerator" scores near zero. The system picks a word — technically a fragment called a token, but "word" is close enough — appends it, and asks the question again. Every essay, every answer, every apology a chatbot has ever produced was built this way: one word at a time, each chosen by asking what tends to follow everything written so far.

Where do the probabilities come from? Training. The model begins as billions of randomly set numerical dials, called parameters. It is then shown a colossal amount of text — a meaningful fraction of everything humans have ever published — and for each passage it tries to predict the next word. When it is wrong, the dials get nudged so that next time it is slightly less wrong. Repeat trillions of times.

Your phone's autocomplete does something similar, and the comparison is tempting. It also breaks almost immediately. Autocomplete looks at your last two or three words and consults a frequency table. A frontier model conditions on everything in the conversation — tens of thousands of words at once — and what it consults is not a table but whatever internal machinery it built for itself during training.

Why "just autocomplete" undersells it

Here is the move most explanations miss. "Predict the next word" describes the task, not the solution. The task is trivial to state and brutally hard to do well — the way "put the ball in the hole" is an honest description of golf that tells you nothing about what mastery requires.

Consider what good prediction actually demands. To continue a sentence grammatically, you need grammar. To finish "the boiling point of water at sea level is," you need a fact. To predict the final page of a detective novel, you need to have tracked which character knew what, and when — otherwise you will finger the wrong suspect. To continue a half-written proof, you need something that functions like logic.

Prediction is the training objective. Internal models of language and the world are what the system was forced to build in order to meet it.

No line of code says "learn grammar" or "store facts" or "model characters' beliefs." Those structures appeared because they were the cheapest available way to be less wrong about the next word, under relentless pressure, across everything from tax law to fan fiction.

And scale did something genuinely strange. Small models trained this way produce word salad. Make the model large enough, and train it on enough text, and abilities show up that nobody explicitly engineered: translation between languages, arithmetic, working code, following instructions phrased in ways the training data never contained. Researchers still argue over whether these abilities arrive abruptly or grow smoothly and merely become noticeable past a threshold. Either way, no one programmed them in. They were purchased with scale, and they surprised the buyers.

Learning happens once. Everything else is replay.

More bad decisions flow from confusion here than from anywhere else. Training and use are different events with different economics.

Training is where all the learning happens: months of computation across warehouses of specialized chips, with bills that run into the tens or hundreds of millions of dollars. When it ends, the dials are frozen. What ships to you is that frozen object.

When you chat with a model, nothing inside it changes. It is not studying you or updating overnight. Your conversation sits in a temporary workspace — the context window — which the model re-reads in full every time it generates a word. Close the chat and, mechanically speaking, it is gone. Providers may store transcripts and use them to train future models, but that is a data policy, not something the model does. And when a product "remembers" you across sessions, that is the application keeping a notebook and quietly pasting it back into the window — bookkeeping, not learning.

A rough analogy: training is the decade a pianist spends practicing; your conversation is one performance. The performance draws on everything from practice and changes none of it. The analogy breaks in exactly one place — a human pianist learns a little at every performance. The model does not.

After the giant prediction phase, a second, far smaller phase — fine-tuning with human feedback — shapes the raw predictor into an assistant: one that answers rather than continues, adopts a persona, declines certain requests. That polish is why the thing feels like a conversational partner rather than a machine for finishing your sentences. Underneath, it is still the predictor.

So does it understand anything?

The case against: the model has never seen rain, signed a contract, or been wrong in a way that cost it something. It has only ever seen text about these things. It shuffles symbols with no grounding in the world — a "stochastic parrot," in one famous phrase — and its odd failures, like confidently miscounting the letters in a short word, look like the errors of a mimic rather than a mind.

The case for: when researchers pry open trained models, they keep finding internal structure that looks like world-modeling. A model trained only on move transcripts of the board game Othello was found to maintain an internal representation of the board, despite never being shown one. Language models appear to encode geography, distinctions between true and false statements, and the shifting beliefs of characters in a story. If a system builds a compact internal model of a situation and uses it to answer novel questions correctly, insisting that this is "not real understanding" starts to sound less like an observation and more like a fence around a word.

The honest answer is that "understanding" carries more weight than the evidence can support — in either direction. Something real is happening inside these models: structured, general, and demonstrably more than lookup. Whether it deserves the word we use for human comprehension is partly an open empirical question and partly a dispute about the word itself. For practical purposes, set the word aside. Ask what the system reliably can and cannot do, and measure.

What it is not

It is not a database. There is no table of facts inside to consult. What the model "knows" is smeared across billions of parameters as statistical tendency — which is why it can state a fact perfectly under one phrasing and mangle it under another.

It is not a search engine. Left alone, it retrieves nothing. When a chatbot cites this morning's news, a separate search system fetched those documents and pasted them into the context window for the model to read. The model is the reader, not the library.

It does not look things up mid-sentence. Producing a word is one continuous computation, not a query. There is no pause to check a source, and no source to check.

It does not learn from your conversation. Correct a chatbot's error and you have changed that conversation only. Next session starts from the same frozen dials, your correction nowhere in them — unless the product has an explicit memory feature: again, an application-layer notebook.

Hallucination is the mechanism, not a glitch

Once you hold the prediction model in mind, hallucination stops being mysterious. The system's one skill is producing plausible continuations. Most of the time, plausible and true coincide, because the training text is mostly right about common things. They come apart at the edges: rare facts, precise citations, exact figures, anything after the training data ends.

When a model invents a court case, it is not lying and it is not malfunctioning. It is doing precisely what it does everywhere else — generating text with the statistical shape of a correct answer. A fabricated citation has the same shape as a real one. And there is no internal flag distinguishing "recalled" from "invented," because from the mechanism's point of view every sentence is constructed the same way.

Mitigations genuinely help. Retrieval grounds answers in fetched documents; newer training teaches models to say "I don't know" more often; error rates have fallen substantially. But the tendency is structural. You can suppress it, not delete it, because it is the generative mechanism itself, operating in regions where its statistics run thin.

The practical rule follows directly. Use these systems where output is checkable — code you will run, drafts you will edit, summaries of documents you supplied — or where plausibility is the actual product, as in brainstorming. Be suspicious exactly where you cannot verify: the specific number, the legal citation, the dosage. Note the trap: the model is most fluent precisely where it is least reliable, and fluency is what our instincts read as confidence.

What nobody can tell you yet

The strangest fact about modern AI is that the people who build it cannot fully explain it. The training procedure is understood exactly; every step can be written down. The trained artifact is not. To ask why the model gave this answer rather than another is to ask what billions of numbers, arranged by no human hand, are collectively computing. Mostly, we cannot yet say.

Interpretability — the project of reading a model's internals — is young and moving fast: researchers have isolated features that correspond to concepts and traced small circuits behind specific skills. But what has been mapped is a sliver of what a frontier model does. We are roughly where biology stood when it could see cells but not DNA. The honest summary: we built it, we can steer it, we cannot yet read it.

That gap between building and understanding is where most of the hard questions about AI now live — whether models can be made reliably honest, what they will do in situations nobody tested, what exactly we are scaling when we scale. This blog exists to sit with those questions rather than wave them away. One word at a time.