Instruction Following › The Pre-training Gap
Language AI HandbookAll chapters Instruction Following › The Pre-training GapOne section · Sections in this chapter2 / 12 ↓
Reading tools Definitions & inline links
Choose your expertise level to adjust how many terms are explained. Beginners see more tooltips, experts see fewer to maintain reading flow. Hover over underlined terms for instant definitions.
Article links
Make inline references clickable
Pre-trained language models like those we studied in Parts XVI through XX excel at one specific task: predicting the next token given a context. During causal language modeling, the model learns to assign high probability to continuations that match the statistical patterns in its training data. This training paradigm produces models with remarkable capabilities, but it creates a basic mismatch with how humans want to use these systems. The core issue is that predicting likely continuations and following your instructions are fundamentally different objectives, even though they both involve generating text.
The pre-training objective is both powerful and narrowly defined. When a model trains on web text and books, along with code, it learns to model the distribution of human-written content. It learns grammar, facts, reasoning patterns, and the conventions of countless writing styles. But none of this training explicitly rewards instruction compliance. The model has no concept of "requests" versus "documents" or "assistant responses" versus "document continuations." From the model's perspective during training, your question is simply one more piece of text to be continued in the most statistically plausible way.
Consider what happens when you prompt a base GPT-style model with "Write a poem about autumn leaves." The model doesn't interpret this as a request requiring action. Instead, it treats the text as a prefix to be continued in the most likely way given its training distribution. The model asks itself, in effect, what text would most plausibly follow these words based on everything it learned during pre-training. Depending on what similar text appeared in pre-training, it might:
- Complete the sentence: "Write a poem about autumn leaves falling gently..."
- Generate a meta-discussion: "Write a poem about autumn leaves. This is a common creative writing prompt..."
- Produce the poem directly if similar instructional content appeared frequently in training
This unpredictability stems from the fact that the pre-training objective optimizes for continuation probability, not instruction compliance. The model has no explicit training signal that says "when text looks like a request, generate a response that fulfills that request." From the model's perspective, there is no meaningful distinction between your instruction and any other piece of text. Everything is simply context to be continued. This basic design characteristic explains why base models, despite their impressive language understanding, often fail to behave as useful assistants.
A base model (or foundation model) is trained only on the language modeling objective, learning to predict the next token. An instruction-tuned model receives additional training specifically on instruction-response pairs, teaching it to interpret and follow your requests. The base model knows how to generate plausible text; the instruction-tuned model knows how to generate text that specifically addresses what you asked for.
The Format Problem
Beyond the objective mismatch, base models don't understand conversational conventions. When you interact with an assistant, there's an implicit structure: you provide a request, and the assistant responds. This turn-taking pattern requires the model to know when to stop generating (it has produced a complete response) and what role it should adopt (helpful assistant rather than document author). These conventions, which humans learn through years of social interaction, must be explicitly taught to language models.
Base models trained on web text have seen conversations, but they've also seen novels, code, advertisements, forum threads, and countless other formats. Without additional training, the model cannot reliably distinguish "this is an instruction I should execute" from "this is text I should continue in its style." A base model might generate a response to your question, or it might generate more questions, or it might continue as if writing a FAQ document, or it might shift into a completely different register. The model simply doesn't have a consistent understanding of its role in the interaction.
The format problem goes beyond mere stylistic inconsistency. When a base model encounters the beginning of an exchange that looks like a user asking a question, it has been trained on text where such exchanges appear in many different contexts: interview transcripts where questions are followed by more questions, Socratic dialogues where answers prompt further inquiry, news articles that quote questions and long analytical responses, and actual chat logs where responses vary wildly in length and style. The model must somehow choose among all these possibilities with no explicit mechanism for doing so. Instruction tuning resolves this ambiguity by establishing a clear, consistent convention: instruction-like input maps to response-like output, full stop.
Why Next-Token Prediction Isn't Enough
The pre-training gap can seem surprising because a model trained on so much text still needs explicit instruction data to learn this seemingly simple behavior. The answer lies in what next-token prediction learns and what it cannot learn on its own.
Next-token prediction learns correlational patterns: what tokens tend to follow other tokens. It captures the texture of language, the flow of arguments, the structure of documents. What it cannot learn from text alone is intentionality. When a text contains the phrase "Write me a poem about autumn," the model learns that these words tend to appear before poems. But it doesn't learn that this phrase represents a request that should be honored, as opposed to a sentence that should be continued. The distinction requires understanding the communicative intent behind language, not just its statistical regularities.
Humans understand communicative intent from a rich context of social interaction, shared conventions, and pragmatic reasoning that goes far beyond the words themselves. Language models, trained purely on the textual record of human communication, learn a great deal about the content of that communication but relatively little about its pragmatics. Instruction tuning provides the pragmatic training signal that pure text prediction cannot supply: here is what "following an instruction" looks like when done correctly, and here is how it differs from simply continuing text.
The pre-training gap wasn't immediately obvious as large language models first emerged. Early GPT models were evaluated primarily on text continuation tasks where the pre-training objective perfectly matched the evaluation criterion. The mismatch became starkly apparent when researchers and early users tried to deploy these models as assistants. GPT-3's 2020 release demonstrated both the impressive capabilities of large-scale pre-training and the erratic behavior that resulted from trying to use a completion model as an assistant. This practical frustration directly motivated the instruction tuning work that followed. Google's FLAN (2022), OpenAI's InstructGPT (2022), and the Stanford Alpaca project (2023) all emerged from the same recognition: raw capability and deployable utility are different things, and bridging the gap requires explicit supervision.