Field
Language & LLMs
The models behind chat assistants, and everything built around them.
A large language model is a system trained to predict the next piece of text, scaled until that simple objective produces something startling. That description sounds reductive and is accurate — which is precisely why the field argues about what these systems understand.
This is the biggest field here, because it's where most practical work happens. It covers what goes in (tokens, context windows, system prompts), how you steer behaviour (prompt engineering, fine-tuning, RLHF), how you give models facts they don't have (RAG), and what goes wrong (hallucination).
The entries take positions. RAG is for knowledge, fine-tuning is for behaviour, and most teams reach for the second when they needed the first. Hallucination is over-diagnosed. A system prompt is not a security boundary.
Start with Large Language Model, then RAG — it's the one people get wrong most expensively.
27 concepts in this field
Token
The small piece of text an AI reads and writes — usually a chunk of a word, not a whole word.
Large Language Model (LLM)
An AI trained on enormous amounts of text to predict the next piece of writing — the technology behind chatbots like ChatGPT and Claude.
Retrieval-Augmented Generation (RAG)
Letting an AI answer from a specific set of documents by looking them up as it responds — instead of relying only on what it memorized.
Fine-tuning
Continuing a model's training on your own examples so its behavior changes — baked into the model, not supplied at answer time.
Prompt Engineering
The craft of writing instructions that get the best, most reliable output from an AI model.
Hallucination
When an AI produces something fluent and confident that is simply false — fluency is not the same as accuracy.
Context Window
The maximum amount of text an AI can consider at once — its short-term working memory, measured in tokens.
Temperature
A single setting that controls how random or predictable an AI's output is — low for focused, high for creative.
Chain-of-Thought
Getting a model to reason step by step before answering — which dramatically improves its performance on hard problems.
Quantization
Storing a model's numbers with less precision so it fits in less memory and runs faster — usually at a surprisingly small cost in quality.
RLHF (Reinforcement Learning from Human Feedback)
Training a model on human preferences rather than correct answers — the step that turned text predictors into assistants.
System Prompt
The standing instructions a model gets before the conversation starts — influential, invisible to users, and not a security boundary.
LoRA (Low-Rank Adaptation)
A way to fine-tune a huge model by training a tiny add-on instead of the model itself — cheap enough that one GPU will do, and good enough that it became the default.
Chunking
Cutting documents into retrievable pieces — the least glamorous decision in RAG, and the one that most often decides whether it works.
Reranking
A second, slower pass that reorders retrieved results by actually reading them — usually the cheapest large improvement available to a RAG system.
Mixture of Experts
A model with many specialist sub-networks that only wakes a few per token — how frontier models got enormous without getting proportionally slow.
KV Cache
The memory that stops a model re-reading its own conversation every token — the reason generation is fast, and the reason serving is expensive.
Perplexity
How surprised a model is by text — the number that drives all of pretraining, and correlates poorly with whether the model is any good.
LLM-as-Judge
Using a model to grade another model's output — cheap, scalable, correlates decently with humans, and it prefers its own writing.
Tokenization
Cutting text into the pieces a model actually reads — the least glamorous step in the stack, and the cause of a surprising share of its stupidest failures.
Sampling
Choosing the next token from the model's probability distribution — where always picking the most likely word produces worse text, which is not what anyone expected.
In-Context Learning
A model picking up a task from examples in the prompt, without any training — and the evidence that it isn't learning the task at all.
Reasoning
Models that think before answering — a large real capability gain, and the visible thinking is not a reliable account of what happened.
Instruction Tuning
Training a text predictor to follow instructions — the step that turned an autocomplete into an assistant, and it may take only a thousand examples.
DPO
Preference training without a reward model or reinforcement learning — the derivation that made RLHF simple, and it may not be free.
Speculative Decoding
A small model guesses ahead and the big one checks in parallel — two to three times faster, with mathematically identical output. An actual free lunch.
Prompt Caching
Reusing the computation for a prompt prefix you've sent before — the largest cost saving available to most applications, and most of them don't use it.