What Fine-Tuning Changes, and What It Cannot Add

What the gradient actually does

Fine-tuning shows the model an input and a target output, then nudges every trainable weight in the direction that would have made those target tokens slightly more likely. Repeat a few thousand times. That is the entire mechanism, and everything fine-tuning is good and bad at follows from it.

What it moves efficiently is the conditional shape of the output: given an input like this, produce an output like that. Register, length, structure, formatting, when to refuse, when to ask a clarifying question, which of several behaviours the model already has should fire here. These patterns appear in every example, so every gradient step reinforces them. A hundred examples can visibly change tone. Two thousand can lock a JSON schema so hard the model stops emitting prose at all.

What it does not add: facts

A fact appears in your dataset a handful of times. The base model saw trillions of tokens. To make one fact reliably retrievable you are fighting an enormous prior with a tiny signal, and gradient descent takes the cheaper route: rather than learn the fact, learn the form of a confident answer.

That produces the characteristic failure. The tuned model answers in your house style, with your structure, at your length, and invents the specifics. It is worse than before, because it now sounds like your best expert while being wrong.

Even where memorisation does happen, the knowledge is:

• uncitable: there is no source to show the user;
• unupdatable: the policy changes and you retrain;
• undeletable: someone asks you to remove one record and there is no record to remove.

Retrieval has none of those problems, and its failure mode (“I could not find anything”) is the one you want.

The hallucination amplifier

Here is the rule that catches most teams. If a training example’s answer depends on knowledge the base model does not have, you are training the model to guess confidently.

Say you build 3,000 question-and-answer pairs from your internal wiki and train without showing the model the wiki. Every one of those examples demonstrates the same lesson: when asked about internal matters, produce a specific, confident answer. At inference, asked about something outside the training set, that is exactly what it does.

The fix is not more data. It is to train the behaviour with the context present (examples that include the retrieved passage and an answer grounded in it) or to include examples where the correct output is that it does not have the information.

What it can add

• Mapping your language onto what it knows. Your jargon, abbreviations, ticket codes, product names. That is a translation task and it is learnable.
• Output shape. Schemas, tags, field order, the exact vocabulary of a controlled label set.
• Decision boundaries. Which of five categories, which team to route to, when to escalate. This is where a small tuned model does best.
• Refusal and calibration. Including teaching it to say it does not know, which is a behaviour rather than a fact.
• Narrow reasoning patterns, partly. Training on worked traces from a stronger model does raise in-domain performance; that is how many small reasoning models are built. But it transfers the pattern, not the capability underneath. The base’s ceiling is still the ceiling, and the gains rarely survive far outside the training distribution.

What it cannot touch at all

Context length. Tool access. Anything about your infrastructure. And behaviour on inputs unlike anything in your data: off-distribution, the tuned model can be worse than the base, which is the subject of a later lesson.

One sentence to keep

If answering requires knowing something, put it in the context. If answering requires deciding something, fine-tuning can teach the decision.