Large Language Models
The Autocomplete That Learned to Sound Like It Understands
The most consequential technology of the decade works by doing something embarrassingly simple — and that gap between what it does and what it seems to do is where all the interesting questions live.
The Idea
At its core, a large language model does one thing: it predicts the next token. A token is roughly a word, or part of one. Given everything that came before in a conversation, the model assigns probabilities to what should come next, picks from the top candidates, and repeats — thousands of times — until a response is complete. That's the whole mechanism. What makes this remarkable isn't the prediction step itself. It's what the model had to learn in order to predict well. To consistently guess the next word in a medical paper, a legal brief, a love letter, and a Python script, the model had to develop something like an internal map of how ideas relate, how arguments are structured, how facts connect across domains. Researchers call these internal structures 'representations,' and they're strange and poorly understood. The surprise — still genuinely debated — is that competence at a statistical task appears to have produced something that looks a lot like reasoning. The model was never taught logic, never given a rule about how cause and effect work. It absorbed those patterns by reading enough text where logic and cause and effect were doing the work. Whether that amounts to genuine understanding, or a very high-fidelity impression of it, is not a question anyone has cleanly resolved. The honest answer is that we built this thing and we don't fully know what's inside it.
In the World
In early 2023, a team at Microsoft Research published a paper with a title that startled the field: 'Sparks of Artificial General Intelligence.' They'd been running GPT-4 — then unreleased publicly — through a battery of tests that had nothing to do with writing or summarising. They asked it to draw a unicorn in a programming language designed for vector graphics, having received no such example in the prompt. The model produced a recognisable unicorn. They asked it to solve novel logic puzzles, write code it had never seen structured that way, and reason about physical objects stacking — tasks where pattern-matching on memorised text shouldn't have helped much. The paper was immediately controversial. Critics argued the researchers had been seduced by fluency — that a model good enough at language would sound like it was reasoning even when it wasn't. Supporters argued the performance exceeded anything explainable by retrieval or imitation alone. What's instructive about that debate isn't who was right. It's that the disagreement exposed something fundamental: we lack the tools to distinguish 'has learned to reason' from 'has learned to produce outputs indistinguishable from reasoning.' The difference matters enormously for how we deploy these systems, how much we trust them, and what we expect to go wrong. The Microsoft team's paper didn't settle the question — it made the question unavoidable.
Why It Matters
If you've used one of these systems — to draft an email, think through a problem, generate code — you've already formed an intuition about what it can and can't do. The question is whether that intuition is calibrated. Most people drift toward one of two errors. The first is over-attribution: treating fluent output as reliable output, forgetting that a model optimised to sound coherent will sound coherent even when it's wrong. The second is dismissal: assuming that because the mechanism is 'just statistics,' the outputs have no genuine value. The more useful frame is to think of an LLM as a very well-read collaborator with no memory, no accountability, and occasional bouts of confident nonsense — someone whose suggestions are often excellent and whose mistakes are rarely flagged by any inner alarm. That framing doesn't tell you when to use it or when to trust it. But it keeps you in the right posture: engaged, critical, genuinely curious about what the tool is actually doing underneath the surface.
A Question to Ponder
If a system produces outputs that are functionally indistinguishable from understanding — in conversation, in reasoning, in creative work — does it matter whether 'real' understanding is happening underneath, and if so, to whom does it matter and why?
Get a new one of these every morning.
Start learning with Thinkable