Home/Language & LLMs

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.

40 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.

Small Language Model (SLM)

A language model small enough to run somewhere a big one can't — and the demonstration that most of the size was never doing the work.

RLVR (Reinforcement Learning with Verifiable Rewards)

Training against answers you can check rather than preferences you have to learn — the method behind the reasoning-model era, and the reason it stops where it does.

Context Engineering

Deciding what goes into the context window and what doesn't — the discipline that replaced prompt engineering once the prompt stopped being the hard part.

Needle in a Haystack

The test that hides a fact in a long document and asks the model to find it — and the reason a model can pass it at 128k tokens and still be useless at 32k.

GraphRAG

Retrieval over a knowledge graph the model built from your documents — better at questions about the whole corpus, and expensive enough that most projects shouldn't.

Question Answering

Getting a machine to answer a question in natural language — the task that quietly turned from "find the passage" into "generate the answer," and defines how we use AI today.

Text Classification

Sorting text into categories — spam or not, positive or negative, which topic — the most widely deployed NLP task, and the one you've used a hundred times without noticing.

Reasoning Model

A language model trained to think before it answers — generating a long internal chain of reasoning and spending extra compute at inference to solve harder problems.

Natural Language Processing (NLP)

The field of getting computers to understand and generate human language — the decades-old discipline whose task-specific methods collapsed, in a few years, into a single general model.

Multilingual AI

How language models behave outside English — where the capability comes from, why it degrades, and why the same sentence can cost four times as much in one language as another.

Subword Tokenization

The compromise that lets a fixed vocabulary cover any word: split rare words into frequent pieces, and accept that the model never sees letters.

Distributional Hypothesis

Firth's claim that you shall know a word by the company it keeps — the idea that meaning can be recovered from co-occurrence patterns, which is why a model trained only on text can represent meaning at all.

Pragmatics

How context and intention determine what is communicated beyond the literal words — the level where most prompt frustration actually lives, and the one models handle least evenly.