Adaptation Is How General Models Become Useful

Take the least invasive adaptation that clears the reliability bar. A model can learn the format of helpfulness without learning the work. Heavier methods make that failure easier to buy and harder to see.

Pretraining creates broad capability. Adaptation points that capability at a task, domain, user, or policy. Every method changes one of three things: the model weights, the input, or a small learned module beside it.

Pretraining Makes Breadth, Adaptation Buys A Job

A general model is broad on purpose. Adaptation aims that breadth at one job. The job is a domain, an instruction style, a policy, a tool interface, or a user population. The gain arrives when the target behavior becomes easier for the model than the generic behavior.

Find out what the model already holds before you change anything. Probing trains a small head on frozen representations and reports what the encoding contains. When the capability is already there, steering reaches it and new weights buy nothing.

Prompt, Retrieve, Adapt, Then Fine-Tune

Four rungs, four prices. Prompting is cheap and reversible. Retrieval adds fresh facts and leaves the weights untouched. Adapters add small trainable modules that swap by task or domain. Full fine-tuning updates weights on supervised or preference data and gives the most control at the highest cost.

Between prompting and full weights sit the tuned inputs. Prompt tuning learns soft prompt vectors. Prefix tuning injects learned vectors into attention layers to steer generation, and the base model stays fixed for both.

Which layer holds the missing piece? If the answer is current knowledge, retrieval is safer than new weights. If the answer is format, prompting or adapters do it. The trap is fine-tuning before you prove the problem needs it.

The selective-architectures note moved knowledge into a retrieval index and away from the weights. That is the same selection question in a new place. Routing decides what wakes. Adaptation decides what changes.

Flexibility Trades Against Stability

The trade is flexibility against stability. Full fine-tuning changes the most and risks forgetting and deployment complexity. Lightweight adaptation is cheaper and modular, and it sometimes fails to move behavior far enough.

Fine-tuning does not add knowledge the way a document upload adds a file. The weights move, and behavior on tasks you never adapted moves with them. You pay for depth whether or not you measure the cost.

Modularity is why adapters stay in the running. One base model serves many jobs when small task-specific parameters swap in and out. A second set of full weights is a second artifact to serve, evaluate, and roll back.

A Model Can Learn The Format Of Helpfulness

Preference and instruction tuning teach more than facts and formats. They teach the model which behaviors humans prefer in an interaction. A model that learns the preferred shape of an answer has the costume. Whether it can do the work is a separate measurement.

Adaptation can improve the benchmark and still narrow the model into a brittle local trick. The failing version fine-tunes until the target examples look good. It teaches surface style, benchmark-specific habits, and refusal patterns that break on the first unfamiliar input.

Catching the costume takes examples the tuning never saw. Use held-out tasks, adversarial checks, and rewordings that keep the work while changing the surface. Score the capability, and treat matching phrasing as weak evidence.

The first harms note named the rule: every threshold picks an error. A refusal boundary is a threshold. Tune it on examples that all look alike, and the model refuses the wrong things once real traffic arrives.

Measure The Regression Beside The Target

A serious pass measures the target and the damage in the same run. Skip the damage and you ship an improvement you cannot price.

• Target-task improvement, scored on tasks held out from the tuning data.
• General ability regression on the tasks you never meant to touch.
• Safety regression, including refusals that now fire on ordinary requests.
• Domain shift, measured on traffic collected outside the tuning distribution.
• Format overfitting, caught by rewording the same task and scoring again.
• Interface match between the adaptation data and the deployed contract.

Test outside the tuning set every time, and keep a holdout that represents the deployment world. Define that world before you build it. The capabilities note called it the interaction contract: prompt format, examples, context, decoding rule, tools, retries, refusal policy, and scoring.

Run this pass before launch, while the method is still cheap to change. After launch, the same comparison costs a migration and a second round of evaluation.

The Builder Test

Take one task you already ship. Build the retrieval-prompt version and the adapter version of it. Run both against the same held-out contract.

Record cost, reversibility, evaluation burden, and failure risk for each one. Ship the cheaper rung that clears the bar. Keep both sets of measurements, because the next task starts from them instead of from an argument.

What Carries

Adaptation stays as small as possible and as strong as necessary. Anything more is extra risk and extra maintenance.

Every rung on that ladder costs compute, and the bill continues long after the launch.