Glossary

153 terms. Each one is matched literally in the transcripts — exact words and exact phrases, nothing fuzzy yet.

ai · 62

agent · 2233 uses: A model given tools and a goal, running in a loop: decide, act, look at the result, decide again. The difference from chat is that it does things rather than describing them.
agentic loop · 46 uses: The cycle an agent runs: pick a tool, call it, read the output, decide what is next. Everything an agent achieves is that loop repeated until it thinks it is finished.also: agent loop, agentic
attention mechanism · 1 use: The part of a transformer that decides which earlier tokens matter for the token being produced now. Its cost grows with the square of the context, which is why long contexts are expensive.also: self-attention
base model · 3 uses: A model that has only been pretrained — it continues text rather than following instructions. Everything you interact with day to day has been tuned on top of one.
benchmark · 19 uses: A standard task set used to compare models. Useful for a rough ranking, weak evidence about your particular codebase.
chain of thought · 1 use: Getting the model to work through intermediate steps before answering. More reliable on multi-step problems, because the steps become context the final answer can lean on.also: chain-of-thought, step by step reasoning
chunking · 1 use: Splitting documents into retrievable pieces before embedding them. Chunk too small and you lose the context; too large and every result is mostly noise.
context engineering: Deciding what goes into the context window and what stays out. As models got better at following instructions, choosing what they see became the harder half of the job.
context window · 120 uses: The total amount of text a model can hold at once — your prompt, the code you attached, and its own reply, all counted together. Go over it and the earliest material has to be dropped.also: context length, context limit
cosine similarity: The usual measure of how close two embeddings are — the angle between them. Close to 1 means near-identical meaning, near 0 means unrelated.
distillation: Training a small model to imitate a large one. Most of the quality, a fraction of the cost and latency.
embedding · 8 uses: A list of numbers representing a piece of text's meaning, arranged so that similar meanings land near each other. The basis of every 'find me related code' feature.also: vector embedding
eval · 3 uses: A repeatable test set for a prompt, model, or agent. Without one, 'the new prompt seems better' is a feeling rather than a fact.also: evaluation suite, evals
few-shot: Putting two or three worked examples in the prompt so the model copies the pattern. Often more effective than describing the pattern in words.also: few-shot prompting, few shot
fine-tuning · 1 use: Further training an existing model on your own examples to shift its behaviour. Powerful, and usually the wrong first move — better prompts and better context are far cheaper.
frontier model · 29 uses: Whichever models are currently the most capable available. A moving target, and the reason a workshop from a year ago describes limits that no longer exist.
grounding · 1 use: Giving the model the actual source material — the real file, the real docs — so its answer is anchored to something checkable rather than to its memory of the internet.
guardrails · 17 uses: The checks around a model rather than inside it — allowlists, approval prompts, sandboxes, review steps. What stops one confident wrong answer from becoming a bad afternoon.
hallucination · 2 uses: The model stating something false with complete confidence — an API that does not exist, a flag that was never added. Not lying; it is predicting plausible text, and false things are often plausible.
human in the loop · 9 uses: Requiring a person to approve a step before it happens. The dial between 'the agent asks about everything' and 'the agent force-pushed to main'.also: human-in-the-loop
inference · 4 uses: Actually running a trained model to get an answer, as opposed to training it. What you pay for per token.
jailbreak: A prompt crafted to get a model past its own restrictions.
knowledge cutoff: The date after which a model saw no training data. Anything released later has to be handed to it in the prompt, or it will confidently describe the old version.
KV cache: The intermediate state a model keeps for tokens it has already read, so generating token 5,001 does not mean re-reading the first 5,000.
latency · 3 uses: How long you wait. For an agent it compounds — thirty tool calls at two seconds each is a minute of watching a spinner.
LLM · 54 uses: A large language model: a network trained on enormous amounts of text to predict what comes next. Everything else in these videos is a way of steering that one capability.also: large language model
LLM as a judge: Using one model to grade another's output against a rubric. Scales far better than human review, and inherits whatever biases the judge has.also: model as judge, LLM judge
lost in the middle · 2 uses: The observation that models attend best to the start and end of a long context and can skim what is buried in the middle. Put the important thing where it will be read.also: context rot, needle in a haystack
MCP · 360 uses: An open protocol for exposing tools and data to AI applications. Write an MCP server once and any client that speaks it — Cursor included — can use your tools.also: Model Context Protocol
mixture of experts: An architecture where only a fraction of the network runs for any given token. Lets a model be very large in total while staying affordable to run.also: MoE
multimodal: A model that takes more than text — images, audio, video. In practice for coding: you can paste a screenshot of the broken UI.
non-determinism · 6 uses: The same prompt not producing the same output twice. Normal for these models, and the reason you review the diff rather than trusting a run that worked yesterday.also: non-deterministic
open weights: A model whose weights you can download and run yourself. Not the same as open source: you get the numbers, rarely the training data or the recipe.also: open-weight model
pretraining: The first and most expensive training phase, where a model learns language and code by predicting the next token across a very large corpus.
prompt · 241 uses: The text you send the model. In an agent it is rarely just your message — it is your message plus rules, plus attached files, plus everything that happened earlier in the run.
prompt caching · 1 use: Reusing the model's processing of a prompt prefix that has not changed, so a long unchanging system prompt is only paid for properly once.
prompt engineering · 4 uses: Wording a request so the model reliably does the right thing — being specific, showing an example, saying what not to do. Less fashionable than it was, still the cheapest fix available.
prompt injection · 5 uses: Hostile instructions hidden in content the model reads — an issue comment, a web page, a dependency's README — that try to redirect it. The reason an agent's reach should be limited.
quantization: Storing a model's numbers at lower precision so it fits in less memory and runs faster, at some cost to quality.
RAG: Retrieval-augmented generation: search a corpus for relevant passages, paste them into the prompt, then answer. It is how a model discusses documents it was never trained on.also: retrieval augmented generation, retrieval-augmented generation
rate limit · 2 uses: A cap on how many requests or tokens you may use per minute. The usual reason a batch job that worked on ten files falls over on a thousand.
reasoning model · 33 uses: A model trained to spend extra computation thinking before it answers. Better on hard problems, slower and more expensive on easy ones.
reranking: A second pass over search results using a slower, more accurate model, to reorder them before the top few go into the prompt.
RLHF: Training a model on human preferences between its own outputs, which is how a raw text predictor turns into something that answers questions helpfully.also: reinforcement learning from human feedback
sandbox · 24 uses: An isolated environment where an agent's commands cannot reach anything you care about. The honest prerequisite for letting it run commands unattended.
semantic search · 23 uses: Searching by meaning rather than by exact characters, so a query about 'login' can find code that only ever says 'authenticate'.
spec-driven development: Writing the specification first and treating it as the durable artifact, with the code as the generated part. The reaction to vibe coding, once the prototypes had to be maintained.also: spec-first
streaming · 2 uses: Sending tokens to you as they are produced rather than waiting for the whole reply. Same total time, much better to sit through.
structured output: Forcing the model's reply into a schema you can parse, instead of hoping the JSON it wrote by hand happens to be valid.
system prompt · 12 uses: The instructions sitting above the conversation that set the model's role and constraints. You usually do not see it; the tool writes it, and your rules get appended to it.
temperature: How much randomness to allow when picking each next token. Near zero the model repeats its most likely answer; higher and it wanders, which helps for prose and hurts for code.
thinking tokens: The tokens a reasoning model spends working something out before it starts its visible reply. You pay for them, and you can usually cap how many it may use.also: reasoning tokens, thinking budget
time to first token: The delay before any output appears. It dominates how fast a tool feels, far more than the total time does.also: TTFT
token · 161 uses: The unit a model actually reads and writes — roughly three quarters of a word, or a few characters of code. Context limits, latency, and price are all counted in tokens, not words.
tokenizer: The component that chops text into tokens before the model sees it. Why models miscount letters in a word: they never saw the letters, only the chunks.
tool use · 3 uses: Giving the model a menu of functions it can call — read a file, run a command, search the web — and letting it choose. The mechanism underneath every coding agent.also: tool calling, function calling
top-p: An alternative randomness dial: only consider the most likely tokens that together make up p of the probability, and ignore the long tail.also: nucleus sampling
transformer: The architecture nearly every modern language model uses. Its key trick is attention: every token can look at every other token when deciding what comes next.
vector database · 6 uses: A store built for one question: given this embedding, which stored embeddings are nearest? That is how a codebase index gets searched.also: vector store, vector db
vibe coding · 1 use: Building by describing what you want and accepting whatever the model produces without reading it closely. Excellent for prototypes, a liability in anything you have to maintain.
weights · 6 uses: The billions of numbers learned during training. They are the model — everything it knows is encoded in them.also: model weights, parameters
zero-shot: Asking for something with no examples at all and relying on the model to already know the shape of the answer.

