The Most Used Software Nobody Understands
More than 800 million people now use ChatGPT every week, according to recent usage statistics, and yet if you asked a hundred of them how ChatGPT actually works, you'd mostly get shrugs. That's not a knock on anyone — the neural networks behind modern AI are genuinely strange, and most explanations either drown you in math or wave their hands and say "it's magic."
Here's the good news: you don't need a PhD to understand this. The core ideas behind ChatGPT — tokens, embeddings, attention, training — are surprisingly intuitive once someone explains them like a smart friend instead of a textbook. So let's do exactly that. No equations, no jargon without a translation, and by the end you'll understand not just how it works, but why it sometimes confidently makes things up.
One Job: Predict the Next Word
Strip away everything else, and ChatGPT does exactly one thing: it predicts the next chunk of text. That's it. You give it some words, and it calculates which chunk is most likely to come next. Then it appends that chunk and repeats — one piece at a time — until it decides it's done.
That sounds way too simple to produce essays, working code, and decent poetry. But here's the key insight: predicting the next word well requires understanding an enormous amount about the world. To finish the sentence "The capital of France is...", you need geography. To finish "She dropped the glass and it...", you need physics. To finish a half-written Python function, you need programming. Next-word prediction turns out to be a sneaky way of forcing a system to absorb knowledge about nearly everything.
Those "chunks" of text have a name: tokens. A token is usually a word or a piece of a word — "understanding" might get split into "under," "stand," and "ing." English text averages about 0.75 words per token, which is why AI pricing and context limits are always quoted in tokens. When people say a model can handle 128,000 tokens of context, they mean it can consider roughly 96,000 words of your conversation at once.
Embeddings: How Neural Networks Turn Words Into Meaning
Computers can't work with words directly — they need numbers. So the first thing a neural network does is convert each token into a long list of numbers called an embedding. And this is where things get genuinely beautiful.
Think of an embedding as a point on a map — except instead of two dimensions, this map has thousands. Words with similar meanings land near each other. "King" sits close to "queen" and "monarch." "Happy" sits near "joyful" and far from "miserable." The model doesn't store definitions; it stores locations, and meaning emerges from the geography.
The famous party trick: in this space, the directions themselves carry meaning. The path from "king" to "queen" points roughly the same way as the path from "man" to "woman." Nobody programmed that in. It emerged from the model noticing, across trillions of words, that these pairs behave similarly in sentences. As IBM's explainer on attention mechanisms puts it, these dense vectors encode semantics through their direction in space.
A useful analogy: embeddings are like the layout of a ridiculously well-organized library where every book sits next to its closest relatives — not alphabetically, but by meaning. The librarian never read you the books. They just placed them so well that location alone tells you what's inside.
How ChatGPT Actually Works: The Transformer and Attention
Now for the engine. ChatGPT is built on an architecture called the transformer, introduced in a 2017 Google research paper with the now-iconic title "Attention Is All You Need". That paper is arguably the most consequential computer science publication of the century so far, and its big idea is something called attention.
Here's the problem attention solves. In the sentence "The trophy didn't fit in the suitcase because it was too big," what does "it" refer to? You instantly know it's the trophy. But that requires looking back across the sentence and weighing which earlier word matters most. Older AI systems read text like a person peering through a paper-towel tube — one word at a time, with fading memory. Transformers read the whole passage at once, and attention lets every word "look at" every other word and decide which ones are relevant.
Think of it like a meeting where every participant simultaneously polls everyone else: "Does what you said change what I mean?" The word "it" sends out a query, "trophy" and "suitcase" raise their hands, and the model weighs their answers — settling on "trophy" because "too big" fits an object that doesn't fit, not a container.
Modern models run this process through dozens of layers, with many attention "heads" per layer, each specializing in different patterns — one might track grammar, another tracks long-range references, another tracks tone. Stack enough of these layers and you get a system that builds an increasingly sophisticated picture of what your sentence means before predicting what should come next.
The "neural network" part? It's a web of billions of numerical dials called parameters (or weights), loosely inspired by how neurons connect in a brain. Each dial nudges signals as they flow through the layers. The intelligence isn't in any single dial — it's in the pattern of all of them working together, the way a single pixel means nothing but a million pixels make a photograph.
Training vs. Inference: School vs. the Pop Quiz
People often imagine ChatGPT "learning" from their conversations in real time. It doesn't. There are two completely separate phases in a model's life, and keeping them straight clears up most confusion.
| Training | Inference | |
|---|---|---|
| What happens | The model's billions of dials get adjusted | The dials are frozen; the model just predicts |
| When | Months, before release | Every time you send a message |
| Data | Trillions of tokens from the internet, books, code | Only your conversation |
| Cost | Hundreds of millions of dollars | Fractions of a cent per response |
| Does it learn? | Yes — this is the only time | No — it remembers nothing afterward |
Training works like this: show the model a passage with the next token hidden, let it guess, measure how wrong it was, and nudge billions of dials slightly toward a better answer. Repeat trillions of times across a planet-sized pile of text. Early on the model produces gibberish; months and many millions of dollars of computing later, it has internalized grammar, facts, reasoning patterns, and style.
Inference is what happens when you chat. The model is frozen — it's taking the quiz, not studying. It reads your conversation, runs it through those frozen layers, and predicts tokens. When the conversation ends, nothing persists in the model itself. That's also why models have a knowledge cutoff: they know nothing after their training data ends unless they're given web search or documents to read.
RLHF: Teaching a Neural Network Some Manners
Here's the thing — a model that's only done next-word prediction is a savant with no social skills. Ask it "How do I bake bread?" and it might respond with more questions about bread, because online, questions often follow questions. It completes text; it doesn't help people.
The fix is called RLHF — reinforcement learning from human feedback — and it's the step that turned an autocomplete engine into a usable assistant. OpenAI detailed the approach in its InstructGPT research, and the recipe goes roughly like this:
- Human trainers write examples of genuinely helpful responses, and the model learns to imitate them.
- The model then generates multiple answers to the same prompt, and humans rank them from best to worst.
- Those rankings train a separate "reward model" — essentially a learned taste-tester that scores responses the way humans would.
- The main model then practices against that taste-tester millions of times, getting nudged toward answers people prefer.
Think of pre-training as twenty years of reading everything in the library, and RLHF as a finishing school that teaches you when to speak, how to be helpful, and what not to say at dinner. It's why ChatGPT answers questions instead of continuing them, declines harmful requests, and apologizes (sometimes too much).
RLHF is also where a model's "personality" comes from — and it's a big part of why different assistants feel different despite similar underlying architectures. If you're choosing between them, our comparison of Claude vs ChatGPT vs Gemini digs into how those personalities and strengths diverge in practice.
Why Neural Networks Hallucinate
Now the uncomfortable part. ChatGPT sometimes states falsehoods with total confidence — fake citations, invented court cases, plausible-sounding statistics that don't exist. The industry calls these hallucinations, and once you understand the machinery, you can see they're not a bug in the code. They're the system working exactly as designed.
Remember: the model is a next-token predictor, not a database. It doesn't look up facts; it generates text that is statistically shaped like facts. When you ask about something well-covered in its training data, the most probable continuation usually is the truth. But when you ask about something obscure — a niche academic paper, a small-town restaurant, your cousin's startup — the model still has to predict something, and what comes out is text with the right shape and no anchor to reality. A citation with a real-sounding journal, plausible authors, and a page number that leads nowhere.
A few things make this worse:
- No built-in "I don't know." Confident text vastly outnumbers hedged text in training data, so confidence is the default register. RLHF partially trains in humility, but imperfectly.
- Fluency masquerades as accuracy. The same machinery that makes the writing smooth makes the errors smooth too. There's no tonal difference between a fact it knows cold and one it just invented.
- It aims to please. RLHF rewards answers people rate highly, and people tend to rate confident, complete-looking answers higher than honest shrugs.
The practical defense is simple: treat the model as a brilliant, fast, occasionally overconfident colleague. Verify anything that matters — names, numbers, citations, legal and medical claims. Tools that ground responses in live search or your own documents help a lot, and so does prompting well; our guide to Mastering AI Conversations: Best Practices for Using Chat-Based LLMs at Work covers techniques that measurably reduce nonsense.
What This Means for How You Use It
Understanding the machinery changes how you work with these tools, in concrete ways:
- Context is everything. The model only knows what's in its training data and your current conversation. Paste in the relevant document instead of assuming it knows your situation. Specific prompts beat vague ones because they narrow the space of probable continuations.
- It's a reasoning engine, not a reference book. Use it to draft, summarize, brainstorm, transform, and explain — tasks where the shape of the output matters. Be skeptical when you use it as an encyclopedia.
- Long conversations drift. Everything runs through a finite context window. In marathon chats, early details fall out of view, and quality degrades. Starting fresh often beats pushing through.
- It doesn't learn from you mid-chat. Corrections apply within the conversation only. Tomorrow, the underlying model is the same frozen network it was today.
And this foundation is exactly what the next wave builds on. The industry is now wiring these predict-the-next-token engines into systems that can plan, use tools, and act on your behalf — if you want to see where that leads, our explainer on What is Agentic AI? picks up the story where this one ends.
The Takeaway
ChatGPT is not a digital brain, a search engine, or magic. It's a transformer — a neural network with billions of tuned dials — that converts your words into points in a vast space of meaning, uses attention to figure out what relates to what, and predicts one token at a time, having been finished and polished by humans ranking its answers. Everything remarkable about it, and everything frustrating, flows from that design.
The key takeaway: scale turned a humble objective — guess the next word — into something that looks an awful lot like understanding. Whether it is understanding remains a genuinely open question that researchers argue about. But you don't need to settle that debate to use these tools well. Know what the machine is actually doing, trust it where prediction shines, verify where it doesn't, and you'll get more out of it than the hundreds of millions of users still treating it like magic.
