How Generative AI Actually Works — a Plain-English Mental Model (No Math Required)

By /

You use it, and it works. You type a question, and a fluent, confident, often genuinely useful answer appears. But if someone asked you to explain how — what the thing is actually doing between your question and its answer — you might come up short. Most people do. We’ve quietly accepted a tool we can’t picture.

That’s a problem, because you can’t use a tool well when it’s a black box. If you don’t have a mental model of what a large language model is doing, you can’t predict when it will be brilliant and when it will confidently make things up, why the way you ask changes the answer, or which tasks are a great fit and which are a trap. The good news: you don’t need the math. The core idea is simpler than the hype suggests, and once it clicks, a lot of AI’s strange behavior stops being mysterious and starts being predictable. Let’s build that mental model from the ground up.

The one-sentence version: it predicts the next word

Here is the whole thing, compressed: a large language model is a system that, given some text, predicts what word most plausibly comes next — and then does that again, and again, one piece at a time, to build up an answer.

That’s it. When you ask “What’s the capital of France?”, the model isn’t looking up a fact in a database. It’s calculating that after that question, the most probable next words are something like “The capital of France is Paris.” It generates “The,” then “capital,” then “of,” each time asking the same question: given everything so far, what comes next? String enough of those predictions together and you get sentences, paragraphs, essays, code.

This sounds almost too simple to produce something that can write a sonnet or debug a program. The surprise of the last few years is precisely that it isn’t too simple. When you make the prediction engine large enough and train it on enough text, “predict the next word really, really well” turns out to require a startling amount of implicit understanding — of grammar, facts, reasoning patterns, tone, and the structure of arguments. The model had to absorb all of that to get good at the guessing game. But at its core, it’s still a guessing game.

Where the “knowledge” comes from: training

So how does it get good at the guess? Through training, which is a slow, one-time process very different from the fast back-and-forth you have with it later.

During training, the model is shown enormous quantities of text — a large slice of the public internet, books, articles, code. It plays a fill-in-the-blank game billions of times: part of the text is hidden, the model predicts it, and every time it’s wrong, its internal settings get nudged very slightly to be less wrong next time. Repeat that across trillions of words and the model gradually tunes billions of internal numbers (called parameters) until its next-word guesses are remarkably good.

Two consequences fall out of this that explain a lot of AI’s behavior:

Its knowledge is frozen and fuzzy. Everything the model “knows” was baked in during training, up to a cutoff date. It doesn’t know what happened after that, and it never memorized the training text word-for-word — it absorbed statistical patterns from it. So it’s less like a librarian who can fetch the exact page and more like someone who read a vast amount years ago and now recalls the gist, confidently but imperfectly. That’s why it can nail the general shape of an idea and still get a specific date, name, or number wrong.

It reflects its training data — strengths and flaws alike. The patterns it learned include our collective expertise, but also our biases, errors, and blind spots. The model isn’t a neutral oracle; it’s a compression of what humans have written, warts and all.

After this raw training, most assistants get a second, lighter phase — often using human feedback — that shapes them to be helpful, follow instructions, and stay on the rails. That’s what turns a raw next-word predictor into something that behaves like an assistant. But underneath the polish, the engine is unchanged: predict the next piece of text, one at a time.

Words become directions in “meaning-space”

Here’s the part that makes the guessing feel less mechanical. To predict well, the model can’t treat words as isolated symbols — it has to represent meaning. It does this by turning every word (really, every chunk of a word, called a token) into a long list of numbers that acts like a set of coordinates in a vast conceptual space.

In that space, things used in similar ways land near each other. “King” sits close to “queen” and “monarch.” “Paris” sits in a neighborhood with other capitals. Relationships even show up as directions — the step from “king” to “queen” points roughly the same way as “man” to “woman.” The model never gets told these relationships; it discovers them because they help it predict text.

You don’t need to track the coordinates. The useful takeaway is that the model operates on relationships between concepts, not a lookup table of facts. That’s why it can handle a question phrased in a way it has never seen, blend ideas fluently, and pick up your tone — and also why it can glide smoothly from something true into something false, because to the machine, a plausible-sounding falsehood lives right next door to the truth.

