What Is Instruction Tuning? Turning a Base Model Into an Assistant

// In plain English

A fresh base model is a spectacular autocomplete engine and nothing more. It read a huge slice of the internet and learned exactly one skill: given some text, predict the next word. Ask it "Write me a haiku about autumn" and it might not write a haiku — it might continue your sentence with "and three more poems about the seasons," because online, a line like that is often followed by more requests, not by an answer. It doesn't know it's supposed to help you. It only knows how text tends to flow.

Instruction tuning is the step that fixes this. It's a round of supervised fine-tuning where you show the model thousands of examples of the shape (instruction → good response). After enough examples, the model stops merely continuing your text and starts doing what you asked. The raw next-word predictor becomes an assistant.

Picture a brilliant new hire who has read every book in the library but has never had a job. They know an enormous amount, yet on day one they don't understand workplace conventions — when someone asks a question, you answer it; when given a task, you complete it. Instruction tuning is the onboarding week. You don't teach them new facts; you teach them the format of being useful: a request comes in, a helpful response goes out.

// Why it matters

If you've only ever used ChatGPT, Claude, or Gemini, you've never met a raw base model — and that's the point. Everything you think of as "talking to an AI" depends on instruction tuning having already happened. Without it, the most powerful model in the world is almost unusable for normal people.

Here's the concrete difference. Hand the same prompt to a base checkpoint and to its instruction-tuned sibling and you get two very different behaviours:

The base model isn't broken or dumb. It is doing its one job perfectly — predicting plausible continuations. It just was never told that a question is an invitation to respond. Instruction tuning is what installs that single, enormous behavioural shift.

For a builder, this matters in two practical ways. First, when you download a model from a hub, you must pick the right variant: a -base checkpoint for further training, or an -instruct (or -chat) checkpoint to actually use. Grab the wrong one and your app produces gibberish. Second, instruction tuning is the cheapest, highest-leverage way to give a model a behaviour — a tone, an output format, a domain specialty — without the expense and complexity of the later preference-training stage. For a fuller picture of the two checkpoint types, see base vs instruct models.

// How it works

Instruction tuning sits in the middle of the standard model-building pipeline. It comes after the giant, expensive pretraining run and before the optional, finicky preference-training stage. Each step changes the model's behaviour in a different way.

The training data is the whole story

Pretraining feeds the model raw, unlabelled text — books, code, web pages — and asks it to predict the next token. Instruction tuning feeds it something structured and curated: pairs where a human (or a strong model) wrote a prompt and a high-quality answer. The model still learns by next-token prediction, but now the "next tokens" it's learning to produce are the helpful response. A single training example looks like this:

{
  "instruction": "Summarize this email in one sentence.",
  "input": "Hi team, the Q3 launch is delayed two weeks because the\nvendor missed the parts shipment. New target is Oct 14.",
  "output": "The Q3 launch is pushed to October 14 due to a delayed\nvendor parts shipment."
}

Collect tens of thousands of these — across summarizing, translating, coding, explaining, refusing harmful requests, following formats — and the model generalizes the meta-skill: when text arrives shaped like an instruction, produce text shaped like a helpful answer. Crucially, the volume here is tiny compared to pretraining. Pretraining sees trillions of tokens; a good instruction-tuning set might be a few thousand to a few hundred thousand examples. You are not teaching new facts — those are already in the weights from pretraining — you are teaching a response style.

The chat template glues it together

During training, those pairs are wrapped in special marker tokens that show the model where a user's turn ends and the assistant's turn begins. This wrapping is the chat template, and the instruction-tuned model learns to expect it forever after. It's why you address an instruct model with roles like user and assistant rather than just dumping plain text — the template is the language it was taught to speak.

// Instruction tuning vs RLHF

Instruction tuning and preference training (the most common form is RLHF, reinforcement learning from human feedback) are the two stages that turn a base model into a polished assistant, and beginners constantly blur them. They run one after the other and solve different problems.

Instruction tuning teaches the model what kind of thing to do — answer the question, follow the format, attempt the task. It learns from examples of correct responses. But "correct" and "the response a human would actually prefer" aren't the same. Two answers can both be factually fine while one is clearer, safer, or better-toned. Instruction tuning can't easily capture that, because writing one perfect gold answer for every prompt is hard, and human preference is about comparing options.

Preference training fills that gap. Instead of one ideal answer, you show the model pairs of responses with a human judgment of which is better, and you nudge the model toward the preferred style. That's where the helpful, harmless, honest polish of a production assistant largely comes from.

// When you'd instruction-tune your own model

You almost never start from a raw base model and do the entire onboarding yourself — that's a lot of data and compute. The common move is to take an already instruction-tuned open model and run a small additional SFT pass to specialize it: teach it your company's tone, a strict JSON output shape, or a niche domain vocabulary. That's still instruction tuning, just a focused top-up.

1. Collect pairs. Gather a few hundred to a few thousand high-quality (prompt → ideal response) examples that demonstrate exactly the behaviour you want. Quality beats quantity here — a clean small set outperforms a large noisy one. See preparing a fine-tuning dataset.
2. Format with the chat template. Wrap every pair in the same role markers the base instruct model expects, so training and inference look identical.
3. Train cheaply. Rather than updating all the weights (full fine-tuning), most people use a parameter-efficient method like LoRA that adjusts a tiny fraction of the model — far less GPU, far less storage. See full fine-tuning vs PEFT.
4. Evaluate honestly. Hold out examples the model never trained on and check it follows instructions without forgetting its general skills. See evaluating a fine-tuned model.

// Going deeper

Once the basics click, a few deeper ideas explain why instruction tuning works as well as it does — and where it can quietly go wrong.

*It's mostly eliciting, not teaching.* A striking finding in the field is that instruction tuning needs surprisingly few examples to work. That's strong evidence the base model already learned how to summarize, translate, and reason during pretraining — instruction tuning mainly teaches it to surface those abilities on demand, in the right format. You're flipping a switch the pretraining already wired, not building new circuitry. This is why a few thousand great examples can transform a model's behaviour.

Catastrophic forgetting is the main hazard. Push too hard on a narrow instruction set and the model can lose general competence it had before — it gets great at your one task and noticeably worse at everything else. Smaller learning rates, fewer epochs, mixing in diverse data, and parameter-efficient methods like LoRA all help keep the broad skills intact while you add the new behaviour.

Data quality dominates. Because the model copies the style of your responses, sloppy, inconsistent, or biased example answers get faithfully reproduced. Errors in your gold outputs don't get averaged away — they get learned. Many of the strongest open instruct models came not from more data but from carefully filtered, deduplicated, high-quality data. Garbage demonstrations in, garbage habits out.

Synthetic and distilled data. Writing instruction-response pairs by hand is slow, so a large share of modern instruction data is generated by a stronger model and then filtered. When the teacher model's outputs are used to train a smaller student, that's distillation-adjacent territory — a cheap way to bottle a big model's behaviour into a small one, though you inherit the teacher's blind spots too.

The throughline, true since the first instruct models: pretraining gives a model its knowledge and raw ability, and instruction tuning gives it its manners. Almost everything that feels like "the AI understood me and helped" traces back to this one supervised step quietly sitting between the giant pretraining run and the final polish.