Glossary

AI terms in plain English

704 words you'll meet in AI and machine learning, each explained in everyday language, with a link to the lesson that teaches it. In lessons, these words have a dotted underline: hover or tap one to see its meaning.

A

A/B test: Show two versions to two random groups and compare the results, to learn which one really works better. Lesson: Evals
ablation: Switching off one part of a model, such as an attention head, to see what changes. A big change means that part mattered. Lesson: Interpretability
absolute value: A number with its minus sign dropped: the absolute value of -3 is 3. Lesson: Loss functions
abstract syntax tree: Code parsed into a tree of its parts, such as functions, calls and expressions. Linters and editors work on it. Lesson: Reading unfamiliar code
accuracy: The share of predictions that were right. Misleading when one answer is much more common than the others. Lesson: What machine learning is
activation function: The simple function a neuron applies after its weighted sum. Without it, stacking layers would add nothing. Lesson: Activation functions
active parameters: The parameters each token actually uses in a mixture-of-experts model. They set the compute per token; the total sets the memory needed. Lesson: Mixture of experts
AdamW: Adam with weight decay applied separately from the gradient step. It's the default optimizer for training most language models. Lesson: Optimizers
adapter: A small set of extra trained weights added to a frozen model to change its behavior. Easy to swap, share and remove. Lesson: LoRA
add-one smoothing: Adding 1 to every count before turning counts into chances, so nothing the model never saw gets a chance of exactly 0. Lesson: Language modeling
advantage: In reinforcement learning, how much better one answer scored than expected (in GRPO, than its group's average). Lesson: Training reasoning models
agent: A model in a loop that decides what to do next, uses tools, looks at the results, and repeats until the job is done. Lesson: The agent loop
agent harness: The software around a model that turns it into an agent: the loop, tools, permissions, context management, memory and logging. Lesson: What an agent harness is
agent loop: The repeating cycle of an agent: think, call a tool, read the result, decide again. Lesson: The agent loop
agent skill: A folder that teaches an agent one kind of task: a SKILL.md with a name, a description and instructions, plus scripts and files. Lesson: Hooks and skills
alignment: Making AI systems reliably do what people intend, safely and honestly. Lesson: Alignment and safety
allowlist: A list of the only things permitted, such as the few web addresses an agent may contact. Anything not on it is blocked. Lesson: Prompt injection and security
API: A way for one program to ask another for data or actions, usually over the internet. Lesson: How APIs work
API key: A secret password-like string that identifies you to an API. Never share it or put it in code. Lesson: API keys and secrets
append-only: Only ever adding to the end, never editing what's there. Agent transcripts and session logs work this way. Lesson: The core loop, built properly
approximate nearest neighbor: Finding vectors that are very probably the closest, much faster than checking every one. Vector databases use it to search millions of items. Lesson: Vector databases
architecture decision record: A short note of one significant decision: its context, the decision and its consequences. Lesson: Writing for engineers
argument: A value you hand to a function when you call it, like the number in round(3.7). Lesson: Functions
array: A grid of numbers (a row, a table, or more) that NumPy can do math on all at once. Lesson: NumPy arrays
arXiv: The free website where most AI research papers are posted, often before any peer review. Lesson: Reading AI papers
at-least-once delivery: A guarantee that each message is delivered, but possibly more than once, so consumers must be idempotent. Lesson: Caches, queues and background jobs
attention: How a transformer lets each token look at the other tokens and pull in the information it needs. Lesson: Attention: the intuition
attention weights: The shares of focus a token gives to each earlier token. They are all positive and add up to 1. Lesson: Attention: the intuition
AUC: Area under the ROC curve: the chance the model scores a random true case above a random false one. 1 is perfect, 0.5 is guessing. Lesson: ROC curves and AUC
authentication: Proving who is making a request, with a key, a password or a token. Lesson: Authentication and authorization
authorization: Deciding what an authenticated caller is allowed to do. Lesson: Authentication and authorization
autograd: Software that works out gradients automatically from the computation graph, so you never do it by hand. Lesson: Build an autograd engine
average precision: The area under the precision-recall curve: one number for how well a model finds a rare class. Lesson: ROC curves and AUC
AWQ: Activation-aware weight quantization: keeps the few weights that matter most for real inputs more precise. Lesson: Quantization

B

back-of-the-envelope estimate: Rough math, such as requests per second or storage per year, done before building to see which problems are real. Lesson: System design fundamentals
backend: The part of an app that runs on your own server, out of users' sight. It's where secrets like API keys belong. Lesson: Shipping an LLM app
backpropagation: Working backwards from the error to find how much each weight was to blame, so each can be adjusted. Lesson: Backpropagation
bagging: Training many models, each on a random resample of the data, and averaging their answers. The averaging cancels out much of each model's random error. Lesson: Random forests and boosting
base model: A model straight out of pretraining: it continues text but doesn't yet follow instructions. Lesson: Pretraining at scale
base-rate fallacy: Forgetting how rare something is to begin with. A 95%-accurate fraud flag can still be wrong most of the time when fraud is rare. Lesson: Conditional probability and Bayes
base64: A way to write any file, such as an image, as plain text so it can travel inside a JSON request. It makes the data about a third bigger. Lesson: Images and documents
baseline: A simple reference result to beat, such as always guessing the most common answer. A model is only useful if it does better. Lesson: Evals
batch: A small group of examples processed together in one training step. Lesson: Training with gradient descent
batch normalization: Rescaling each feature across a batch to an average of 0 and a spread of 1, then letting the network adjust it. Common in image models. Lesson: Normalization layers
Bayes' rule: A way to update how likely something is when new evidence arrives. Lesson: Conditional probability and Bayes
benchmark: A standard test set used to compare models. Useful, but models can be tuned to the test. Lesson: Benchmarks and their limits
BERT: Google's 2018 encoder model, trained by hiding words and guessing them from both sides. Its descendants still power much search and classification. Lesson: Encoders and embedding models
best-of-n sampling: Generating several answers and keeping the one a reward model scores highest. Simple and strong, but it costs n generations per question. Lesson: RLHF
bf16: A 16-bit number format with the same range as normal 32-bit numbers but less precision. It halves memory and speeds up training. Lesson: GPUs and compute
bias: In a model, a starting value added before anything else (the intercept). It can also mean a systematic error; the context tells you which. Lesson: Linear regression
bias-variance tradeoff: Simple models miss in a steady way (bias); flexible models swing with every change in the data (variance). The best model balances the two. Lesson: Bias and variance
bidirectional: Reading in both directions: each token can look at the words before and after it, as encoders like BERT do. Lesson: Encoders and embedding models
Big O: A way to describe how a program's work grows as its input grows, such as O(n) for one loop or O(n²) for a loop inside a loop. Lesson: Algorithm complexity
bigram: A pair of neighboring tokens. A bigram model predicts the next token from only the one before. Lesson: A bigram model
binary classification: Classification with exactly two possible answers, such as churn yes or no. Lesson: Features and labels
binary search: Finding an item in a sorted list by checking the middle and throwing away the half it can't be in, again and again. Lesson: Searching, sorting and dynamic programming
binomial distribution: The chances of getting 0, 1, 2 and so on successes in a fixed number of tries, when every try has the same chance. Lesson: Distributions
bit: The unit of information: the answer to one fair yes-or-no question, like one coin flip. Lesson: Entropy and surprise
blameless postmortem: A write-up after an incident that looks for how the system allowed it, not who to blame, and ends with owned action items. Lesson: Reliability and incidents
blue-green deployment: Running a full new copy beside the old one, then switching all traffic at once, with instant rollback. Lesson: Containers and deployment
BM25: The standard keyword-search score: it rewards documents that use the question's words, especially rare words, without over-rewarding repeats. Lesson: Making RAG good
Bonferroni correction: When you run many tests, divide the 0.05 cutoff by how many you ran, so chance alone doesn't hand you a fake winner. Lesson: A/B tests and significance
boolean: A value that is either True or False. Lesson: Decisions with if/else
bootstrap: Estimating uncertainty by resampling your own data, with replacement, many times and seeing how much the answer moves. Lesson: Samples and confidence
BPE: Byte-pair encoding: a way to build a token vocabulary by repeatedly merging the most common pairs of characters. Lesson: Tokenization and BPE
Bradley-Terry model: A way to turn many "A beat B" judgments into one strength score per item, so you can predict how often any item beats any other. Lesson: Instruction and preference data
branch protection: Repository rules that only let changes into the main branch through pull requests that pass required checks. Lesson: CI/CD pipelines
breadth-first search: Exploring a graph in rings: everything one step away, then two steps, and so on. It finds the path with the fewest hops. Lesson: Recursion, trees and graphs
broadcasting: NumPy and PyTorch stretching a smaller array to match a bigger one, so you can add a single number or a row to a whole table at once. Lesson: NumPy arrays
burn rate: How fast the error budget is being used, compared with the pace that would last exactly the whole period. Lesson: Reliability and incidents
byte-level BPE: BPE that starts from the 256 possible bytes instead of letters, so it can spell out any text at all, emoji included. Lesson: Tokenization and BPE
bytecode: The simple instruction list Python turns your code into before its virtual machine runs it, one instruction at a time. Lesson: How computers run code

C

cache stampede: Many requests missing the cache at once, such as when a popular entry expires, and all hitting the database. Lesson: Caches, queues and background jobs
cache-aside: Read the cache first; on a miss, load from the source, store the result in the cache, and return it. Lesson: Caches, queues and background jobs
calibration: Whether a model's probabilities can be taken at face value: of the customers it gives 30%, about 30% really churn. Lesson: ROC curves and AUC
call graph: A map of which functions call which, used to understand code and find unused parts. Lesson: Reading unfamiliar code
canary release: Sending a small share of traffic to a new version first, to catch problems before everyone gets it. Lesson: Containers and deployment
CAP theorem: When the network between copies breaks, a system must choose: stay consistent and refuse some requests, or stay available and risk stale answers. Lesson: System design fundamentals
catastrophic forgetting: When fine-tuning on a narrow task makes a model lose skills it had before, because the same weights get overwritten. Lesson: Supervised fine-tuning
causal mask: A rule that stops each token looking at the tokens after it, so the model can't peek at the answer. Lesson: Causal masking
CDN: Servers around the world that keep copies of content close to users, so it loads faster. Lesson: Running APIs in production
central limit theorem: Averages of many random values form a bell curve, even when the values themselves don't. Lesson: The normal distribution
chain rule: To find how a chain of steps responds to a nudge, multiply how much each step responds. Lesson: The chain rule
channel: In images, one layer of numbers per pixel, such as red, green or blue. A CNN layer outputs one channel per filter. Lesson: Convolutional networks
chat template: The fixed format, with special tokens, that marks who is speaking in a conversation, so a chat model knows where your message ends and its reply starts. Lesson: Base models vs assistants
checkpoint: A saved copy of a model's weights at some point in training, so you can go back to it or resume later. Lesson: The training loop
cherry-picking: Showing only the examples or results that look good and leaving out the rest. Lesson: Reading AI papers
chunking: Cutting long documents into smaller pieces so the most relevant pieces can be found and sent to a model. Lesson: Chunking documents
churn: Customers leaving: a customer who stops buying has churned. Predicting churn is the running example in Phase 3. Lesson: What machine learning is
circuit breaker: A guard that stops calling a failing service for a while after repeated errors, then lets one trial call through. Lesson: Designing AI systems
class: A template for making objects that bundle data with the functions that work on it. Lesson: Classes and objects
classification: Predicting which category something belongs to, such as spam or not spam. Lesson: Features and labels
Claude Agent SDK: A library that packages Claude Code's harness: built-in file, shell and web tools, permissions, hooks, subagents and sessions, run on your own machines. Lesson: What an agent harness is
CLAUDE.md: A project instructions file a coding agent loads at the start of every session: build commands, conventions and things to avoid. Lesson: Memory, plans and long tasks
click-through rate: The share of people who saw a link or ad and clicked it: clicks divided by views. Lesson: What an LLM actually does
CLIP: OpenAI's 2021 model, trained on image–caption pairs to place matching pictures and text close together in one shared embedding space. Lesson: Multimodal transformers
closed model: A model you can only use through its maker's API: you can't download its weights or run it yourself. Lesson: Choosing a model
closure: A small function that remembers the values around it when it was made. Autograd stores one per operation to run its backward step later. Lesson: Build an autograd engine
clustering: Grouping similar examples together without being told the groups in advance. Lesson: Clustering
CNN: A network that slides small pattern-detectors across an image to find edges, shapes and objects. Lesson: Convolutional networks
coefficient: Another name for a weight in a linear or logistic regression: how much one feature pushes the prediction. Lesson: Logistic regression
Cohen's kappa: How much two judges agree beyond what chance alone would give: 0 is no better than chance, 1 is perfect agreement. Lesson: Instruction and preference data
ColumnTransformer: A scikit-learn step that prepares different columns in different ways, such as scaling numbers and one-hot encoding categories. Lesson: The scikit-learn workflow
commit: A saved snapshot of your project in git, with a message saying what changed. Lesson: Version control with git
compaction: Replacing the older part of a conversation with a summary, keeping recent turns, so a long task fits in the context window. Lesson: Managing the context window
compiler: A program that translates code into machine instructions ahead of time, so the result runs fast. Lesson: How computers run code
complement: Everything except the event: the chance something does not happen is 1 minus the chance it does. Lesson: Probability basics
comprehension: A one-line way to build a list from another, like [x * 2 for x in prices]. Lesson: Comprehensions
computation graph: A map of every calculation a model did, which lets the computer trace each result back to its inputs. Lesson: Computation graphs
compute-optimal: The split of a fixed compute budget between model size and training tokens that gives the lowest loss: about 20 tokens per parameter. Lesson: Scaling laws
conditional probability: How likely something is once you know something else is true, like rain given dark clouds. Lesson: Conditional probability and Bayes
confidence interval: A range that probably contains the true value, given the data you sampled. Lesson: Samples and confidence
conformance test: A fixed set of checks that any implementation of a protocol should pass, whatever else it does. Lesson: Testing, designing and shipping servers
confused deputy: A program with some authority tricked into using it for someone who shouldn't have it, such as by forwarding a token. Lesson: Securing remote servers with OAuth
confusion matrix: A table counting a classifier's predictions against the true answers: one row per true class, one column per predicted class. For yes/no it shows true and false positives and negatives. Lesson: Multiclass classification
consistent hashing: Placing servers and keys on a ring so that adding or removing a server moves only a small share of keys. Lesson: System design fundamentals
constitutional AI: Training a model to critique and improve its own answers against a written set of principles. Lesson: Constitutional AI
container image: A read-only package of an app with its system files and libraries, run as an isolated container. Lesson: Containers and deployment
contamination: When a benchmark's test questions (or their answers) leaked into a model's training data, so its score overstates what it can really do. Lesson: Benchmarks and their limits
content block: One piece of a message sent to a model, such as a stretch of text, an image or a PDF. A message can hold several. Lesson: Images and documents
context editing: Removing or shrinking parts of a conversation, such as old tool results, to save space. The Claude API can do it on the server. Lesson: Managing the context window
context rot: The drop in a model's accuracy as its context fills with old or irrelevant material. Lesson: Managing the context window
context window: The most text a model can take in at once, measured in tokens: its short-term memory. Lesson: Tokens and the context window
continuous batching: Letting new requests join a running batch the moment a slot frees up, instead of waiting for the whole batch to finish. It keeps the GPU busy. Lesson: Serving models
continuous deployment: Delivery keeps every merged change ready to release; deployment releases each one automatically once checks pass. Lesson: CI/CD pipelines
continuous integration: A server running a project's tests and checks on every change, blocking changes that fail. Lesson: Projects, packaging and CI
contrastive learning: Training that pulls the embeddings of matching pairs (like a question and its answer) together and pushes mismatched pairs apart. Lesson: Encoders and embedding models
conversion rate: The share of people who went on to do the thing you wanted, such as buying, out of those who clicked. Lesson: What an LLM actually does
coroutine: A function that can pause while it waits and resume later, written with async def in Python. Lesson: Concurrency and async
corpus: The collection of text a language model learns from, such as product descriptions or a slice of the web. Lesson: Language modeling
CORS: Headers a server sends to tell browsers which other websites may read its responses. Lesson: Running APIs in production
cosine decay: A schedule that lowers the learning rate along a smooth half-wave curve, slowly at first, then faster, then gently down to near zero. Lesson: Learning rate
cosine similarity: How alike two vectors' directions are, from 1 (same direction) through 0 (unrelated) to -1 (opposite). Lesson: Embeddings
critical path: The longest chain of steps that have to happen one after another. However many agents you add, the job can't finish faster than this. Lesson: Multi-agent systems
cron: A standard way to run a program on a schedule, such as every weekday at 9 a.m. Lesson: LLMs in automations
cross-attention: Attention where one sequence looks at another, such as a translation model's decoder reading the encoder's output. Lesson: Encoders and embedding models
cross-encoder: A model that reads a query and a document together and gives one relevance score. More accurate than comparing embeddings but slower, so it reranks a short list. Lesson: Encoders and embedding models
cross-entropy: A score for how surprised a model is by the right answer. Lower is better; it's the usual training loss for classifiers and language models. Lesson: Cross-entropy and KL divergence
cross-site scripting: An attack where text shown on a web page contains code that runs in visitors' browsers. Escaping the text prevents it. Lesson: Secure coding
cross-validation: Scoring a model several times on different held-back slices of the data, for a steadier estimate. Lesson: Cross-validation
CSV: A plain-text spreadsheet: one row per line, values separated by commas. Lesson: Files and CSV data
CUDA: NVIDIA's system for running code on its GPUs. In PyTorch, "cuda" is the name of the GPU device. Lesson: PyTorch tensors

D

d_model: The width of a transformer: how many numbers stand for each token as it passes through the layers. Lesson: Embedding layers
data drift: When the data a model sees in use slowly stops looking like the data it learned from, so its accuracy quietly falls. Lesson: The scikit-learn workflow
data leakage: When information from the test data sneaks into training, so the model looks better than it really is on new data. Lesson: Train, validation and test sets
database transaction: A group of database changes that all happen together or not at all. Lesson: Databases and SQL
dataclass: A Python class declared by listing its typed fields; Python writes the setup code for you. Lesson: Types and data modeling
dead ReLU: A ReLU neuron whose input is always negative, so it always outputs 0, gets no gradient and stops learning. Lesson: Debugging training
dead-letter queue: Where a queue puts jobs that failed too many times, so a person can inspect them. Lesson: Caches, queues and background jobs
decision boundary: The line (or surface) where a model switches from answering yes to answering no. Lesson: Logistic regression
decision tree: A model that asks a series of yes/no questions about the inputs to reach a prediction. Lesson: Decision trees
decoder: A transformer that reads left to right and predicts the next token; each token can only see the ones before it. GPT-style chat models are decoders. Lesson: The transformer block
decorator: A line starting with @ just above a function that adds extra behavior to it, such as @app.post("/api/answer"). Lesson: The agent loop
demonstration: In fine-tuning, an example conversation showing exactly the reply you want the model to learn to give. Lesson: Supervised fine-tuning
dense model: An ordinary model where every token uses every parameter, as opposed to a mixture of experts. Lesson: Mixture of experts
dependency injection: Handing code the things it needs (a database, a model client) instead of letting it create them, so they can be swapped or faked in tests. Lesson: Software design
derivative: How fast something changes when you nudge its input: the slope at a point. Lesson: Derivatives
design doc: A document written before building something big: the problem, goals, non-goals, proposal, alternatives and risks. Lesson: Writing for engineers
design pattern: A named, reusable solution to a common design problem, such as an adapter or a strategy. Lesson: Software design
dictionary: A collection of key–value pairs, like a contacts list that maps a name to a phone number. Lesson: Dictionaries
dimension: How many numbers a vector has. A vector with 3 numbers is 3-dimensional. Lesson: Vectors
dimensionality reduction: Squeezing many columns into a few while keeping most of the information, to speed models up or to draw data in 2D. Lesson: Dimensionality reduction
distillation: Training a small model to imitate a big one, keeping much of its skill at lower cost. Lesson: Distillation
distribution: A description of all the possible outcomes and how likely each one is. Lesson: Distributions
diverge: When training blows up: the loss grows instead of settling, often because the learning rate is too big. Lesson: Learning rate
DNS: The internet's directory: it turns a name like api.shop.test into the numeric address of the server. Lesson: HTTP from the wire up
DNS rebinding: A trick that lets a web page reach servers on your own computer through your browser. Checking the Origin header blocks it. Lesson: Transports II: Streamable HTTP
Dockerfile: A recipe of instructions that builds a container image, one layer per instruction. Lesson: Containers and deployment
dot product: Multiply two vectors number by number and add up the results. Big when they point the same way. Lesson: Dot product and cosine similarity
double descent: When a model is made far bigger than the data seems to justify, its test error can fall again after first rising. It's one reason huge neural networks still generalize. Lesson: Bias and variance
DPO: Direct preference optimization: training straight from preference pairs, without a separate reward model. Lesson: DPO and direct preference methods
draft model: In speculative decoding, the small fast model that guesses the next few tokens for the big model to check. Lesson: Speculative decoding
dropout: Randomly switching off some neurons during training so the network can't lean on any single one. Lesson: Dropout
dtype: What kind of number an array holds, such as whole numbers (int64) or decimals (float32). It sets precision and memory use. Lesson: NumPy arrays
dual-era: MCP software that speaks both the old handshake and the new stateless style, answering each caller in whichever it opens with. Lesson: Discovery, capabilities and the two eras
dynamic programming: Solving a problem by filling in a table of answers to smaller, overlapping versions of it. Lesson: Searching, sorting and dynamic programming

E

early stopping: Stopping training once the validation score stops improving, and keeping the best version so far. Lesson: Random forests and boosting
eigenvector: A direction that a matrix only stretches or shrinks, without turning it. Lesson: Eigenvectors (intuition)
elastic net: Regularization that mixes the ridge and lasso penalties. Lesson: Regularization
elbow method: Picking the number of clusters where adding more stops making the clusters much tighter: the bend in the curve. Lesson: Clustering
elicitation: An MCP server asking the user a question, such as a confirmation, through the app while it handles a request. Lesson: Progress, subscriptions and multi-round-trip requests
embedding: A list of numbers that captures what a piece of text means, so similar meanings get similar numbers. Lesson: Embeddings
embedding layer: A lookup table that gives each word or token its own learned list of numbers. Lesson: Embedding layers
embedding space: The map that embeddings live on, where nearby points mean similar things. CLIP puts images and text on the same map. Lesson: Multimodal transformers
encoder: A transformer that reads the whole text at once to understand it, used for embeddings and classification. Lesson: Encoders and embedding models
endpoint: One specific web address of an API that does one job, like /v1/messages. Lesson: How APIs work
ensemble: Several models whose answers are combined, by voting or averaging. Together they usually beat any one of them. Lesson: Random forests and boosting
entropy: How unpredictable something is. A fair coin has more entropy than a coin that nearly always lands heads. Lesson: Entropy and surprise
enum: A fixed set of allowed values, such as an order status of pending, paid or shipped. Lesson: Types and data modeling
environment variable: A setting stored outside your code, often used to keep secrets such as API keys out of files. Lesson: API keys and secrets
epoch: One full pass of training over every example in the training set. Lesson: Training with gradient descent
error budget: The failures an SLO allows, such as 0.1% of requests. While budget remains, ship; when it's spent, focus on reliability. Lesson: Reliability and incidents
estimator: scikit-learn's name for anything with a fit method: models, scalers and whole pipelines. Lesson: The scikit-learn workflow
ETag: A short tag naming one version of a resource, used to skip unchanged downloads and to stop conflicting updates. Lesson: A database-backed API
eval: A set of test cases with expected results, used to measure how well an AI system does its job. Lesson: Evals
evaluation harness: Code that runs a model or agent across a fixed set of tasks, in clean environments, and scores the results. Lesson: Evaluation harnesses
event loop: The part of an async program that runs many tasks on one thread, switching whenever one is waiting. Lesson: Concurrency and async
eventual consistency: Copies of data may briefly disagree after a write, but come to agree soon after. Lesson: System design fundamentals
exception: An error Python raises when something goes wrong while the program runs. Lesson: Errors and exceptions
exit code: The number a program hands back when it ends: 0 for success, anything else for a kind of failure. Lesson: Capstone: a command-line app
expected value: The long-run average of a random amount: each value times its chance, all added up. Lesson: Mean, variance and spread
expert: One of the several feed-forward networks in a mixture-of-experts layer. Each token only goes through the few the router picks. Lesson: Mixture of experts
explained variance ratio: The share of the data's spread that each PCA component keeps. Adding them up shows how much a few components hold. Lesson: Dimensionality reduction
exponential: Growth by repeated multiplying, like doubling every step. Lesson: Exponentials and logarithms
exponential backoff: Waiting longer after each failed try before trying again: 1 second, then 2, then 4. Lesson: LLMs in automations

F

f-string: A string with an f in front that can slot values in, like f"Hi {name}". Lesson: Strings and f-strings
F1 score: One number that balances precision and recall. Lesson: Precision, recall and F1
fail closed: When a safety check itself breaks, block the action instead of allowing it. Failing open allows it. Lesson: Hooks and skills
false negative: A no the model got wrong: it predicted the customer would stay, but they churned. Lesson: Precision, recall and F1
false positive: A yes the model got wrong: it predicted churn, but the customer stayed. Lesson: Precision, recall and F1
false positive rate: The share of real negatives the model wrongly flags, such as the share of loyal customers it says will churn. Lesson: ROC curves and AUC
false refusal: A model refusing a request that was actually harmless, such as declining to explain how locks work. Lesson: Constitutional AI
fan-in: How many inputs feed into one neuron. Good starting weights shrink as fan-in grows. Lesson: Weight initialization
feature: One input column a model learns from, such as a customer's age or number of orders. Lesson: Features and labels
feature engineering: Turning raw data into inputs that make a pattern easier to learn, like days since last purchase. Lesson: Feature engineering
feature flag: A switch in code that turns a feature on or off for some users without a deploy. Lesson: CI/CD pipelines
feature map: The grid of scores a CNN filter produces: high where its pattern appears in the image, low elsewhere. Lesson: Convolutional networks
feed-forward network: The small neural network inside each transformer block. It works on each token on its own, after attention has mixed in information from the other tokens. Lesson: The transformer block
few-shot: Putting a few worked examples in a prompt so the model copies the pattern. Lesson: Examples in prompts
fine-tuning: Further training a pretrained model on a smaller, focused set of examples to change its behavior. Lesson: Choosing a model
flaky test: A test that sometimes passes and sometimes fails with no code change, usually from timing or shared state. Lesson: CI/CD pipelines
FlashAttention: A faster way to compute exactly the same attention on a GPU, by working in small tiles so it rarely touches slow memory. Lesson: Scaled dot-product attention
float: A number with a decimal point, such as 0.5 or 3.14. Lesson: Numbers and arithmetic
FLOPs: Floating-point operations: the count of basic multiply-and-add steps. Training cost and chip speed are both measured in them. Lesson: GPUs and compute
fold: One of the equal slices that cross-validation cuts the data into. Each fold takes a turn as the held-back data. Lesson: Cross-validation
foreign key: A column holding another table's primary key, which links the two rows, like an order's customer_id. Lesson: Databases and SQL
forward pass: Running inputs through the network, layer by layer, to get a prediction. Lesson: The forward pass
FP8: Floating-point numbers stored in 8 bits (FP4: 4 bits), used to run or train models faster and in less memory than 16-bit numbers. Lesson: Quantization
front end: The part of an app that runs in the user's browser or phone. Anyone can read its code. Lesson: Shipping an LLM app
function: A named, reusable piece of code that takes inputs and gives back a result. Lesson: Functions

G

GELU: A smooth cousin of ReLU used in most transformers. It lets small negative values through a little instead of cutting them to 0. Lesson: Activation functions
GGUF: The file format llama.cpp and tools built on it use for quantized models you run on your own computer. Lesson: Quantization
Gini impurity: How mixed a group is: the chance two random picks from it (with replacement) disagree. 0 means everyone in the group has the same label. Lesson: Decision trees
git: A tool that records versions of your files so you can see changes and undo mistakes. Lesson: Version control with git
git bisect: A Git command that binary-searches history to find the commit that introduced a bug. Lesson: Git for teams
Goodhart's law: "When a measure becomes a target, it ceases to be a good measure": optimize for a score and the score stops meaning what it did. Lesson: Benchmarks and their limits
GPT: Generative pre-trained transformer: a stack of transformer blocks trained to predict the next token. Lesson: The GPT architecture
GPTQ: A popular way to quantize a model's weights after training, adjusting the rounding so the layer's outputs change as little as possible. Lesson: Quantization
GPU: A graphics chip that does thousands of multiplications at once, which is why it trains neural networks fast. Lesson: GPUs and compute
gradient: The list of all the partial derivatives: it points in the direction that makes a result rise fastest. Lesson: Gradients
gradient boosting: Adding small decision trees one at a time, each fixing the mistakes left by the ones before. Lesson: Random forests and boosting
gradient clipping: Capping how big the gradient can get before a step, so one bad batch can't blow up training. Lesson: Vanishing and exploding gradients
gradient descent: Improving a model by taking small steps in the direction that lowers the error the most, over and over. Lesson: Optimization by walking downhill
GraphQL: An API style with one endpoint where the client's query names exactly the fields it wants back. Lesson: API styles
greedy decoding: Always picking the single most likely next word. Simple and repeatable, but it can sound flat or loop. Lesson: Distributions
grid search: Trying every combination from a list of settings, scoring each with cross-validation, and keeping the best. Lesson: Cross-validation
grounding: Making a model answer only from sources you give it, and say so when they don't cover the question. Lesson: Hallucinations and grounding
grouped-query attention: Letting groups of query heads share one key head and one value head, so the KV cache shrinks with little loss in quality. Lesson: Inference and the KV cache
gRPC: A fast way for services to call each other's functions, with typed messages and generated code. Lesson: API styles
GRPO: Group relative policy optimization: sample several answers to one problem and push up the ones that beat the group's average. Lesson: Training reasoning models
GRU: A simpler cousin of the LSTM with fewer gates. It also helps an RNN remember across long sequences. Lesson: Recurrent networks

H

hallucination: When a model states something false with confidence, because it predicts plausible text rather than checking facts. Lesson: Hallucinations and grounding
harmonic mean: An average that stays low if either number is low. F1 is the harmonic mean of precision and recall. Lesson: Precision, recall and F1
hash table: A structure that turns a key into a slot number, so it can store and find values in about one step. Dicts and sets use one. Lesson: Core data structures
He initialization: Starting weights sized for ReLU layers: random, with a spread of about √(2 / fan-in), so signals keep a steady size through many layers. Lesson: Weight initialization
head size: How many numbers each query and key holds in one attention head. Scores are divided by its square root. Lesson: Scaled dot-product attention
headline metric: The one number you agree in advance to judge a model by, so you can't pick whichever number looks best afterwards. Lesson: Capstone: a tuned, evaluated assistant
health check: A simple web address your host calls now and then to check your app is still running. Lesson: Shipping an LLM app
held-out: Data kept aside and never used for training, so you can test the model on examples it hasn't seen. Lesson: Evals
hidden state: An RNN's running memory: a list of numbers it updates after each word and passes on to the next step. Lesson: Recurrent networks
hit rate: The share of test questions where the right document appears in the top k results. Lesson: Making RAG good
HNSW: A popular index for approximate nearest-neighbor search: a layered graph you hop through, from coarse links to fine ones, toward the closest vectors. Lesson: Vector databases
holdout group: Customers or data deliberately left out, so you can compare against them and see the real effect. Lesson: Capstone: churn prediction
HTTP: The rules web browsers and APIs use to send requests and get responses. Lesson: How APIs work
Huber loss: A loss that treats small misses like squared error and big misses like absolute error, so a few wild values can't dominate training. Lesson: Loss functions
Hugging Face Hub: The main website for sharing open models and datasets, each with a model card. Lesson: Running open models locally
hybrid search: Combining keyword search with embedding search, so you get both exact-word matches and matches in meaning. Lesson: Making RAG good
hyperparameter: A setting you choose before training, such as tree depth or learning rate, rather than one the model learns. Lesson: Cross-validation
hyperplane: A flat dividing surface in any number of dimensions: a line in 2D, a flat sheet in 3D, and so on. Lesson: The artificial neuron

I

idempotency key: A unique id a client sends with a request so that retrying it can't make the server do the work twice. Lesson: Rate limits, retries and idempotency
idempotent: Safe to run twice: doing it again has no extra effect, like pressing an elevator button that's already lit. Lesson: LLMs in automations
imperative mood: Writing as a command, such as "Add retries". The convention for commit message subjects. Lesson: Writing for engineers
implicit reward: In DPO, the score you can read off from how much more likely the trained model makes an answer than the reference model does. Lesson: DPO and direct preference methods
import: The Python command that loads code from a module so you can use it. Lesson: Modules and imports
imputing: Filling in a missing value with a sensible guess, such as the column's median. Lesson: Preparing data
incident commander: The person who coordinates an incident response and makes decisions, while others do the hands-on work. Lesson: Reliability and incidents
independent: Two events are independent when one happening doesn't change the chance of the other, like two separate coin flips. Lesson: Probability basics
index: The position of an item in a list. Python counts from 0, so the first item is at index 0. Lesson: Lists
inertia: How tight a k-means clustering is: the total squared distance from each point to its cluster's center. Lower is tighter. Lesson: Clustering
inference: Using a trained model to make predictions, as opposed to training it. Lesson: Inference and the KV cache
information content: How surprising one outcome is, in bits: rare events carry more information than common ones. Lesson: Entropy and surprise
integer: A whole number with no decimal point, such as 3 or -12. Lesson: Numbers and arithmetic
intercept: In a straight-line model, the prediction when every feature is 0: where the line crosses the vertical axis. Lesson: Linear regression
interpretability: Research into what is actually happening inside a model's numbers. Lesson: Interpretability
interpreter: A program that carries out code as it reads it, instead of translating it all first. Lesson: How computers run code
inverted dropout: The usual way dropout works: scale up the surviving values during training, so nothing needs changing when the model is used. Lesson: Dropout
irreducible loss: The floor the loss approaches however big the model and data get, because some text is simply unpredictable. Lesson: Scaling laws

J

Jaccard similarity: How alike two sets are: the number of items they share, divided by the number of different items in both. 1 means identical, 0 means nothing in common. Lesson: Pretraining at scale
jailbreak: A prompt written to trick a model into ignoring its safety rules. Lesson: Constitutional AI
jitter: A small random extra wait added before a retry, so many programs don't all retry at the same moment. Lesson: LLMs in automations
JSON: A common text format for data, made of lists and key–value pairs. Most APIs send and receive it. Lesson: JSON
JSON Lines: A file format with one JSON record per line, the usual way to store training examples. Lesson: Instruction and preference data
JSON schema: A precise description of the JSON you expect: which fields, what type each is, and which are required. Lesson: Structured output
JSON-RPC: A simple way for one program to ask another to run a named command, with the request and reply written as JSON. MCP uses it. Lesson: Model Context Protocol
JWT: A signed token carrying facts about the caller, such as who they are and when the token expires. Signed, not secret. Lesson: Authentication and authorization

K

kernel: In a CNN, a small grid of weights that slides over an image and scores how strongly each patch matches a pattern, such as an edge. Lesson: Convolutional networks
key: In attention, what a token offers to be matched on, like a page's index entry. Lesson: Queries, keys and values
keyword search: Finding documents that contain the words in the question. It catches exact names and codes that meaning-based search can miss. Lesson: Making RAG good
KL divergence: A measure of how different one set of probabilities is from another. Lesson: Cross-entropy and KL divergence
KV cache: Saving the keys and values of earlier tokens so the model doesn't recompute them for every new token. Lesson: Inference and the KV cache

L

label: The right answer for an example, which the model learns to predict. Lesson: Features and labels
language model: A model that predicts the next token from the ones before it. Lesson: Language modeling
language-model head: The last layer of a language model. It turns the final vector at each position into one score per token in the vocabulary. Lesson: The GPT architecture
lasso: Regularization that adds the plain size of every weight to the loss. It pushes unhelpful weights to exactly zero, so it also picks features. Lesson: Regularization
latency: How long you wait for a response. Lesson: Cost and latency
layer: One stage of a neural network that transforms numbers before passing them on. Lesson: Multi-layer networks
leaf: An end point of a decision tree, with no more questions. It gives the prediction. Lesson: Decision trees
learning curve: A chart of training and validation scores as the training set grows. The gap between the lines shows whether more data would help. Lesson: Bias and variance
learning rate: How big a step training takes each time. Too big overshoots; too small crawls. Lesson: Learning rate
learning-rate schedule: A plan for changing the learning rate as training goes on, usually starting larger and ending smaller. Lesson: Learning rate
learning-rate sweep: Training briefly with several learning rates, often each about three times the last, and keeping the one whose loss falls best. Lesson: Learning rate
least squares: Fitting a model by choosing the weights that make the sum of squared errors as small as possible. Lesson: Linear regression
lethal trifecta: An agent that can read private data, also reads untrusted text, and can send data out. With all three, one hidden instruction can leak your data. Lesson: Prompt injection and security
lifecycle hook: Code a harness runs at a set moment, such as before or after each tool call. It can block, change or add to what happens. Lesson: Hooks and skills
lifetime value: The total a customer has spent with a business so far, or is expected to spend over the whole relationship. Lesson: Feature engineering
lift: How many times better a targeted group does than average: if 40% of the top 5 churn against 20% overall, the lift is 2. Lesson: Capstone: churn prediction
likelihood: How well some settings explain the data you saw. Training often picks the settings that make the data most likely. Lesson: Maximum likelihood
linear regression: Predicting a number with a straight-line formula: a weight for each input, added up, plus a starting value. Lesson: Linear regression
linearly separable: When one straight line (or flat surface) can split the yes examples from the no examples. A single neuron can only learn these. Lesson: The artificial neuron
linked list: A chain of small objects, each holding one item and a pointer to the next one. Lesson: Core data structures
linter: A tool that reads code and flags likely mistakes and bad patterns without running it. Lesson: Projects, packaging and CI
list: An ordered collection of values in square brackets, like [3, 5, 8]. Lesson: Lists
llama.cpp: A fast open-source program for running quantized models on ordinary computers, including laptops without a big GPU. Lesson: Running open models locally
LLM: A large language model: a program trained on huge amounts of text to predict the next word, which lets it write, answer and reason. Lesson: What an LLM actually does
LLM-as-judge: Using one model to grade another model's answers against a rubric. Lesson: LLM-as-judge
load balancer: A service that spreads incoming requests across several copies of a server. Lesson: Running APIs in production
load-balancing loss: An extra training penalty that pushes the router to spread tokens evenly, so no expert is overloaded and none sits unused. Lesson: Mixture of experts
local derivative: How one small step in a computation graph changes its output when its input moves a little. Backpropagation multiplies these along the path. Lesson: Computation graphs
lockfile: A file recording the exact version of every installed package, so every install gets the same ones. Lesson: Projects, packaging and CI
log-likelihood: The log of the likelihood. Adding logs is easier than multiplying many tiny chances, and the best fit stays the same. Lesson: Maximum likelihood
log-log plot: A chart where both axes use a log scale, so each step along an axis multiplies by 10. Power laws turn into straight lines. Lesson: Scaling laws
log-odds: The natural log of the odds. Logistic regression's score is a log-odds: 0 means 50/50, positive leans yes, negative leans no. Lesson: Logistic regression
logarithm: The reverse of an exponential: how many times you multiply to get a number. log₁₀(1000) is 3. Lesson: Exponentials and logarithms
logistic regression: A simple classifier: a weighted sum of inputs squeezed into a probability between 0 and 1. Lesson: Logistic regression
logit: A raw score a model gives each option before softmax turns the scores into probabilities. Lesson: Softmax
logit lens: Reading a model's in-progress guess at each layer by passing the hidden state straight to the output layer. Lesson: Interpretability
long tail: A shape of data with a big crowd of small values and a thin trail of a few giant ones, such as customer spending. Lesson: Feature engineering
long-term memory: Facts an app saves outside the model, such as a user's preferences, and adds back into the prompt in later conversations. Lesson: Conversations and memory
loop: Code that repeats: for each item in a list, or while something stays true. Lesson: Loops
loop detection: Spotting an agent repeating the same call with the same result, and stepping in before a budget runs out. Lesson: Tracing, budgets and guardrails
LoRA: Low-rank adaptation: fine-tuning by training a small add-on instead of all the weights, which is far cheaper. Lesson: LoRA
loss: A single number saying how wrong a model's predictions are. Training tries to make it small. Lesson: Loss functions
lossless: Changing how something is computed without changing the result at all, such as speculative decoding producing exactly what the big model would have. Lesson: Speculative decoding
lower-triangular: A grid with numbers on and below the diagonal and zeros above it. The causal mask has this shape: each token sees only itself and earlier ones. Lesson: Causal masking
LRU cache: A cache with a size limit that throws away the least recently used entry when it's full. Lesson: Performance and profiling
LSTM: An RNN with gates that decide what to keep, forget and output, so it can carry information across many more steps. Lesson: Recurrent networks

M

machine learning: Getting a computer to learn a pattern from examples instead of writing the rules by hand. Lesson: What machine learning is
macro average: Averaging a score across classes with each class counted equally, however rare it is. Lesson: Precision, recall and F1
majority baseline: The accuracy you get by always predicting the most common class. A model has to beat it to be worth anything. Lesson: Multiclass classification
managed agents: A hosted option where Anthropic runs the agent loop and a sandbox container for each session. Lesson: What an agent harness is
map-reduce: Splitting a big job into pieces, handling each piece separately (map), then combining the results (reduce). Lesson: Prompt chaining
margin of error: The plus-or-minus around an estimate, such as 3.2% ± 0.8%. It is usually about two standard errors. Lesson: Samples and confidence
masked language modeling: Training by hiding some tokens and asking the model to guess them from the words on both sides. It's how BERT learned. Lesson: Encoders and embedding models
mass assignment: A bug where an API copies every field a client sends, letting it set things like role or price it shouldn't. Lesson: A database-backed API
matrix: A table of numbers with rows and columns. Lesson: Matrices
matrix multiplication: Combining two tables of numbers by taking dot products of rows with columns. It is most of the arithmetic inside a neural network. Lesson: Matrix multiplication
max pooling: Shrinking a feature map by keeping only the biggest value in each small square, so a pattern counts wherever it shows up nearby. Lesson: Convolutional networks
MCP: Model Context Protocol: a standard way to plug tools and data sources into AI apps. Lesson: Model Context Protocol
MCP client: The part of an AI app that holds one connection to one MCP server and speaks the protocol for it. Lesson: Build a client
MCP host: The AI app, such as a chat app or code editor, that connects to MCP servers and lets the model use their tools. Lesson: Model Context Protocol
MCP Inspector: A developer tool that connects to an MCP server so you can browse and call its tools, resources and prompts by hand. Lesson: Testing, designing and shipping servers
MCP server: A small program that offers tools or data to AI apps through MCP, such as one that reads your calendar. Lesson: Model Context Protocol
mean: The average: add the values up and divide by how many there are. Lesson: Mean, variance and spread
mean absolute error: The average size of the misses, ignoring whether each was too high or too low. A miss twice as big costs twice as much. Lesson: Loss functions
mean pooling: Turning a text's token vectors into one vector for the whole text by averaging them. Lesson: Encoders and embedding models
mean reciprocal rank: A search score: for each test question, 1 ÷ the rank of the first right document, averaged. 1 means the right one always comes first. Lesson: Making RAG good
mean squared error: A loss: square each prediction's error and average them, so big mistakes count extra. Lesson: Loss functions
median: The middle value once the numbers are sorted. Unlike the average, one huge value barely moves it. Lesson: Preparing data
memoization: Saving a function's results so a repeat call with the same input returns instantly. Lesson: Searching, sorting and dynamic programming
memory bandwidth: How many bytes per second a chip can read from its memory. Generating text one token at a time is usually limited by this, not by arithmetic. Lesson: Inference and the KV cache
memory poisoning: An injected instruction saved into an agent's memory, where it comes back in later sessions. Lesson: Memory, plans and long tasks
memory tool: A Claude API tool the model uses to view and edit files under /memories. Your harness carries out each command. Lesson: Memory, plans and long tasks
merge conflict: When two branches changed the same lines differently, so Git can't combine them without a person deciding. Lesson: Git for teams
metadata: Facts stored alongside a piece of content, such as which document it came from, its date or its section, used to filter and cite. Lesson: Chunking documents
method: A function that belongs to an object, called with a dot, like name.upper(). Lesson: Classes and objects
middleware: Code that wraps every request to an app, for jobs like logging, timing, authentication and adding headers. Lesson: A web framework, from the inside
MinHash: A hashing trick that estimates Jaccard similarity from short signatures, so near-duplicate documents can be found without comparing every pair. Lesson: Pretraining at scale
mini-batch: A small group of training examples processed together in one step. Batch size is how many examples it holds. Lesson: Training with gradient descent
mixed precision: Doing most of the math in smaller, faster number formats like bf16, while keeping a full-precision copy where accuracy matters. Lesson: GPUs and compute
mixture of experts: A model with many specialist sub-networks, where only a few are switched on for each token, saving compute. Lesson: Mixture of experts
MLP: Multi-layer perceptron: the basic neural network, with layers of neurons fully connected to the next layer. Lesson: Multi-layer networks
model: The thing that learns: a formula with adjustable numbers that turns inputs into predictions. Lesson: What machine learning is
model card: The fact sheet published with a model: its size, what it was trained on, what it's for and its known limits. Lesson: The transformer block
model routing: Sending each request to a suitable model, such as easy ones to a small cheap model and hard ones to a large one. Lesson: Designing AI systems
module: A file of Python code you can import and reuse. Lesson: Modules and imports
momentum: An optimizer trick: keep a running average of recent steps so training keeps rolling in a steady direction instead of zigzagging. Lesson: Optimizers
multi-agent: Several AI agents working together, each with its own role, passing work between them. Lesson: Multi-agent systems
multi-head attention: Running several attention patterns side by side, so the model can track different relationships at once. Lesson: Multi-head attention
multi-query attention: The extreme of grouped-query attention: every query head shares a single key head and value head, giving the smallest KV cache. Lesson: Inference and the KV cache
multi-round-trip request: MCP's way to ask for more input mid-call: the server ends the request with a question, and the client retries it with the answer. Lesson: Progress, subscriptions and multi-round-trip requests
multiclass classification: Classification with more than two possible answers, such as sorting customers by their favorite product category. Lesson: Multiclass classification
multimodal: Able to work with more than text, such as images, documents or audio. Lesson: Images and documents
mutually exclusive: Events that can't both happen at once, like a die showing 2 and showing 5. Their chances simply add. Lesson: Probability basics

N

n-gram: A model that predicts the next item from the previous n − 1 items. A bigram uses one, a trigram two. Lesson: A bigram model
N+1 query problem: Running one database query for a list, then another for every item in it, instead of one combined query. Lesson: Performance and profiling
nat: A unit of information that uses natural logs instead of base 2. One nat is about 1.44 bits. Lesson: Entropy and surprise
natural logarithm: The log that undoes e to a power: ln(x) asks "e to what power gives x?" So ln(e) is 1 and ln(1) is 0. Lesson: Exponentials and logarithms
nearest neighbors: Predicting from the most similar past examples. Lesson: Nearest neighbors
neural network: A model made of layers of simple units; each layer turns its inputs into new numbers for the next layer. Lesson: Multi-layer networks
neuron: One unit in a neural network: a weighted sum of its inputs, then a simple function. Lesson: The artificial neuron
next-token prediction: The one task a language model is trained on: guess the next piece of text from everything before it. Lesson: What an LLM actually does
nit: A review comment about something tiny and optional, labeled so the author knows it isn't blocking. Lesson: Code review
non-functional requirement: How well a system must work rather than what it does: latency, scale, availability, consistency, cost and security. Lesson: System design fundamentals
normal distribution: The bell-shaped curve: most values sit near the average, and fewer the further you go. Lesson: The normal distribution
normalization: Rescaling the numbers inside a network so they stay in a steady range, which makes training smoother. Lesson: Normalization layers
null hypothesis: The boring explanation you try to rule out: "there's no real difference, it's just chance". Lesson: A/B tests and significance
NumPy: A Python library for fast math on whole arrays of numbers at once. Lesson: NumPy arrays

O

OAuth: The standard way to let an app act for you on another service, without giving it your password. Lesson: Authentication and authorization
object: One thing made from a class, with its own data, like one customer record. Lesson: Classes and objects
observability: Recording what your AI app did on each request (inputs, outputs, timing, cost) so you can find problems. Lesson: Logging and monitoring
odds: The chance something happens divided by the chance it doesn't. A 75% chance is odds of 3 (3 to 1). Lesson: Logistic regression
odds ratio: How much the odds get multiplied when one feature goes up by 1. Above 1 raises the odds; below 1 lowers them. Lesson: Logistic regression
Ollama: A free app for downloading and running open models on your own computer with one command. Lesson: Running open models locally
one-hot encoding: Turning a category into columns of 0s and 1s, with a 1 in the column of the matching category. Lesson: Preparing data
online softmax: Computing a softmax one chunk at a time with a running maximum and a running total, so the full row of scores never has to be stored. Lesson: Long context
open-weight model: A model whose weights are published, so you can download and run it yourself. Lesson: Choosing a model
OpenAPI: A standard, machine-readable description of an API's endpoints, used to make docs, client libraries and tests. Lesson: Documenting APIs with OpenAPI
OpenTelemetry: An open standard for traces, metrics and logs, with conventions for recording model and tool calls. Lesson: Tracing, budgets and guardrails
optimistic concurrency: Letting anyone edit, but only saving if the record hasn't changed since they loaded it, checked with a version number. Lesson: A database-backed API
optimizer: The rule that decides how to change the weights each step, given the gradients. Adam is the usual choice. Lesson: Optimizers
orchestrator: A model that splits a job into parts as it goes and hands each part to a worker, then combines the results. Lesson: Agent design patterns
outlier: A value far from the rest, such as one order of $5,000 among orders of about $50. It can be a real event or a mistake. Lesson: Preparing data
overfitting: When a model memorizes its training examples, including their noise, and does worse on new data. Lesson: Overfitting and underfitting
overlap: In chunking, the words repeated at the end of one chunk and the start of the next, so an idea split across a boundary still appears whole somewhere. Lesson: Chunking documents
overtraining: Training a model on far more tokens than compute-optimal. Training costs more, but the smaller model is cheaper to run for every user afterwards. Lesson: Scaling laws

P

package: Code someone else wrote and published, which you install and import, like NumPy. Lesson: Packages and environments
padding: Extra zeros added around an image's edge so a CNN filter can be centered on edge pixels too, and the output shrinks less. Lesson: Convolutional networks
PagedAttention: Storing each conversation's KV cache in small fixed-size blocks, like pages of memory, so little memory is wasted and more conversations fit at once. Lesson: Serving models
pagination: Returning a long list one page at a time, with a way to ask for the next page. Lesson: Designing a REST API
parameter count: How many adjustable numbers (weights) a model has. Large language models have billions. Lesson: Scaling laws
parameter-efficient fine-tuning: Fine-tuning that trains only a small number of new or chosen weights, such as LoRA adapters, instead of the whole model. Lesson: Prompting vs RAG vs fine-tuning
partial derivative: How much a result changes when you nudge just one of several inputs and hold the rest still. Lesson: Partial derivatives
pass@k: The chance that at least one of k attempts at a problem is correct. Lesson: Training reasoning models
pass^k: The chance an agent succeeds on all k tries at the same task: a test of reliability, where pass@k tests whether it can succeed at all. Lesson: Evaluating agents
patch embedding: The layer that turns each small square of an image into a list of numbers, like a token embedding for pictures. Lesson: Multimodal transformers
path parameter: A placeholder in a URL pattern, like {id} in /campaigns/{id}, that captures part of the path. Lesson: Build an API server from scratch
path traversal: An attack that uses ../ in a file name to reach files outside the folder an app meant to share. Lesson: Secure coding
payback period: How long before the money a change saves covers what it cost to set up. Lesson: Prompting vs RAG vs fine-tuning
PCA: A way to boil many columns of data down to the few directions where the data varies most. Lesson: SVD and PCA
percent-encoding: Writing special characters in a URL as % and two hex digits, such as a space as %20. Lesson: HTTP from the wire up
percentile: The value below which a given share of results fall. The 95th percentile beats 95% of the others. Lesson: Logging and monitoring
permission mode: A setting for how much an agent may do unasked, from read-only planning to allowing file edits. Lesson: Permissions and approvals
permutation importance: How much a model's score drops when one column is shuffled. A big drop means the model leans on that column. Lesson: Capstone: churn prediction
perplexity: How many words a language model is effectively choosing between at each step. Lower is better; it's e to the cross-entropy. Lesson: Cross-entropy and KL divergence
pipeline: A fixed series of steps that data goes through in order, such as fill gaps, rescale, then predict, so the steps can't get mixed up. Lesson: Preparing data
PKCE: An OAuth safeguard: the app proves it started the login with a secret only it knows, so a stolen code is useless. Lesson: Authentication and authorization
PMF: A list of every value a random count can take and the chance of each one. The chances add up to 1. Lesson: Distributions
Poisson distribution: The chances of a count of events in a fixed time, like sign-ups per hour, when they happen at a steady average rate. Lesson: Distributions
policy: In reinforcement learning, the model being trained: the thing that decides what to do (here, which token to write next). Lesson: RLHF
policy gradient: Training by making high-scoring answers more likely and low-scoring ones less likely, in proportion to how good they were. Lesson: Training reasoning models
position bias: Preferring whichever answer is shown first (or second) regardless of quality. Swapping the order and asking again exposes it. Lesson: Instruction and preference data
position interpolation: Stretching a model's context by squeezing the new, longer positions into the range it was trained on, then fine-tuning it briefly. Lesson: Long context
positional encoding: Extra numbers that tell the model where each token sits in the sequence. Lesson: Positional encodings
post-training: Everything done to a model after pretraining to turn a text predictor into an assistant: fine-tuning on example chats, preference training and safety work. Lesson: Base models vs assistants
posterior: Your updated belief after seeing the evidence. Bayes' rule turns the prior into the posterior. Lesson: Conditional probability and Bayes
power law: A curve where each doubling of the input cuts the output by the same fraction. It shows up as a straight line on a log-log plot. Lesson: Scaling laws
PPO: Proximal policy optimization: the reinforcement-learning method classic RLHF uses, which nudges the model toward higher-scoring answers in small, careful steps. Lesson: RLHF
pre-norm: Putting the normalization before each sub-layer instead of after it. It makes deep transformers much easier to train. Lesson: Normalization layers
pre-tokenization: Splitting text into rough chunks, such as words and spaces, before the tokenizer merges pieces inside each chunk. Lesson: Tokenization and BPE
precision: Of the things a model flagged, the share that were right. Lesson: Precision, recall and F1
precision-recall curve: A chart of precision against recall as the threshold moves. More telling than the ROC curve when the thing you're looking for is rare. Lesson: ROC curves and AUC
preference data: Pairs of answers to the same prompt where people (or a model) marked which one is better. Lesson: Instruction and preference data
preference pair: One prompt with two answers, one marked as preferred (chosen) and one not (rejected). Lesson: DPO and direct preference methods
prefilling: Writing the first words of the model's reply yourself so it continues from there. Newer models reject it; use structured output instead. Lesson: System prompts and roles
preprint: A research paper shared publicly before (or without) peer review. Lesson: Reading AI papers
pretraining: The first, huge training run where a model learns language by predicting the next token across vast amounts of text. Lesson: Pretraining at scale
primary key: A column that uniquely identifies each row of a table, such as an id. Lesson: Databases and SQL
principal component: One of the hidden directions PCA finds: a recipe that mixes the original columns. The first one captures the most spread in the data. Lesson: SVD and PCA
prior: What you believe about a chance before you see new evidence, such as 1% of payments being fraud. Lesson: Conditional probability and Bayes
probability: How likely something is, from 0 (never) to 1 (certain). Lesson: Probability basics
process group: A process and the children it started. Killing the group on timeout stops them all. Lesson: Running code safely
profiler: A tool that measures how long each part of a program takes, so you fix the slow part instead of guessing. Lesson: Performance and profiling
progressive disclosure: Loading information in stages: a short summary always, details only when a task needs them. Lesson: Hooks and skills
projector: A small layer that maps a vision encoder's vectors into a language model's embedding space, so the model can read them like tokens. Lesson: Multimodal transformers
prompt: The instructions and text you send to a model. Lesson: Prompt fundamentals
prompt caching: Reusing the work a model already did on a repeated prompt start, which makes calls cheaper and faster. Lesson: Cost and latency
prompt chaining: Splitting a job into steps, where each model call's answer feeds the next call. Lesson: Prompt chaining
prompt injection: An attack where text the model reads (a web page, an email) contains instructions that try to hijack it. Lesson: Prompt injection and security
proxy: A server that passes your requests on to another service, often adding the secret key so it never reaches the browser. Lesson: Tokens and the context window
pruning: Cutting back the branches of a decision tree that don't help on validation data, so it overfits less. Lesson: Decision trees
pull request: A request to merge a branch, where the change is reviewed, discussed and checked before it joins the main branch. Lesson: Git for teams
pure function: A function whose result depends only on its inputs, and which changes nothing outside itself. Lesson: Readable code and refactoring
PyTorch: The most widely used Python library for building and training neural networks. Lesson: PyTorch tensors

Q

Q-learning: A simple reinforcement-learning method that learns a table of how good each action is in each situation. Lesson: Alignment and safety
QLoRA: LoRA on top of a model whose frozen weights are stored in 4 bits, so a big model fits on one GPU for fine-tuning. Lesson: LoRA
quantile loss: A lopsided loss that charges more for misses in one direction, such as running out of stock costing more than overstocking. Lesson: Loss functions
quantization: Storing a model's numbers with fewer digits so it uses less memory and runs faster, at a small cost in quality. Lesson: Quantization
query: In attention, what a token is looking for, like a search you type. Lesson: Queries, keys and values
queue: A line of items where the first one added is the first one removed: first in, first out. Lesson: Core data structures
quintile: One of five equal-sized groups you get by sorting values and cutting the line into fifths. Lesson: Feature engineering

R

R²: How much better a model predicts than always guessing the average: 1 is perfect, 0 is no better, and below 0 is worse. Lesson: Linear regression
race condition: A bug where the result depends on the timing of tasks running at once, such as two updates where one gets lost. Lesson: Concurrency and async
RAG: Retrieval-augmented generation: look up relevant documents first, then give them to the model so it answers from them. Lesson: Retrieval-augmented generation
random forest: Many decision trees trained on different samples, voting together. Lesson: Random forests and boosting
random variable: A number whose value depends on chance, like the number of heads in 10 coin flips. Lesson: Distributions
rank: In LoRA, the width of the two thin tables that make up the update. Higher rank can learn more but costs more. Lesson: LoRA
rate limit: A cap on how many requests you may send in a set time. Go over it and the service replies with error 429. Lesson: LLMs in automations
read replica: A copy of a database that serves reads, slightly behind the primary that takes the writes. Lesson: System design fundamentals
readiness check: Health checks a platform makes: liveness asks whether to restart the app; readiness asks whether to send it traffic. Lesson: Containers and deployment
reasoning model: A model that works through a problem step by step before answering, trading time for accuracy. Lesson: Reasoning models and effort
rebase: Replaying your commits on top of another branch, giving a straight history with new commit ids. Lesson: Git for teams
recall: Of the things that should have been flagged, the share the model caught. Lesson: Precision, recall and F1
reciprocal rank fusion: A simple way to merge two ranked lists: each document scores 1 ÷ (60 + its rank) in each list, and the scores are added. Lesson: Making RAG good
recursion: A function solving a problem by calling itself on a smaller version of it, until it reaches a case simple enough to answer directly. Lesson: Recursion, trees and graphs
red-teaming: Deliberately trying to make a model misbehave, before release, to find and fix the problems first. Lesson: Alignment and safety
redact: To hide sensitive parts of text before storing it, such as replacing an email address with [email]. Lesson: Logging and monitoring
refactoring: Improving how code is organized without changing what it does. Lesson: Readable code and refactoring
reference model: A frozen copy of the model before preference training. Training is penalized for drifting too far from it. Lesson: DPO and direct preference methods
regression: Predicting a number, such as next month's sales. Lesson: Features and labels
regression test: A test added after fixing a bug, so the same bug can't quietly come back. Lesson: Debugging systematically
regularization: Gently penalizing a model for being too complicated, to stop it overfitting. Lesson: Regularization
reinforcement learning: Learning by trial and error from a reward signal, rather than from right answers. Lesson: What machine learning is
rejection-sampling fine-tuning: Generating many answers, keeping only the ones that pass a check, and fine-tuning on those. Lesson: Fine-tune an open model
release gate: A test a model must pass before it ships, with the pass mark written down in advance. Lesson: Capstone: a tuned, evaluated assistant
ReLU: The most common activation function: keep positive numbers, turn negative ones into 0. Lesson: Activation functions
replay attack: Recording a genuine message and sending it again later. Signed timestamps defend against it. Lesson: Webhooks and events
request id: A unique id for one request, put in every log line and the response, so its trail can be found later. Lesson: Running APIs in production
reranker: A slower, more careful model that re-orders the top search results by how well each one actually answers the question. Lesson: Making RAG good
resample: Draw a new sample from your data, picking rows at random with replacement, to mimic collecting fresh data. Lesson: Samples and confidence
residual: How far one prediction missed: the true value minus the predicted value. Lesson: Linear regression
residual block: A layer that adds its result to its own input (x + f(x)), so the input always has a clean path through. Lesson: Residual connections
residual connection: A shortcut that adds a layer's input to its output, so information and gradients flow easily through deep networks. Lesson: Residual connections
residual stream: The running total that flows through a transformer: each layer reads it and adds its result back in, instead of replacing it. Lesson: Residual connections
resource template: A pattern like docs://help/{id} that describes a whole family of MCP resources without listing each one. Lesson: Resources and prompts
REST: A style of API built around resources at URLs, acted on with standard HTTP methods like GET and POST. Lesson: API styles
return value: What a function hands back when it finishes. Lesson: Functions
reward hacking: When a model finds ways to score highly with the reward model that don't make its answers better, like padding or flattery. Lesson: RLHF
reward model: A model that scores answers by how much people would prefer them. Lesson: RLHF
RFM: Recency, frequency, monetary: scoring customers on how recently they bought, how often, and how much they spend. A classic marketing feature set. Lesson: Feature engineering
ridge regression: Regularization that adds the squared size of every weight to the loss, so weights stay small but rarely reach exactly zero. Lesson: Regularization
RLAIF: Reinforcement learning from AI feedback: like RLHF, but an AI model applying written principles does the judging instead of people. Lesson: Constitutional AI
RLHF: Reinforcement learning from human feedback: training a model toward answers people prefer, using a learned scorer. Lesson: RLHF
RLVR: Reinforcement learning with verifiable rewards: training on problems whose answers a program can check, such as math or code with tests. Lesson: Training reasoning models
RMSNorm: A simpler LayerNorm that only rescales by the typical size of the numbers, without subtracting the average. Used in many recent LLMs. Lesson: Normalization layers
RNN: A network that reads a sequence one step at a time, carrying a memory forward. Lesson: Recurrent networks
ROC curve: A chart of how a classifier trades catching more true cases against raising more false alarms. Lesson: ROC curves and AUC
RoPE: Rotary position embeddings: marking word order by turning each query and key by an angle that grows with position, so attention scores depend on how far apart two tokens are. Most modern open models use it. Lesson: Positional encodings
router: The small layer in a mixture-of-experts model that scores the experts for each token and sends the token to the top few. Lesson: Mixture of experts
rug pull: A server quietly changing its tools after you approved them. Pinning a fingerprint of each tool catches it. Lesson: MCP security
runbook: Written steps for handling an alert or task: what it means, how to check, what to try first. Lesson: Reliability and incidents

S

salt: A random value mixed into each password before hashing, so equal passwords get different hashes. Lesson: Secure coding
sampling: Picking the next token at random according to the model's probabilities, instead of always taking the top one. Lesson: What an LLM actually does
sandbox: A sealed-off test environment where an agent can take real actions without touching real systems or data. Lesson: Evaluating agents
saturated: When a sigmoid or tanh neuron's input is so large that its output is stuck near the flat end, so its slope (and learning) is almost zero. Lesson: Weight initialization
scalar: A single ordinary number, as opposed to a vector or a matrix. Lesson: Vector arithmetic and length
scaled dot-product attention: The standard attention recipe: compare queries with keys by dot product, divide by √(size), softmax, then mix the values. Lesson: Scaled dot-product attention
scaling laws: The finding that models improve predictably as you add data, size and compute. Lesson: Scaling laws
scikit-learn: A popular Python library of ready-made machine-learning models and tools. Lesson: The scikit-learn workflow
scripted model: A stand-in for a model that returns prepared replies in order, so harness code can be tested quickly and repeatably. Lesson: What an agent harness is
SDK: Software development kit: a ready-made library for calling a service from your code, such as Anthropic's Python SDK. Lesson: Structured output
seed: A starting number for a random generator. The same seed gives the same "random" numbers every run, so results can be repeated. Lesson: Probability basics
self-consistency: Asking a model the same question several times and taking the most common answer. Lesson: Training reasoning models
self-supervised learning: Learning from data that supplies its own answers, such as hiding the next word of a sentence and guessing it. It's how language models are pretrained. Lesson: What machine learning is
semantic versioning: Version numbers written MAJOR.MINOR.PATCH, where each part signals breaking changes, new features or bug fixes. Lesson: Projects, packaging and CI
server-sent events: A simple way for a server to keep a connection open and push a stream of small updates, used to send a reply token by token. Lesson: Streaming responses
SFT: Supervised fine-tuning: training on example prompts with good answers, so a model learns to respond helpfully. Lesson: Supervised fine-tuning
SGD: Gradient descent using a small random batch each step instead of all the data: noisier but much faster. Lesson: Mini-batches and SGD
shape: The size of an array along each direction, like (3, 4) for 3 rows and 4 columns. Lesson: Tensors
sharding: Splitting data across several databases by a key, such as user id, so each holds only part of it. Lesson: System design fundamentals
shared expert: An expert that every token goes through, alongside the ones the router picks. Lesson: Mixture of experts
shingle: A short run of words in a row, such as three, taken from a document. Comparing two documents' shingles shows how much text they share. Lesson: Pretraining at scale
side effect: Anything a tool does besides giving back an answer, such as sending an email or changing a record. Asking again can't undo it. Lesson: The agent loop
sigmoid: An S-shaped function that squeezes any number into the range 0 to 1. Lesson: Logistic regression
silhouette score: How well each point sits in its own cluster rather than the next one: near 1 is clear-cut, near 0 is on a border. Lesson: Clustering
similarity search: Finding the texts whose meaning is closest to a question, by comparing their embeddings. Lesson: Similarity search
single point of failure: A part the whole system needs that has no backup, so its failure takes everything down. Lesson: System design fundamentals
singular value: A number from SVD that says how much the matrix stretches along one direction. Bigger means that direction matters more. Lesson: SVD and PCA
sliding-window attention: Attention where each token only looks at a fixed number of recent tokens, so the cost grows in step with the length instead of with its square. Lesson: Long context
SLO: A reliability target for something users feel, such as 99.9% of requests succeeding fast, measured by an indicator (SLI). Lesson: Reliability and incidents
slope: How steep a line or curve is: how much it goes up for each step across. Lesson: Derivatives
slopsquatting: Publishing a malicious package under a name AI tools tend to invent, hoping someone installs it. Lesson: Working with AI coding tools
soft labels: A teacher's full spread of probabilities over the answers, which carries more information than just the single right answer (a hard label). Lesson: Distillation
softmax: A function that turns a list of scores into probabilities that add up to 1, keeping the biggest score biggest. Lesson: Softmax
softmax regression: Logistic regression for more than two classes: one score per class, turned into probabilities by softmax. Lesson: Multiclass classification
span: One step inside a trace, such as a single model call or search, with its own start and end time. Lesson: Logging and monitoring
specification gaming: When a system scores well by exploiting a loophole in how its goal was written, instead of doing what was meant. Lesson: Alignment and safety
spectrogram: A picture of sound: how much energy each frequency has over time. Lesson: Multimodal transformers
speculative decoding: Speeding up generation by letting a small model draft several tokens and a big model check them at once. Lesson: Speculative decoding
SQL: The language almost every database understands, for storing, finding, combining and summarizing data in tables. Lesson: Databases and SQL
SQL injection: An attack where text pasted into a database query changes the query itself. Placeholders prevent it. Lesson: Databases and SQL
SSRF: Tricking a server into sending requests to places it shouldn't, such as its own internal network. Lesson: Webhooks and events
stack: A pile of items you add to and take from at the top only: last in, first out. Lesson: Core data structures
staging: A private copy of your app where you try changes before real users see them. Lesson: Shipping an LLM app
standard deviation: The typical distance of a value from the average. It is the square root of the variance. Lesson: Mean, variance and spread
standard error: How much an estimate from a sample would wobble if you took a fresh sample. Bigger samples give smaller standard errors. Lesson: Samples and confidence
standardization: Rescaling a column so its average is 0 and its standard deviation is 1, so columns measured in different units become comparable. Lesson: Preparing data
STAR method: A structure for interview stories: situation, task, action and result. Lesson: Interviews and your portfolio
state_dict: PyTorch's dictionary of a model's weights by name. Saving and loading it is how you keep or restore a trained model. Lesson: The training loop
state-space model: An alternative to attention that carries a fixed-size summary forward as it reads, so long texts cost no more per token. Mamba is the best known. Lesson: Long context
stateless: Remembering nothing between requests. A model API is stateless, so your code must send the whole conversation every time. Lesson: Conversations and memory
statistical power: The chance a test spots a real difference when one exists. More data gives more power. Lesson: A/B tests and significance
statistical significance: Evidence that a difference you measured (say, in an A/B test) is probably real, not luck. Lesson: A/B tests and significance
status code: A number in an API's reply saying how it went: 200 means OK, 404 means not found. Lesson: How APIs work
stdio: A program's standard streams: input it reads, output it writes, and a separate stream for errors and logs. Local MCP servers talk over them. Lesson: Transports I: stdio
steering: Changing a model's behavior by adding a direction to its hidden states while it runs, without retraining it. Lesson: Interpretability
stop reason: The field in each Messages API reply that says why the model stopped, such as end_turn, tool_use or max_tokens. The loop branches on it. Lesson: The core loop, built properly
stopwords: Very common words such as "the" and "a" that keyword search ignores because they say little about what a document is about. Lesson: Making RAG good
stratified split: Splitting data so each part keeps the same mix of classes as the whole, for example the same share of churners in train and test. Lesson: Train, validation and test sets
Streamable HTTP: MCP's transport for remote servers: one web address, one POST per message, answered with JSON or a stream of events. Lesson: Transports II: Streamable HTTP
streaming: Showing a model's reply as it is written, word by word, instead of waiting for all of it. Lesson: Streaming responses
stride: How many pixels a CNN filter moves at each step. A stride of 2 skips every other spot and halves the output size. Lesson: Convolutional networks
string: A piece of text in a program, written inside quotes, such as "hello". Lesson: Strings and f-strings
structured output: Asking a model to answer in an exact format, such as JSON with set fields, so code can use it. Lesson: Structured output
student model: In distillation, the smaller model trained to copy a larger teacher model. Lesson: Distillation
subagent: An agent started by another agent to handle one part of a job, reporting its result back. Lesson: Multi-agent systems
sum of squared errors: Square each prediction's miss and add them all up. Squaring makes every miss count as positive and big misses count much more. Lesson: Linear regression
superposition: When a model packs more features than it has neurons by sharing each neuron across several of them, which makes single neurons hard to read. Lesson: Interpretability
supervised learning: Learning from examples that come with the right answers. Lesson: Features and labels
SWE-bench: A benchmark of real GitHub issues in real repositories, graded by the projects' own tests. Lesson: Evaluation harnesses
SwiGLU: A feed-forward layer design used in Llama-style models, where one set of numbers acts as a gate that turns another set up or down. Lesson: The transformer block
sycophancy: A model telling people what they want to hear, such as agreeing with a wrong claim, because agreeable answers got rated higher in training. Lesson: Instruction and preference data
symmetry breaking: Starting weights at different random values so neurons in a layer learn different things instead of staying identical copies. Lesson: Weight initialization
system card: A report published with a model describing its safety testing: what was tried, what went wrong and what was done about it. Lesson: Alignment and safety
system prompt: Standing instructions that set how a model should behave for a whole conversation. Lesson: System prompts and roles

T

t-SNE: A way to draw high-dimensional data in 2D that keeps near neighbors together. Good for pictures, not as model input. Lesson: Dimensionality reduction
tabular data: Data in rows and columns, like a spreadsheet: one row per customer, one column per fact about them. Lesson: Feature engineering
tail latency: How long the slowest requests take, such as the slowest 5% (p95). Users notice these waits even when the average is fine. Lesson: Logging and monitoring
tanh: An S-shaped activation like sigmoid, but its outputs run from -1 to 1 instead of 0 to 1. Lesson: Activation functions
target: The right answer a model should give for an example, such as the true sale amount. The loss measures how far the prediction is from it. Lesson: The chain rule
TCP: The layer that turns the internet's unreliable packets into a reliable, in-order stream of bytes between two programs. Lesson: HTTP from the wire up
teacher forcing: Training on real text by predicting every next token at once from the true earlier tokens, not the model's own guesses. Lesson: Causal masking
teacher model: In distillation, the large model whose answers or probabilities a smaller student model learns to copy. Lesson: Distillation
temperature: A setting for how adventurous a model's word choices are: low is predictable, high is varied. Lesson: Sampling strategies
tensor: A grid of numbers with any number of directions: a vector is 1-D, a matrix is 2-D, a stack of matrices is 3-D. Lesson: Tensors
terminal: A text window where you type commands to your computer instead of clicking. Lesson: The terminal
test harness: Code that runs other code under controlled conditions and checks the results. Lesson: What an agent harness is
test set: Examples kept aside until the very end to give an honest score on unseen data. Lesson: Train, validation and test sets
test-driven development: Writing a failing test first, then the code that makes it pass, then tidying up. Lesson: Testing your code
test-time compute: Extra computation spent while answering, such as thinking longer or trying several answers, rather than during training. Lesson: Training reasoning models
three-way merge: Combining two branches by comparing each with their last shared commit, the merge base. Lesson: Git for teams
threshold: A cutoff value: on one side the answer is yes, on the other no. A classifier often says yes above a probability of 0.5. Lesson: Logistic regression
throughput: How much work a system gets through per second, such as tokens generated across all users. Different from how fast one user gets a reply. Lesson: Serving models
time to first token: How long you wait before the first word of a reply appears. Most of it is the model reading the prompt. Lesson: Streaming responses
TLS: Encryption for a network connection, plus a certificate proving the server's identity. HTTPS is HTTP inside TLS. Lesson: HTTP from the wire up
token: A chunk of text a model reads and writes, often a word or part of a word. Models count and charge by tokens. Lesson: Tokens and the context window
token bucket: A way to rate-limit: each user has a bucket of request tokens that slowly refills. Each request takes one, and an empty bucket means wait. Lesson: Shipping an LLM app
token ID: The number a tokenizer gives each token. Models work with these numbers, not with the text itself. Lesson: Tokens and the context window
token passthrough: Forwarding a token a client sent you to another service. MCP forbids it; get your own token for each service instead. Lesson: Securing remote servers with OAuth
tokenization: Splitting text into tokens, and turning each into a number the model can use. Lesson: Tokens and the context window
tool annotations: Hints a server attaches to a tool, such as read-only or destructive. They're the server's own claims, so only trust them from trusted servers. Lesson: Build a server: tools
tool definition: A tool's name, description and input schema: everything a model knows about the tool. Lesson: A tool registry for agents
tool poisoning: Hiding instructions for the model inside a tool's description, often where the user can't see them. Lesson: MCP security
tool runner: A helper in the Anthropic SDKs that runs the agent loop over tools you define. Lesson: What an agent harness is
tool search: A Claude API tool that lets the model look up rarely used tools when needed, so their definitions don't load on every call. Lesson: A tool registry for agents
tool use: Letting a model ask your code to run a function, such as a search or a calculator, and use the result. Lesson: Tool use
top-k search: Returning the k results that score highest, such as the 3 most similar documents to a question. Lesson: Similarity search
top-p: Sampling only from the most likely tokens, cutting off the unlikely tail. Lesson: Sampling strategies
topological order: An order for the steps of a graph where every step comes after the steps it depends on. Lesson: Computation graphs
topological sort: An order of tasks in which each one comes after everything it depends on. Lesson: Recursion, trees and graphs
trace: A record of every step in one multi-step run, such as an agent's model calls and tool calls, grouped under one id. Lesson: Logging and monitoring
traceback: The error report Python prints. Read it from the last line up: that line says what went wrong. Lesson: Errors and exceptions
training cutoff: The date a model's training data stops. It knows nothing about events after it unless you give it the information. Lesson: Benchmarks and their limits
training loop: The repeated cycle of training: predict, measure the loss, backpropagate, update the weights. Lesson: The training loop
training loss: The model's average error on the examples it learns from. It should fall as training goes on. Lesson: Build a tiny GPT
training set: The examples a model learns from. Lesson: Train, validation and test sets
trajectory: The full record of what an agent did on a task: every message, tool call and result, in order. Lesson: Evaluating agents
transformer: The design behind today's language models: layers of attention plus small neural networks, repeated many times. Lesson: The transformer block
transformer block: One repeating unit of a transformer: attention, then a small neural network, each with a shortcut and normalization. Lesson: The transformer block
transpose: Flipping a matrix so its rows become columns. Lesson: Transpose, identity and inverse
true negative: A no the model got right: it predicted the customer would stay, and they did. Lesson: Precision, recall and F1
true positive: A yes the model got right: it predicted churn, and the customer did churn. Lesson: Precision, recall and F1
true positive rate: The share of real positives the model catches, such as the share of churners it flags. Another name for recall. Lesson: ROC curves and AUC
trunk-based development: A workflow where everyone merges small, short-lived branches into one main branch that is always deployable. Lesson: Git for teams
twelve-factor app: A set of practices for web services, such as reading configuration from environment variables so one image runs everywhere. Lesson: Containers and deployment
type hint: A note in the code saying what type a value should be, like price: float. Tools check hints; Python doesn't enforce them. Lesson: Types and data modeling
typosquatting: Publishing a malicious package under a name one letter off a popular one, hoping people install it by mistake. Lesson: MCP security

U

UMAP: A faster cousin of t-SNE for drawing high-dimensional data, such as embeddings, in 2D. Lesson: Dimensionality reduction
underfitting: When a model is too simple to capture the pattern, so it does badly even on training data. Lesson: Overfitting and underfitting
unified diff: The standard text format for changes: files, then hunks marked with @@, lines starting with + for added and - for removed. Lesson: Code review
unified memory: Memory shared by the CPU and GPU, as on Apple Silicon Macs, so a large model can use most of the computer's memory. Lesson: Running open models locally
unigram: The simplest language model: it predicts each character or word from how common it is overall, ignoring what came before. Lesson: Language modeling
unit test: A small automated check that one piece of code gives the right result for a given input. Lesson: Testing your code
unsupervised learning: Finding patterns, such as groups of similar customers, in data that has no right answers attached. Lesson: What machine learning is
uplift modeling: Predicting who will change their behavior because you contacted them, not just who is likely to churn anyway. Lesson: Capstone: churn prediction
UTF-8: The standard way computers store text as bytes. Plain English letters take one byte each; accents, other scripts and emoji take two to four. Lesson: Files and CSV data
utilization: The share of a chip's peak speed that a training run actually gets. Waiting on memory and on other chips keeps it well below 100%. Lesson: Pretraining at scale

V

validation loss: The model's average error on held-back text it never trains on. If it rises while training loss keeps falling, the model is memorizing. Lesson: Build a tiny GPT
validation set: Held-back examples used to compare and tune models while you work. Lesson: Train, validation and test sets
value: In attention, the information a token passes along when it is matched, like the page you get back. Lesson: Queries, keys and values
value model: In RLHF with PPO, a helper model that predicts the score an answer is likely to get from the part written so far. Lesson: RLHF
vanishing gradients: When the error signal shrinks to almost nothing (or blows up) as it passes back through many layers, so learning stalls. Lesson: Vanishing and exploding gradients
variable: A name that holds a value so your program can use it later, like a labeled box. Lesson: Variables
variance: How spread out values are around their average. Lesson: Mean, variance and spread
vector: An ordered list of numbers, like [3, 1, 4]. It can stand for a point, a direction, or a description of something. Lesson: Vectors
vector database: A database built to store embeddings and quickly find the closest ones to a query. Lesson: Vector databases
virtual environment: A separate folder of installed packages for one project, so projects don't clash. Lesson: Packages and environments
visibility timeout: How long a pulled job stays hidden from other workers. If it isn't acknowledged in time, it's retried. Lesson: Caches, queues and background jobs
vision encoder: The part of a multimodal model that turns an image into a list of vectors, often trained CLIP-style. Lesson: Multimodal transformers
vision transformer: A transformer for images: it cuts the picture into small patches and treats each patch like a word. Lesson: Convolutional networks
vocabulary: The full list of tokens a model knows. Lesson: What an LLM actually does

W

warmup: Starting training with a tiny learning rate and raising it over the first steps, so early, wild updates don't knock the model off course. Lesson: Learning rate
webhook: A web address you give another service, which it calls when something happens, such as a new order. Lesson: LLMs in automations
WebSocket: A connection that stays open so the browser and server can both send messages at any time. Lesson: API styles
weight: An adjustable number inside a model that says how much an input matters. Training sets the weights. Lesson: Linear regression
weight decay: Shrinking every weight a tiny bit on each step, so the model keeps its weights small and is less likely to overfit. Lesson: Regularization
weight initialization: Choosing a network's starting weights. Small random numbers of the right size let signals and gradients flow from the first step. Lesson: Weight initialization
weight tying: Reusing the input embedding table as the output layer, so the model needs fewer numbers to learn. Lesson: The GPT architecture
WSGI: Standard plugs between Python web servers and frameworks, so any server can run any app. ASGI is the async version. Lesson: Build an API server from scratch

X

Xavier initialization: Starting weights sized for tanh or sigmoid layers, using the average of how many inputs and outputs a layer has. Lesson: Weight initialization
XML tags: Labels like <document> and </document> that mark where each part of a prompt starts and ends, so the model can't mix them up. Lesson: Prompt fundamentals
XOR: "Exclusive or": yes when exactly one of two things is true, but not both. One neuron can't learn it; two layers can. Lesson: The artificial neuron

Z

z-score: How many standard deviations a value sits above or below the average. A z-score of 2 is unusually high. Lesson: The normal distribution
zero-shot: Asking a model to do a task with no examples (zero-shot) or with one (one-shot), instead of several (few-shot). Lesson: Examples in prompts
zero-shot classification: Sorting things into labels the model was never trained on, by comparing each item with a text description of each label. Lesson: Multimodal transformers