Ask a language model for a haiku about a broken coffee machine and you’ll have one in about two seconds. Nothing was looked up. The model has never seen your kitchen, doesn’t hold a database of poems, and isn’t running a search behind the scenes. It produced the answer one small chunk of text at a time, each chunk chosen because it fit plausibly after the chunks before it.
That single mechanism explains most of what surprises people about generative AI, both the impressive parts and the maddening ones. Understand it properly and the rest of the field stops looking like magic.
Next-token prediction, the engine under everything
Text gets chopped into tokens before a model ever sees it. A token is roughly four characters of English, so “generative” might split into “gener” and “ative,” and 1,000 words lands somewhere near 1,300 tokens. During training, the model’s only job was to look at a run of tokens and assign probabilities to whatever comes next.
Do that at sufficient scale, across trillions of tokens of books, code, forum arguments and documentation, and something odd happens. To predict the next word well, you have to absorb grammar, factual associations, tone and a fair amount of reasoning structure. None of that was explicitly programmed. It’s a side effect of the prediction task.
At generation time the model samples from those probabilities. Turn the temperature dial down and it picks the safest likely token every time, which reads flat and repetitive. Turn it up and you get variety plus a higher chance of nonsense. That dial is why the same prompt gives you three different answers on three different runs.
What’s actually stored inside a model
People often picture a model as a library it consults. It isn’t. A model is a very large pile of numbers, called parameters or weights, adjusted during training until the predictions got good. A 7-billion-parameter model holds roughly 7 billion numbers, often compressed to 4 or 8 bits each so it can run on a single consumer GPU.
Because knowledge is compressed into those weights rather than stored verbatim, it comes out lossy. The model grasps the shape of a fact without reliably nailing the exact date, citation or figure. That’s the honest explanation for hallucination, and it’s more useful than treating it as a bug a stern prompt will fix.
Grounding beats scolding
Telling a model “don’t make things up” helps a little. Handing it the source text and asking it to answer only from that text helps enormously. That’s the logic behind retrieval, which I’ll come back to.
Pretraining, instruction tuning and fine-tuning are different things
These three terms get used interchangeably in marketing copy and they absolutely are not.
- Pretraining is the expensive part: months of compute over a huge text corpus, teaching basic token prediction. Only a handful of organisations do this at frontier scale.
- Instruction tuning and preference training come next. Humans and AI graders rank responses, nudging the model toward answers people find helpful rather than merely probable.
- Fine-tuning is what you might do on top: a few thousand examples of your own task so the model picks up your format, tone or domain vocabulary. It changes behaviour far more reliably than a long prompt, and it does not add new facts particularly well.
If a vendor offers to “train a model on your company data,” ask which of these they mean. The answer moves the cost by two or three orders of magnitude.
Context windows and the forgetting problem
Every model has a context window: the maximum tokens it can hold in view at once, covering your prompt, any documents you pasted and its own output. Early chat models managed 4,096 tokens. Current ones advertise anywhere from 128,000 to a million.
Bigger isn’t automatically better. Models tend to attend more reliably to material at the start and end of a long context than to the mushy middle, and stuffing 200 pages into a prompt often costs more in accuracy and money than retrieving the four relevant pages would. A well-built system treats the context window as scarce desk space, not a warehouse.
Prompting is design work, not incantation
There are no secret phrases. What consistently works is what works when briefing a competent freelancer: state the task, give the constraints, show an example of good output, specify the format.
A request like “summarise this” produces mush. “Summarise this 12-page contract in five bullets, one per clause category, flagging any term over 24 months with a warning marker” produces something you can use. Few-shot examples do more heavy lifting than most prompt tricks, and asking for structured output such as JSON makes the result far easier to wire into software.
The layers around the model do a lot of the work
Production systems rarely call a bare model and hope for the best. Three patterns show up again and again.
Retrieval. Documents get split into chunks, converted into embeddings (vectors that place similar meanings near each other) and stored in a vector database. At query time the closest chunks get pulled into the prompt. This grounds answers in current, citable material.
Tool use. The model can request a function call (a calculator, a database lookup, a calendar API) and surrounding code executes it. This turns an unreliable narrator into something that can check its own arithmetic.
Agents. Chain several model calls with tools and a goal and you get a loop that plans, acts, checks results and retries. Genuinely useful, and also where most reliability problems live, since small errors compound across steps.
Learning the fundamentals in a sensible order
The fastest route in is to build something small and watch the seams show. Start with tokens and embeddings, move to prompting, then retrieval, then evaluation. That fourth step is the one people skip and the one that separates a demo from a system anyone trusts.
If you’re choosing structured learning, be picky. Online generative AI classes range from genuinely hands-on to a slideshow somebody recorded two years ago, and the difference is obvious once you know what to look for. A generative AI engineering course should have you wiring up retrieval and evals, not just typing prompts into a chat box. For comparison shopping, this breakdown of the best generative AI courses ranked by what you’ll actually build is a decent starting filter.
Teams rolling this out need a different frame entirely. A generative AI for business course should cover cost per request, data handling and where a human stays in the loop, because those are the questions that quietly kill pilots. On credentials specifically, it’s worth checking which generative AI certifications are worth paying for before anyone puts a badge in their profile.
Five things worth testing yourself this week
- Paste a 40-page PDF into a long-context model, then ask something whose answer sits on page 22. Compare that with retrieving only the relevant section.
- Run one prompt at temperature 0 and at temperature 1. Note where the cautious version is better and where it’s just bland.
- Ask for a specific statistic with a source, then verify it. Count how often the citation actually exists.
- Give a task with and without two example outputs. The gap is usually wider than any prompt phrasing change.
- Estimate your token spend. Input tokens dominate most bills, and halving a bloated system prompt is often the biggest cost cut available.
None of these takes more than an afternoon, and each one teaches something a tutorial can’t: the exact points where a model’s confidence and its accuracy come apart. That gap is the real subject of generative AI fundamentals, and every system worth shipping is built to manage it.