# What is an LLM, and how does it actually make words?

> A jargon-free explanation of large language models: what they are, why they're basically a very good autocomplete, and how they write one word at a time.

Source: https://rfriedmann.de/blog/what-is-an-llm/
Published: 2026-03-19 · Track: learn · Level: Beginner

You type a question into ChatGPT or Claude, and a fluent answer appears. Behind
that is a thing called an **LLM**. People talk about them constantly and rarely
say what they actually are. So let's open the box, no background needed.

<aside class="defbox"><span class="tag">In plain words</span><b>LLM (large language model):</b> a computer program that has read an enormous amount of text and learned its patterns well enough to continue any piece of writing in a believable way. <b>Large</b> = huge (both the text it learned from and its own size), <b>language</b> = it works on text, <b>model</b> = a system that captures patterns.</aside>

That's the whole thing. It's not a search engine and it's not a database of
facts. It's a pattern machine for language.

## The one trick: guess the next word

Here's the part that surprises people. Everything an LLM does comes down to a
single, almost silly-sounding skill: **given some text, guess what comes next.**

Take a half-finished sentence. The model looks at it and scores every word it
knows for how likely it is to come next.

<aside class="defbox"><span class="tag">In plain words</span><b>Token:</b> the model doesn't quite work in whole words. It works in <b>tokens</b>, which are short chunks of text, often a word, sometimes part of one. For this article you can just think "word."</aside>

<figure class="chart">
<div class="chart-title">"The cat sat on the ___" - the model's top guesses for the next word</div>
[diagram omitted — see the page for the chart]
<figcaption class="chart-caption">The model scores every possible next word, then picks one. Numbers here are illustrative, but this guess-and-pick is exactly what happens, every single word.</figcaption>
</figure>

It doesn't *know* the answer is "mat". It estimates that "mat" is the most likely
continuation, and usually goes with it. Same as the autocomplete on your phone,
except trained on a large slice of everything ever written, so its guesses are
startlingly good.

## Then it does it again. And again.

One guess only gives you one word. To write a whole answer, the model takes the
text *including the word it just added* and guesses again. And again. A sentence
grows like this:

<div class="buildup">
<div class="row">The <span class="new">cat</span></div>
<div class="row">The cat <span class="new">sat</span></div>
<div class="row">The cat sat <span class="new">on</span></div>
<div class="row">The cat sat on <span class="new">the</span></div>
<div class="row">The cat sat on the <span class="new">mat.</span></div>
</div>

Each line is one trip through the guesser. The new word gets added, the whole
thing goes back in, and it predicts the next one. That loop, running very fast,
is the answer typing itself out on your screen. There's no grand plan for the
sentence; it's built one believable step at a time.

## Under the hood: a neural network

I've been treating the guesser as a black box. Time to crack it open a little. The
thing doing the guessing is a **neural network**.

<aside class="defbox"><span class="tag">In plain words</span><b>Neural network:</b> a web of simple units ("neurons"), loosely inspired by the brain, arranged in layers. Each unit is wired to the next layer by connections, and every connection carries a number called a <b>weight</b>.</aside>

Here is the shape of it:

<figure class="chart">
<div class="chart-title">A neural network: numbers in, patterns in the middle, next-word scores out</div>
[diagram omitted — see the page for the chart]
<figcaption class="chart-caption">Each dot is a simple unit; each line carries a weight. Real models have far more units and dozens to hundreds of layers, but the shape is exactly this.</figcaption>
</figure>

Read it left to right. Your text, as numbers, enters on the left and flows through
layer after layer. At each step, every unit adds up the signals reaching it, each
one turned up or down by its connection's weight, and passes the result on. Out
the right side come the scores for the next word, the same ones you saw in the bar
chart earlier.

The "deep" in "deep learning" just means *many* layers stacked up. Small networks
have a few; the big language models have dozens to well over a hundred. And those
weights, the dial on every connection, are exactly the "billions of numbers" I
keep mentioning. A large model can have hundreds of billions of them. Which raises
the obvious question: who sets all those dials?

## Setting the dials: training

Nobody sets them by hand. A fresh network starts with random weights and guesses
pure gibberish. Training is how it gets good.

<aside class="defbox"><span class="tag">In plain words</span><b>Training:</b> before you ever use it, the model is shown mountains of text and made to play "guess the next word" billions of times. Each time it guesses wrong, every connection weight gets nudged a little in the direction that would have helped. Do that long enough and those weights quietly soak up grammar, facts, and styles.</aside>

So the model's "knowledge" isn't a list it looks things up in. It's baked into
those connection weights as patterns. "Paris" reliably follows "the capital of
France is" because that pairing turned up countless times in training, and the
weights settled into it.

## Why it sometimes makes things up

This also explains the thing everyone complains about.

<aside class="defbox"><span class="tag">In plain words</span><b>Hallucination:</b> when a model states something false with total confidence. It happens because the model is predicting <em>plausible</em> text, not <em>true</em> text. It has no fact-checker inside.</aside>

If a convincing-sounding but wrong continuation is what the patterns suggest, the
model will write it just as smoothly as a correct one. It isn't lying; it
genuinely has no separate notion of "true". That's worth remembering every time
an answer sounds authoritative.

## A dial for creativity

One last thing you may have heard of. When the model picks from its ranked
guesses, there's a setting that decides how adventurous it is. Turn it down and
it almost always takes the top guess: predictable, repeatable, a bit dry. Turn it
up and it sometimes reaches for lower-ranked words: more surprising and creative,
and more likely to wander off. That's the "temperature" knob, and it's the same
guessing machine either way, just bolder or more cautious about which word it
commits to.

## From idea to something you can run

That's an LLM: a next-word guesser, trained until its guesses are good, run in a
loop. The catch is that doing all that guessing fast enough to feel instant takes
serious engineering, which is its own rabbit hole. If you want to see how a real
engine pulls it off, start with
[how an engine turns a model file into words](/blog/how-imp-works-model-to-token/),
then the [speed story on a single graphics card](/blog/serving-30b-models-rtx-5090/).