What happens when a language model 'learns.'

The word "learn" is doing a lot of work in "the model learned to write code." Under the hood, modern chat models are trained in three distinct phases, each doing something different.

Phase 1: Pre-training

The model is exposed to an enormous corpus of text — hundreds of billions of words scraped from the web, books, code repositories, and other sources. The training objective is simple: predict the next token.

That's it. Given the first N tokens, predict token N+1. Do this trillions of times across the corpus.

What emerges from this simple objective is stunning: the model learns grammar, facts, reasoning patterns, code syntax, poetry, translation, and everything else that shows up in the training data. Not because it was told to — because "predict the next token accurately across billions of examples" requires internalizing all of these things implicitly.

Pre-training is expensive (millions of dollars in compute for a frontier model) and slow (weeks to months). It produces a "base model" that's raw — it can complete text but doesn't respond like an assistant.

Phase 2: Instruction tuning

The base model is fine-tuned on curated examples of instruction-following. Someone writes "Q: What's the capital of France? A: Paris." across thousands of examples in different styles. The model learns to respond to questions rather than just extending them.

This is where the model starts feeling like an assistant. Behavior shifts from "completion" to "response." Format expectations get built in.

Phase 3: RLHF (or Constitutional AI)

Humans compare pairs of model outputs and pick which one they prefer. "Which of these two responses is more helpful / more accurate / less harmful?" The model is fine-tuned to produce outputs that match the human preferences.

Anthropic's Constitutional AI variant uses the model itself to evaluate outputs against a written set of principles ("the constitution") rather than requiring humans to generate every ranking. Cheaper to scale, controversial in some corners.

The result of this phase is what you experience as "Claude" or "GPT." Helpful, honest, refuses harmful requests, admits uncertainty. Those behaviors don't come from the base model — they come from what RLHF taught it to prefer.

Why this matters practically

**Training cutoff.** Pre-training uses text from a specific date range. The model doesn't know about events after that. Different models have different cutoffs; each release ships with a specific one.

**Fine-tuning shifts behavior.** The model you're interacting with has been through instruction tuning + RLHF/CAI to be helpful in specific ways. That's a design choice. Different labs make different choices — some models are more cautious, some more expansive, some more literal.

**No online learning.** Once a model is deployed, it doesn't learn from your specific conversations. Your feedback doesn't update the weights. The next user gets the same model.

**Memory ≠ learning.** LADLE's memory feature stores facts about you and adds them to prompts. That's system-prompt manipulation, not model retraining. The model itself is unchanged; the context it sees is enriched.

What you can and can't do with a trained model

**Can:** Give it context, examples, constraints. Ask it to reason. Attach documents. All of these change what the model sees this turn.

**Can't:** Permanently teach the model something new. Every conversation starts fresh with the same underlying weights.

For most users this is fine. The point of a trained model is that it comes with capabilities you don't have to build.