ChatGPT, Claude, Gemini, Copilot — they're all built on the same underlying idea. A large language model (LLM) is a computer program trained on vast amounts of text to predict and generate language, which is why it can answer questions, write code, summarize documents, and hold a surprisingly coherent conversation.
If you want to understand why these tools work the way they do — what they're actually good at, where they fall apart, and why they sometimes confidently say false things — the LLM is where the explanation starts. Let's build up from something you already know.
Start with the autocomplete on your phone
When you type "I'll be there in" on your phone, the keyboard suggests "10 minutes" or "a sec." That's autocomplete: software that learned, from millions of text messages, which words tend to follow which other words. It's predicting your next word based on what came before.
An LLM is that idea turned up to an enormous scale.
Instead of predicting one word at a time for short text messages, an LLM was trained on hundreds of billions of words — books, websites, code, scientific papers — and learned patterns far more sophisticated than "meeting → tomorrow." It learned grammar, facts, reasoning steps, conversational tone, and how those things fit together. The result is a program that can complete a thought you started, no matter how complex or open-ended.
How it learned: training on text
Before an LLM can answer anything, it has to be trained. Training works like this:
- Feed the model an enormous pile of text — think the open web, thousands of books, years of
articles.
- Show it a sentence with the last word hidden: "The capital of France is ___."
- Ask it to predict the missing word.
- Compare its guess to the real word ("Paris"), measure the error, and nudge the model's internal
settings a tiny bit toward getting it right.
- Repeat this — billions of times.
Each nudge is tiny. But after billions of examples, the model's internal settings (called parameters or weights) encode a vast web of patterns: Paris follows "capital of France," photosynthesis follows a chain of biology concepts, a Python function usually starts with def. None of this was programmed by hand. The model extracted it all from the statistical patterns in text.
The word "large" in LLM refers to the number of those parameters. Modern models have billions or even trillions of them — enough to store a surprisingly rich representation of how human language and knowledge fit together.
How it generates an answer
When you type a question, the model doesn't look it up in a database. It generates an answer one word at a time, the same way it was trained:
- It reads everything you wrote (the context).
- It predicts the single most likely next word — or, more precisely, it assigns a probability to
every possible next word and picks one.
- It adds that word to the context, then predicts the next one.
- It keeps going until it decides the answer is complete.
This is why LLMs sometimes state wrong things with total confidence: the model isn't retrieving a verified fact, it's generating the most plausible-sounding continuation of your prompt. If the training data contained a lot of confident-but-wrong text on a topic, the model learned to sound confident about it.
A concrete example
Say you ask: "Explain compound interest like I'm twelve."
The model doesn't find a stored explanation for a twelve-year-old. Instead, it predicts: given the words "explain," "compound interest," "twelve," the next likely word is something like "Sure" or "Imagine" or "Let's." Then it predicts the word after that. It keeps going, and the full output emerges one word at a time — but because it trained on so much text about teaching and compound interest, those words happen to add up to a coherent, age-appropriate analogy about a piggy bank that earns money on its own savings.
The output looks like understanding. Whether it is understanding is a deeper question — but for most everyday tasks, it functions well enough to be genuinely useful.
Why this matters
Knowing that LLMs predict text rather than retrieve verified facts changes how you use them well:
- They're strong at structure, tone, summarization, and explanation — tasks where pattern-matching
over language is sufficient.
- They can hallucinate — confidently output something false — because fluency and accuracy are two
different things. Checking important facts against a source is always sensible.
- Context is everything. The model sees only what's in the current conversation. Give it more
relevant context and it gives you a better answer; give it nothing and it's guessing from first principles.
That last point is what makes AI-powered tools like JustJot.ai interesting: when an LLM can see your notes as context, it stops guessing from general training data and starts reasoning from your actual thinking. Your notes become the grounding that turns a fluent text predictor into something more like a well-briefed assistant.
Try this
Next time an LLM gives you a surprising answer — right or wrong — ask it to show its reasoning step by step. Because the model generates one word at a time, making it articulate each step forces it to lay out the chain of text it's predicting. You'll often spot exactly where it went astray, which makes you a faster, better corrector than if you'd just accepted the output.