What an LLM Actually Is (Not Another Prompting Course)

LLMs

Chapter 1 · What an LLM Actually Is (Not Another Prompting Course)

This course exists to answer one question the site has never actually answered: what is happening, mechanically, inside the model between a prompt going in and a response coming out? Not how to phrase the prompt well — that's already covered, thoroughly, elsewhere.

What This Course Is Not

Course	What it actually teaches
prompt1	How to phrase a prompt well — clarity, context, constraints, few-shot examples, chain-of-thought
claude-adv1	How to build with the Claude API — tool use, streaming, RAG, multi-agent patterns
llm1 (this course)	What's actually happening inside the model — tokenization, attention, pretraining, fine-tuning, why any of the above techniques work at all

prompt1 and claude-adv1 already own the practical territory in full — this course doesn't re-teach either one. It sits underneath both, the same way imgai1 sat underneath image-generation prompting: that course didn't teach how to phrase an image prompt well either — it explained diffusion, the actual mechanism a prompt gets fed into. This course is the direct textual analogue.

Delivering on nlp1-10's Own Three Claims

nlp1-10's own capstone closed the NLP course by naming three real differences between its own hand-built pipelines and an LLM — scale, self-supervised pretraining taken further, and one flexible architecture instead of many task-specific pipelines. That chapter asserted all three honestly, but didn't have the room to prove any of them mechanically. This course does exactly that, one claim at a time.

Where each claim gets proven

Scale — llm1-7 (real pretraining data/parameter counts) and llm1-8 (scaling laws — why bigger follows a predictable curve, not a guess)
Self-supervised pretraining taken further — llm1-7, extending nlp1-5's and nlp1-9's own context-prediction training signal to an entire corpus, predicting the next token instead of a single missing word
One flexible architecture vs. many pipelines — llm1-6, explaining why a single decoder-only Transformer can be steered toward tasks nlp1-6 and nlp1-7 each needed a separately built, separately trained pipeline to perform

Unpacking the Name — Large Language Model

Large — a real, measurable claim about parameter count and training data volume, not marketing language. llm1-8 covers exactly what "large" buys you and why.
Language — trained primarily on text (many current models are genuinely multimodal too, an honest scope note this course doesn't chase further).
Model — a function that computes a probability distribution over what token comes next, not a database. This is a genuine, important contrast with nlp1-9's own GloVe: GloVe is a fixed lookup table — look up a word, get back a static vector, nothing more. An LLM is a function with billions of learned parameters that computes a fresh answer for every input; nothing is looked up, everything is computed.

A model, not a lookup table

This distinction matters for the rest of the course: nlp1-9's own out-of-vocabulary problem existed specifically because GloVe's vocabulary was a fixed table with gaps. A computed function has no such fixed table to run out of — llm1-2 covers exactly how tokenization closes that gap for good.

A First, Deliberately Incomplete Preview

Take the prompt "The capital of France is". At a high level, without yet explaining any of the mechanics: the text is broken into pieces (llm1-2), each piece is converted into a vector that also encodes its position in the sequence (llm1-3), those vectors pass through many stacked layers that let every piece attend to every other piece (llm1-4/llm1-5), and the model ultimately produces a probability distribution over every possible next piece — with "Paris" receiving, if training went well, the highest probability of all. This entire path is deliberately left abstract here — the capstone (llm1-11) walks it in full, once every piece has been built.

Why This Actually Helps With Prompting, Without Re-Teaching It

Knowing this mechanism doesn't replace prompt1's own techniques — it explains why they work. Few-shot examples help because the model is a pattern-continuation engine at its core (llm1-7 makes this precise). Chain-of-thought helps because generation is genuinely sequential — each token really does depend on every token generated before it (llm1-11's own trace makes this concrete). This course is a companion to prompt1, not a replacement for it.

Hands-On Exercises

Exercise 1

Explain the specific difference in scope between prompt1, claude-adv1, and this course, and explain why this course is described as the direct analogue of what imgai1 did for image-generation prompting.

📄 View solution

Exercise 2

Explain why "Model" in "Large Language Model" is a meaningful, load-bearing word rather than filler, using the contrast between an LLM and nlp1-9's own GloVe lookup table to make the distinction concrete.

📄 View solution

Exercise 3

For each of nlp1-10's own three named differences (scale, self-supervised pretraining taken further, one flexible architecture vs. many pipelines), identify which specific chapter of this course is responsible for proving it mechanically, and explain in one sentence what "proving it mechanically" means as opposed to simply asserting it.

📄 View solution

Chapter 1 Quick Reference

This course's scope: the mechanism underneath a prompt — not how to write one (prompt1) or how to build with an API (claude-adv1)
The imgai1 parallel: that course explained diffusion underneath image prompting; this course explains the Transformer underneath text prompting
Model ≠ lookup table: an LLM computes a fresh answer for every input, unlike nlp1-9's own fixed GloVe vectors
nlp1-10's three claims, and where each gets proven: scale (llm1-7/8), self-supervised pretraining taken further (llm1-7), one flexible architecture vs. many pipelines (llm1-6)
Next chapter: Subword Tokenization: Byte-Pair Encoding