cursor · 31

.cursorignore · 1 use: Like .gitignore, but for the model. Files listed here are kept out of the index and out of prompts — secrets, vendored code, giant generated files.
.cursorrules: The older single-file format for project instructions to the model. Superseded by rules files under .cursor/rules, but you will still see it in older videos and repos.
@-symbol · 5 uses: The way you hand something specific to the model in a Cursor prompt. Typing @ opens a picker for files, folders, docs, git history, and the web, and what you pick gets pulled into the prompt.also: at symbol, @ symbol, at-mention
@Codebase: An @-symbol that searches your whole indexed project and pulls in the parts that look relevant, instead of you naming the files yourself.
@Docs: An @-symbol that pulls in indexed documentation for a library. It is how you stop a model from guessing at an API that changed after its knowledge cutoff.
@Web: An @-symbol that runs a live web search and feeds the results into the prompt, for anything newer than the model's training data.
Agent mode · 46 uses: The setting where the model runs on its own: it reads files, searches the codebase, edits, runs terminal commands, and reacts to what happens — looping until the task is done or it gets stuck.also: agentic mode
AGENTS.md · 4 uses: A plain markdown file at the root of a repo describing how to work in it — how to build, how to test, what the conventions are. Deliberately tool-neutral, so several AI coding tools read the same file.
Ask mode · 49 uses: Read-only chat. The model can see your code and answer questions about it, but cannot edit files or run commands. Useful when you want to understand something rather than change it.
auto-run · 2 uses: Letting the agent execute terminal commands and apply edits without stopping to ask each time. Faster, and exactly as risky as it sounds — which is why there is an allowlist.also: auto-apply, auto run mode
Background Agent · 26 uses: An agent that runs in its own remote environment rather than in your editor, so you can hand off a long task and keep working. It reports back with a branch or a pull request.
Bugbot · 83 uses: Cursor's automated code reviewer. It reads pull requests and leaves comments on the bugs it finds, in the same place a human reviewer would.
checkpoint · 1 use: A snapshot Cursor takes of your files before an agent run, so you can roll the whole thing back in one click when the agent goes somewhere you did not want.
Cmd+K · 3 uses: The inline edit shortcut. Select code, describe the change in plain language, and the model rewrites that selection in place instead of talking about it in a side panel.also: Ctrl+K, Command K, Cmd K
codebase indexing · 1 use: Cursor reading your repository once, splitting it into chunks, and storing embeddings of them so it can later find relevant code by meaning rather than by exact filename.also: indexing the codebase, codebase index
Composer · 163 uses: Cursor's family of in-house coding models, trained for agentic work rather than conversation. Released as Composer 1, then 1.5, 2, and 2.5.also: Composer 1, Composer 1.5, Composer 2.5
Composer 2 · 46 uses: The second generation of Cursor's coding model, built for a world where agents write most of the code rather than assisting edit by edit. Cursor pitches it as competitive with frontier models on coding while being markedly faster and cheaper.
Cursor · 782 uses: The code editor these workshops are about — a fork of VS Code with an AI model wired into the editing surface itself rather than bolted on as a chat window.
Cursor CLI · 25 uses: Cursor's agent as a terminal program rather than an editor panel, so it can run in scripts, in CI, and over SSH where there is no GUI.
Cursor Rules · 21 uses: Standing instructions the model gets on every request in this project — conventions, stack choices, things it keeps getting wrong. Stored as files under .cursor/rules so they live in the repo and get reviewed like code.also: rules file, project rules, user rules
custom mode: A mode you define yourself: which model, which tools it is allowed to use, and what instructions it always gets. Lets you make a narrow, predictable agent for one job.
inline edit · 4 uses: Editing code directly in the buffer through a prompt, with the result shown as a diff you accept or reject — as opposed to copying suggestions out of a chat panel.
Max Mode · 14 uses: Running a model with its largest available context window and fewer internal shortcuts. Slower and more expensive per request, worth it when the task genuinely needs the model to hold a lot of code at once.
MDC · 4 uses: The file format for Cursor rules: markdown with a small metadata header on top saying when the rule should apply — always, for certain file globs, or only when the model asks for it.also: .mdc
Plan mode · 132 uses: A first pass where the model writes out what it intends to do and you approve the plan before any file is touched. Cheaper to correct a plan than to unpick fifteen wrong edits.also: planning mode
Privacy Mode · 16 uses: The Cursor setting where your code is not retained or trained on. Worth checking before you point any of this at a work repository.
shadow workspace: A hidden copy of your project where the model can make edits and see what the linter and type checker say, before anything shows up in the editor you are looking at.
slash command · 17 uses: A saved prompt you invoke by name with a leading slash, so a workflow you repeat becomes one keystroke instead of a paragraph you retype.
sub-agent · 47 uses: An agent spawned by another agent to handle a piece of work in its own fresh context, reporting back just the answer. Keeps a long task from filling the main context window with search results.also: subagent, child agent
Tab · 1 use: Cursor's autocomplete. It predicts your next edit rather than just the next few characters, so one Tab press can change a line you already wrote or jump you to the next place that needs the same change.also: Cursor Tab
YOLO mode: The informal name for auto-run with the guardrails turned down: the agent runs whatever it decides it needs to. Fine in a sandbox or a throwaway branch, alarming anywhere else.

