How Prediction Becomes Ability

Lesson 4 of 4 in Next-Token Prediction, Really.

Here is the puzzle this module has been building toward. The training objective is one sentence long: put probability on the next Token. Nobody trained a translation module, a coding module, or a reasoning module. Yet large models translate, write working code, and produce chains of argument. Where did that come from?

The honest answer starts with an observation about the objective itself: to predict text well, you must model whatever produced the text. Text is not a bag of words — it is the visible trace of grammar, facts, procedures, and thought. Push the loss low enough and the shortcuts run out; the cheap tricks (memorize common phrases, learn word frequencies) stop paying, and the remaining loss can only be squeezed by capturing more of the structure behind the words.

Make that concrete. To keep beating the loss on code, frequency tricks are not enough — whether the next token is ) or , can depend on a variable defined two hundred lines earlier, so tracking program state pays off in loss. To keep beating it on parallel text — the same content in two languages, which the internet is full of — mapping meaning across languages pays off. To keep beating it on worked solutions — proofs, derivations, debugging sessions — predicting each step from the previous ones looks a lot like following the reasoning. None of this was asked for by name. Every bit of it reduces surprise, and reducing surprise is the only thing training rewards. Prediction is not the opposite of understanding; under enough pressure, it is a ruthless demand for whatever understanding-shaped machinery helps predict.

From guessing games to in-context learning

1948-07-01 — A Mathematical Theory of Communication:
Shannon modeled English as a chain of ever-better n-gram approximations and defined entropy as the limit they approach. The core framing — language as a probability distribution over symbol sequences — is the root idea every language model since has refined.
1951-01-01 — Prediction and Entropy of Printed English:
Shannon used human next-letter guessing to estimate the entropy of English at roughly one bit per character. It established prediction quality as the yardstick for a language model — the ancestor of today’s perplexity evaluations.
2019-02-14 — GPT-2 and staged release:
A 1.5B-parameter GPT trained on web text showed surprising zero-shot ability across tasks, and OpenAI staged its release over misuse concerns. It was the first clear signal that scaling one recipe broadens capability — and the first mainstream release-policy debate.
2020-01-01 — Scaling laws for neural LMs:
Kaplan et al. measured loss falling as smooth power laws in parameters, data, and compute, with architectural details mattering far less. It turned "make it bigger" from a hunch into a predictive engineering discipline.
2020-05-01 — GPT-3: in-context learning:
At 175B parameters, GPT-3 exposed a new interface: in-context learning, where the model performs tasks from instructions and a few examples in the prompt, with no gradient updates. Prompting began to replace fine-tuning as the primary way to program a model.
2022-03-01 — Chinchilla: compute-optimal training:
Hoffmann et al. showed most large models were undertrained: at a fixed compute budget, parameters and training tokens should grow roughly in step (about 20 tokens per parameter). It reset scaling strategy toward smaller models trained on far more data.
2023-02-01 — LLaMA: the open-weights era begins:
Meta trained 7B–65B models Chinchilla-style on trillions of tokens and released the weights to researchers; the 13B model rivaled GPT-3. The weights spread far beyond the research program and ignited the open-weights ecosystem of fine-tunes and local inference.
2023-03-14 — GPT-4:
A multimodal model (text and image input) with large capability jumps — top-decile bar-exam performance among them — whose technical report disclosed neither architecture nor training data. It marked both the new capability frontier and the industry’s turn away from openness.

This idea is much older than the Transformer. In 1951, Claude Shannon published Prediction and Entropy of Printed English — an experiment in which human subjects played exactly the game you played in lesson one, guessing the next letter of English text, so Shannon could measure how predictable the language is. Two things in that paper matter here. He established that ordinary text carries heavy statistical structure — roughly, that much of English is redundant given context. And his measuring instrument was the point that this whole module turns on: how well you predict text is a direct measure of what you know about it. The subjects’ guesses drew on spelling, grammar, idiom, and meaning all at once; prediction quality quietly summed up all of it. Everything from N-gram model models to LLMs is that insight, industrialized.

For decades, prediction quality bought fluency but little else. Then scale changed what the game produces. Brown et al. (2020) — the GPT-3 paper, Language Models are Few-Shot Learners — showed that a sufficiently large Base model could do something no one had directly trained: show it a few examples of a task in the prompt — English–French pairs, say — and it picks up the pattern and continues it, with no weight updates at all. The training game does not change, the Weights do not move; the model has simply gotten good enough at ‘continue the pattern’ that a few demonstrations pin the pattern down. The paper named this in-context learning, and it is why prompting works at all — why you can hand a general model a new task at 2 a.m. and have it done by 2:01. What was a research curiosity is now the interface to every LLM you will ever call.

Do new abilities appear as models grow, or do they accumulate? This is a live scientific dispute — the Emergence debate — and you should know both sides, because how you answer changes how much you trust any claim about what the next bigger model will do.

The claim: emergent abilities

Wei et al. (2022), Emergent Abilities of Large Language Models (arXiv:2206.07682), collected cases where performance on a task sits near random for smaller models and then climbs sharply once model scale crosses some range — defining an emergent ability as one ‘not present in smaller models but present in larger models’, and therefore not predictable by extrapolating small-model results. Multi-digit arithmetic and word-unscrambling are among their examples. If this picture is right, scaling carries genuine surprise in both directions: capabilities you did not plan for can arrive abruptly — and so can risks nobody tested for, which is partly why the paper drew safety attention as well as engineering attention.

The critique: a mirage of metrics

Schaeffer, Miranda & Koyejo (2023), Are Emergent Abilities of Large Language Models a Mirage? (arXiv:2304.15004), answer: the sharpness may live in the ruler, not the model. Many ‘emergent’ results use all-or-nothing metrics — exact-match arithmetic scores zero credit until every digit is right. A model can be improving smoothly and predictably underneath (each token a bit more likely to be correct) while such a metric stays flat and then leaps. Swap in smoother metrics, they show, and several celebrated jumps flatten into ordinary gradual curves; they could also manufacture ‘emergence’ in ordinary vision models just by choosing harsh metrics. On this view, ability grows continuously — the discontinuity is an artifact of how we grade.

In production

The engineering consequence of this whole lesson: never ship on a capability claim. Benchmarks and launch posts describe other people’s tasks; whether prediction has become ability for your task, on your traffic, is an empirical question — and every major cloud gives you machinery to answer it before production.

AWS

Amazon Bedrock ships evaluation tooling for exactly this gap: assemble prompt datasets from your own use cases and run candidate models against them — automatic metrics where they fit, human review panels where judgment is required — before routing production traffic. The mechanism to internalize is that model choice is an evaluated decision with artifacts you can re-run when a new model version lands, not a one-off reading of a leaderboard.

Azure

Azure AI Foundry builds evaluation into the model catalog workflow: side-by-side comparison of candidate models on your own prompt data, plus evaluators for quality and safety you can run pre-deployment and keep running after. The evergreen practice: treat every ‘model X can now do Y’ claim as a hypothesis, and gate promotion to production on your own evaluation runs, versioned like any other release artifact.

Google Cloud

Vertex AI provides a generative-AI evaluation service that scores model outputs on your own datasets against criteria you define, so a capability claim becomes a testable pipeline step rather than a purchasing belief. Because in-context ability is prompt-sensitive, the durable habit is evaluating your actual prompts — templates, context, and all — not simplified stand-ins.

Interactive checkpoint quiz (1 questions) — open this page in a browser to take it.