"AI" is not a technology. It's a label, and it always has been. It has been stamped on chess programs, spam filters, recommendation feeds, satnav routing and camera autofocus for decades, re-applied each time to whatever felt magical at that moment. What changed recently isn't that "AI" arrived. It's that one specific invention — the large language model — got good enough that the label finally stuck.
So when a product page, a pitch deck or a board paper says "AI", the accurate translation, nine times out of ten, is: an LLM, called over an API. That's not a put-down. The LLM is one of the most remarkable machines ever built, and understanding what it actually is (rather than what the label implies) is the difference between buying capability and buying vibes.
How an LLM works, without the mysticism
Strip away the branding and the interface, and the machine underneath is doing something you can hold in your head.
1. Text becomes tokens
The model doesn't see words or letters. Text is broken into tokens: fragments a few characters long. "Newcastle" might be one token; "weighbridge" might be three. Everything the model reads and everything it produces is a stream of these fragments.
2. Training is one game, played a trillion times
Training an LLM is a single exercise repeated at planetary scale: show the network a stretch of real text with the next token hidden, and ask it to guess. Wrong? Nudge a few of its billions of internal dials, the parameters, so that guess would have been slightly better. Then do it again, across more text than any human could read in a hundred-thousand lifetimes: books, code, contracts, forum arguments, documentation. No one programs rules in. The behaviour is grown, not written.
3. Prediction, done well enough, looks like understanding
Here's the part that surprises people: to get really good at guessing the next token, the network is forced to internalise the structure of everything it reads. You can't reliably continue a contract clause without absorbing how contracts work. You can't complete Python without encoding how Python behaves. You can't finish an argument without representing what the argument is. The prediction game, played at sufficient scale, compresses the patterns of human knowledge into the dials. That's why one machine can draft your board paper, refactor your codebase and explain your lease. It isn't ten products; it's one pattern engine that language-shaped work has in common.
4. The assistant is an interface, not the machine
The conversational persona, the one that's helpful, polite and answers in tidy paragraphs, is a later, thinner layer: the raw predictor is tuned on examples of good question-and-answer behaviour until helpfulness becomes its most likely continuation. The newest models add a further trick: they're trained to reason before answering, generating private working-out before the reply. But don't confuse any of that costume with the engine. The same machine that chats also powers code assistants, document extraction, search, and the agent systems that string tools together to do real work. Chat is one doorway into it — the narrowest one.
What that buys you, and what it doesn't
Understood plainly, the LLM's power is easy to state: anything that can be expressed as language-in, language-out is now automatable to a first draft. Summarise this. Extract every delivery date from these contracts. Turn this policy into a checklist. Write the integration glue between these two systems. Triage this inbox. That covers an enormous share of white-collar work, which is why the technology is not hype: we build production systems on LLMs and they earn their keep daily.
But the same mechanism sets the boundaries. A prediction engine produces the most plausible continuation, which is usually, though not always, the true one; that's why it can state falsehoods with perfect confidence, and why serious systems wrap it in retrieval, checks and human sign-off rather than trusting it raw. And it learned everything it knows from descriptions of the world, not from the world. Text about warehouses is not a warehouse. That gap between language about reality and reality itself is where the next generation of AI research lives, and it's the subject of the companion piece to this one: JEPA is not an LLM — AI built for the real world.
5 questions to ask anyone selling you "AI"
Precision when buying is the whole benefit of understanding the machine.
- Which model is actually underneath? Whose, which version, and who operates it?
- What task is it doing, concretely, and is that task language-shaped?
- What happens when it's wrong? Who or what catches the confident error before your customer does?
- Where do your data and prompts go, and what is the vendor allowed to do with them?
- What breaks on the day the underlying model is changed, deprecated or switched off?
Why the name matters
None of this is pedantry. Companies that think they're buying "artificial intelligence" expect judgement, and are surprised by confident nonsense. Companies that know they're deploying a language-pattern engine put it where language is the work, wrap it where truth matters, and get compounding value from day one. The label sets expectations; the architecture sets results.
Call it what it is. You don't architect around a marketing name — you architect around a machine. LittleMan · Digital Architects
Next in this pair: the machine that never read a word. JEPA is not an LLM →