dev · 60

API · 78 uses: The defined surface one piece of software offers another: the functions, the endpoints, the shapes of the data.
AST: Code represented as a tree of its structure rather than as text. Tools that edit code reliably work on this, not on find-and-replace.also: abstract syntax tree, syntax tree
boilerplate · 2 uses: Code you have to write that carries no decisions — imports, wiring, the same three files every time. The clearest early win for generation.
branch · 47 uses: A parallel line of commits, so you can change things without disturbing the version everyone else is working from.
breakpoint · 2 uses: A marked line where the debugger stops execution so you can look around.
bundler: A tool that combines your source files and dependencies into what actually ships to a browser.
cache · 3 uses: A saved copy of an expensive result, kept so the next request is cheap. Also the reason your change did not appear.
CI · 35 uses: Automation that builds and tests every change as it is pushed, so breakage is caught in minutes rather than at release.also: continuous integration
CLI · 110 uses: A program you drive from the terminal with arguments and flags. Easy for an agent to use, because the interface is text in and text out.also: command-line tool
codemod: A script that edits code mechanically across a whole repo, usually by rewriting the syntax tree. The precise alternative to asking a model to change 400 files.
commit · 44 uses: One recorded change to a repository, with a message saying why. The unit you can go back to when something breaks.
container · 11 uses: An application packaged with everything it needs to run, so it behaves the same on your machine and on a server.also: Docker container
debugger · 3 uses: A tool that pauses a running program so you can inspect its actual state, rather than guessing from print statements.
dependency · 21 uses: A library your project needs in order to run. Each one is code you did not write and are nonetheless responsible for.
diff · 13 uses: The lines an edit added and removed, shown side by side. What you actually review when an agent proposes a change.
end-to-end test: A test that drives the whole system the way a user would. Slowest, and the only kind that proves the thing actually works.also: e2e test
endpoint · 6 uses: One addressable URL in a web API, together with the methods it accepts.
environment variable · 6 uses: A named value supplied to a program from outside it — API keys, database URLs. Kept out of the repo, which is why an agent that cannot see them cannot run your app.also: env var, .env
feature flag · 10 uses: A switch that turns a feature on for some users without a deploy, so releasing and shipping stop being the same event.
fixture: Pre-built test data or setup that several tests share.
flaky test · 1 use: A test that passes and fails on the same code. Corrosive, because it teaches everyone to ignore red builds.
formatter: A tool that rewrites code into a canonical layout so nobody argues about spacing and diffs stay small.
framework · 22 uses: A library with opinions about how your whole application is arranged. You fit into it rather than calling it.
hot reload: Applying a code change to a running app without restarting it, so the browser updates as you type.also: hot module replacement
hunk: One contiguous block of a diff. Tools let you accept or reject them individually, which is how you take half of what a model suggested.
IDE · 119 uses: An editor that also knows about your code — navigation, refactoring, debugging, errors as you type.also: integrated development environment
idempotent: Safe to run more than once — the second run changes nothing further. A property worth demanding from anything an agent might retry.
integration test · 16 uses: A test of several pieces working together, including the seams where they usually break.
linter · 6 uses: A tool that reads code without running it and flags likely mistakes and style violations. A fast, free second opinion on anything a model just wrote.also: lint
lockfile: The file recording the exact dependency versions installed, so everyone else gets the same ones.
LSP: The protocol behind go-to-definition, autocomplete, and inline errors. One language server can serve every editor that speaks it.also: language server, language server protocol
merge conflict · 3 uses: Two branches changing the same lines, so the tool refuses to guess and hands the decision back to you.
migration · 69 uses: A recorded, ordered change to a database's structure, so every environment can be brought to the same shape.
mock · 9 uses: A stand-in for a real dependency during a test, so you can check your code without calling a live service.
monorepo: One repository holding many projects. Good for shared changes, hard on any tool that has to index the whole thing.
observability · 9 uses: Being able to work out what a running system is doing from the logs, metrics, and traces it emits — without adding new print statements first.
pull request · 172 uses: A proposal to merge one branch into another, with room for review and automated checks before it lands.also: PR, merge request
race condition · 1 use: A bug that depends on which of two concurrent things finishes first. Reproduces one run in twenty, which is why it survives review.
rebase: Replaying your commits on top of a newer base so the history reads as one straight line instead of a merge knot.
refactor · 28 uses: Changing how code is structured without changing what it does. The thing agents are genuinely good at, provided the tests are there to prove nothing moved.also: refactoring
regression · 5 uses: Something that used to work and now does not. The specific risk in every large automated refactor.
repo · 290 uses: A project's folder of code together with its full history of changes.also: repository
REST · 3 uses: The common convention for HTTP APIs: resources at URLs, verbs for what you do to them.also: REST API
rollback: Putting the previous version back after a bad release.
runtime · 13 uses: The thing that executes your code — Node, the browser, a Python interpreter — and the environment it provides.
scaffold · 6 uses: Generating the skeleton of a new component or service so you start from a working shape rather than an empty file.also: scaffolding
schema · 13 uses: The declared shape of data — which fields exist, what types they hold, what is required.
SDK · 67 uses: A library wrapping an API in your own language so you make function calls rather than assembling HTTP requests.also: client library
semantic versioning: The major.minor.patch convention, where the first number changing is a promise that something you relied on has broken.also: semver
shell · 121 uses: The text interface where you run commands. What an agent is reaching for when it asks to run something.also: terminal, command line
stack trace · 3 uses: The list of function calls that led to an error. Pasting the whole thing to a model is worth more than describing the error in words.also: traceback
staging · 1 use: An environment that mirrors production closely enough to catch what local development cannot.
technical debt · 17 uses: Shortcuts that made yesterday faster and make every subsequent day slower. Generated code accrues it quickly when nobody reads it.also: tech debt
telemetry · 2 uses: The measurements a program reports about itself while running.
test coverage · 18 uses: How much of your code the tests actually execute. A useful floor and a terrible goal.
transpile: Translating source into another language or an older version of the same one — TypeScript to JavaScript, modern syntax to what older browsers accept.also: transpiler, compile step
tree-sitter: A fast incremental parser used by editors to build a syntax tree as you type, even when the file is momentarily invalid.also: treesitter
type checker: A tool that verifies the shapes of your data line up before the code runs. Catches a whole class of confident-looking generated code that could never have worked.also: static analysis
unit test · 21 uses: A test of one small piece in isolation. Fast, precise about what broke.
webhook · 38 uses: A URL you register so another service can call you when something happens, instead of you asking it repeatedly.