Welcome back to AI From Scratch.
If you’ve reached Day 7, you’re not just “AI‑curious” anymore — you’re basically that friend who secretly understands how this stuff works.
Where we are so far:
- You know AI is a next‑token prediction machine (Day 1).
- You’ve seen how it learns via the training loop (Day 2).
- You’ve peeked inside the layers and neurons (Day 3).
- You’ve met Transformers and attention (Day 4).
- You know it doesn’t read words, it reads tokens and numbers (Day 5).
- And yesterday, we talked about why bigger models often feel smarter — and where that idea breaks.
Today’s question:
If two models are built on the same architecture, trained on similar data…
why does one feel like a nerdy research project and the other feels like a helpful assistant?
**
That’s where base models and instruction‑tuned models enter the chat.**
Base model: the raw, slightly feral brain
A base model is what you get right after the big original training run on internet‑scale text.
This is the “pure” next‑word prediction machine: it’s learned language patterns, world facts, coding tricks — everything we talked about up to Day 6.
But here’s the catch: no one has yet sat it down and said,
“Hey, when a human asks you something, please answer like a helpful assistant.”
So a base model:
- Knows a lot about language and the world.
- Will happily continue almost any text you give it — stories, code, song lyrics, rants.
- But might ignore your instructions, ramble, or respond in weird formats because it’s not trained to treat your prompt as a command — it just sees it as the start of more text to complete.
So what this means for you: a base model is like a very smart person who has read the whole internet but has never been told “answer questions clearly, step by step, and don’t be a chaos gremlin.”
Pretraining vs finetuning: the two phases of “raising” an AI
At a high level, modern LLMs go through two big life phases:
Pretraining (the huge, expensive phase)
- Model reads massive amounts of text.
- Objective: “predict the next token correctly.”
- Result: broad language understanding + world knowledge.
Finetuning (the shorter, targeted phase)
- You start from that pretrained base brain.
- You train it more on a smaller, curated dataset for some specific goal: follow instructions, write in a tone, perform a domain task.
Pretraining is like sending the model to the biggest school on Earth.
Finetuning is like giving it a job‑specific bootcamp: “Now you’re a support agent,” or “Now you’re a polite tutor.”
So what this means for you: almost every helpful AI you touch today started life as a raw base model, then got extra training layers to make it behave like a usable product.
Instruction tuning: teaching the model to actually listen
One very specific style of finetuning turned out to be a game‑changer: instruction tuning.
Instead of just feeding the model random text, we create datasets that look like this:
Instruction: “Summarize this article in 3 bullet points.”
Input: (some article)
Output: (a good 3‑bullet summary)
Or:
Instruction: “Explain transformers to a 10‑year‑old.”
Output: (simple, kid‑friendly explanation)
The model is then fine‑tuned on thousands or millions of these (instruction, response) pairs across many tasks — translation, summarization, Q&A, reasoning steps, coding help, etc.
Over time, it learns a meta‑skill:
“When a human writes something that looks like an instruction,
I should respond in the style and format they seem to want.”
Compared to a base model, an instruction‑tuned model:
Follows your prompt structure more closely.
Stays on task instead of randomly storytelling.
Is better at “do X in style Y with constraint Z.”
So what this means for you: that feeling of “I can just talk to it like a person and it mostly gets what I mean” is usually instruction tuning doing its job, not magic.
Base vs instruction‑tuned: how they feel different
Let’s make this concrete.
Ask a base model:
“Explain AI in 5 short bullet points I can paste into a slide.”
It might:
- Write a long essay.
- Ignore the “5 bullets” part.
- Drift into a Wikipedia‑style info dump.
Ask an instruction‑tuned model the same thing and you’re more likely to get:
- Exactly 5 bullets.
- Slide‑friendly phrasing.
- A tone that roughly matches your request.
Why? Because during instruction tuning, it has seen thousands of examples where people say “summarize,” “list,” “explain like I’m 12,” “write an email that…”, and it’s been graded on how well it followed those commands.
So what this means for you: if you want a research sandbox, a base model can be fun. If you want a reliable assistant that listens, instruction‑tuned is usually what you’re actually using — and what you should look for.
Where base models still matter
With all this love for instruction‑tuned models, you might ask:
“Why do base models exist at all?”
A few big reasons:
- Research and advanced users
- Base models let researchers and companies fine‑tune for their own, very specific needs (legal, medical, internal docs) without fighting against someone else’s chatty assistant persona.
- Raw capability vs behavior
- Some work even suggests that on certain reasoning benchmarks or under distribution shifts, base models can outperform their instruction‑tuned cousins, which may overfit to specific prompting styles.
- Full control
- If you want to design your own way of turning a raw model into a product (your own safety rules, tone, tools), starting from the base gives you a clean slate.
So what this means for you: when you see “base” vs “instruct” versions of the same model, base is the raw engine; instruct is the same engine with a “friendly driver” layer on top.
Why this matters even if you never train a model yourself
You might think: “Cool, but I’m never going to fine‑tune a model. Why should I care about any of this?”
A few reasons:
- Choosing tools
- Knowing if an app is built on a base or instruction‑tuned model tells you what to expect: more raw creativity vs more obedient instruction following.
- Debugging weird behavior
- If a model keeps ignoring your prompt structure, you now know: either it’s a weakly tuned base model, or its instruction data didn’t reinforce your style enough.
- Understanding the limits
- Even super polished instruction‑tuned models are still just next‑token predictors underneath — instruction tuning narrows and shapes behavior, it doesn’t turn them into perfect logical robots.
So what this means for you: when an AI feels surprisingly helpful, that’s not just “the model is big” — it’s “the model has been trained again, specifically to behave like a useful assistant.”
Teaser for Day 8 – How Did AI Learn to Be Nice?
We’ve now separated two big ideas:
Pretraining: where the model learns about language and the world.
Instruction tuning / finetuning: where we teach it to follow instructions and act more like an assistant.
But there’s still one more layer we haven’t unpacked:
How did AI learn to be polite, avoid certain topics, refuse some requests,
and generally behave “aligned” with human values (at least most of the time)?
That’s where Reinforcement Learning from Human Feedback (RLHF) comes in — humans literally rating and steering the model’s behavior, and the model learning which kinds of responses get “rewarded.”
Tomorrow, in Day 8 – “How Did AI Learn to Be Nice? The Humans Behind the Curtain”
we’ll talk about:
- What RLHF actually is in everyday language
- How humans sit in the training loop
- And why this “alignment” step matters for safety and for how pleasant your AI chats feel
That's the end!
What blew your mind most? Drop a comment!
Top comments (0)