Why it sounds so confident even when it’s wrong

This is the single most important thing to internalize, so it’s worth being blunt: the model is optimized to produce text that is plausible, not text that is true. Those usually overlap — the most plausible continuation of a factual question is often the correct fact. But not always. When the model doesn’t “know” something, it doesn’t stop and say so. It does the only thing it can do: generate the most likely-sounding continuation anyway. The result can be a fluent, authoritative, completely invented answer — a fake citation, a plausible-but-wrong statistic, a function that doesn’t exist. This is what people mean by a hallucination.

And crucially, a made-up answer and a correct one are produced by the exact same process. The model has no separate “am I sure about this?” signal it’s hiding from you. Its confidence is a feature of its writing style, not a measurement of its accuracy. That single fact should reshape how you treat everything it tells you — which is exactly why checking AI output deserves its own framework. Fluency is not evidence. Verify anything you’ll rely on.

It has no memory — only what’s in front of it

One more piece and the model is complete. A language model has no ongoing memory of you between conversations, and even within a single chat, it’s working only from the text currently in view — the conversation so far plus your latest message. This visible stretch of text is called the context window, and it functions as the model’s entire working memory.

This explains a cluster of everyday behaviors. It “forgets” what you said much earlier in a very long conversation, because older text can fall out of the window. Starting a fresh chat wipes the slate — it doesn’t carry over what you told it yesterday. And giving it relevant material directly (paste the document, spell out the constraints, show an example) reliably improves the answer, because you’re loading the working memory with exactly what it needs rather than hoping the right pattern surfaces from training. When you understand that the model only knows what’s in the window, “give it more context” stops being a vague tip and becomes an obvious move.

What this mental model changes about how you use it

Hold all five pieces together — a next-word predictor, trained once on a huge fuzzy corpus, operating on concept relationships, optimized for plausibility over truth, with only its context window as memory — and the practical rules almost write themselves:

  • Treat it as a brilliant drafting and thinking partner, not a fact database. It’s superb at generating, rephrasing, brainstorming, summarizing, and explaining. It is unreliable as a source of precise facts you haven’t checked.
  • Verify anything that matters. Names, numbers, dates, citations, legal or medical specifics — confirm them against a real source. The confident tone is not a guarantee.
  • Give it context generously. Since it only knows what’s in the window, the quality of what you put in largely determines the quality of what comes out. This is also why how you ask shapes the answer so much — good prompting is really clear thinking made visible.
  • Use it to build your understanding, not replace it. The same tool can make you sharper or make you dependent, depending on whether you lean on it to skip thinking or to learn more actively.

None of this requires fear, and none of it requires blind trust — both of which come from not understanding the tool. What it requires is a clear picture of a genuinely remarkable machine: one that has read more than any human ever could and turned it into an uncanny sense of what words come next, but that has no idea, in any human sense, whether those words are true. Once you can see it for what it is — neither a magic oracle nor a mere autocomplete, but a plausibility engine of astonishing range — you stop being surprised by it and start being able to steer it.

Key takeaways

  • At its core, a large language model does one thing: predict the next chunk of text, over and over, to build an answer. It’s a guessing game made astonishingly capable by scale.
  • Its knowledge was baked in once during training on a huge body of text, then frozen — so it recalls the gist confidently but gets specific facts, dates, and citations wrong, and knows nothing past its cutoff.
  • It represents words as points in a vast “meaning-space,” operating on relationships between concepts rather than a lookup table — which is why it’s fluent and flexible, but can glide smoothly from true into false.
  • It’s optimized for plausibility, not truth. A correct answer and a hallucinated one come from the identical process, so its confidence reflects its writing style, not its accuracy. Verify anything you’ll rely on.
  • Its only working memory is the context window — the text currently in front of it. That’s why it “forgets,” why fresh chats start blank, and why giving it more relevant context reliably improves the output.

Go deeper

Want a clear, jargon-free foundation in how these tools work and how to use them well? Our course AI Literacy for Everyday People takes you from “black box” to genuinely confident, one plain-English step at a time.

Scroll to Top