Vibe coding glossary

The words that show up in agent tools, pull requests, and threads about shipping AI-written code — defined in plain language, one entry each, A to Z.

Agent: A program that drives a language model in a loop: it reads a goal, takes actions with tools — read a file, run a command, edit code — observes the results, and keeps going until the task is done or it gives up. The difference from a chatbot is the loop and the tools; an agent changes things on your machine rather than only answering.
Agentic coding: Writing software by delegating whole tasks to a coding agent rather than typing every line yourself. You describe the outcome, the agent explores the repository, makes the changes, and runs the tests; your job shifts from authoring to steering, reviewing, and shipping. What agentic coding actually means.
Agents file: A markdown file committed to a repository that tells any coding agent working there how the project works — its conventions, commands, architecture, and rules. AGENTS.md is the cross-tool convention; CLAUDE.md is Claude Code's filename for the same thing, and many repos symlink one to the other.
Context engineering: Deciding what a model sees before it answers: which files, docs, examples, and history go into the request, and in what order. It is the discipline that replaced prompt wording as the thing that most affects output quality on real codebases, because a model with the wrong context fails no matter how the instruction is phrased. How Fredrin keeps project context.
Context rot: The quality drop that shows up late in a long session, as a conversation fills with stale plans, dead ends, and superseded file contents. The model starts contradicting itself or re-solving solved problems; the fix is usually a fresh session seeded with a clean summary, not a longer explanation.
Context window: The maximum amount of text — measured in tokens — a model can consider at once, counting the system prompt, the conversation, the files it has read, and the reply it is generating. Everything outside the window is invisible to the model, which is why long sessions get summarized or trimmed.
Eval: A repeatable test that scores a model or an agent on a fixed set of tasks, so a prompt change or a model swap can be judged by a number instead of a hunch. Evals are to AI features what unit tests are to code: unglamorous, and the only thing that catches a silent regression.
Guardrails: Limits placed around an agent so a bad step cannot do real damage — a restricted set of tools, an approval prompt before dangerous commands, a sandbox, or a branch it can never push to. Guardrails are what make it reasonable to let an agent run unattended.
Hallucination: Output that is fluent, confident, and false — an invented API, a library that does not exist, a citation to a page that was never written. Language models generate plausible continuations rather than looking facts up, so hallucination is a property of how they work, not an occasional bug; verification is the only defense.
Human in the loop: A workflow where an agent pauses for a person at the points that matter — approving a plan, reviewing a diff, merging a pull request — instead of running end to end unsupervised. The design question is not whether to have a human in the loop but where to put them, because a checkpoint at every step is as unworkable as none.
LLM: A large language model: a neural network trained on enormous amounts of text to predict what comes next, which turns out to be enough to write code, answer questions, and follow instructions. Every tool in this glossary is a wrapper around one or more of them.
MCP: The Model Context Protocol: an open standard for connecting AI applications to outside tools and data — a database, a design file, an issue tracker — through servers that expose a uniform interface. Introduced by Anthropic in 2024 and now supported broadly, it means an integration written once works in any MCP-aware client.
One-shot: Getting a working result from a single prompt, with no follow-up corrections — “I one-shotted the migration.” Used as a quality brag about a model or a prompt, and as a unit of measure: a task that one-shots is a task worth delegating, and one that takes eight rounds probably needed a plan first.
Parallel agents: Running several coding agents at the same time on separate tasks, each with its own branch and working copy so their edits cannot collide. It moves the bottleneck off any single agent's speed and onto the human's ability to review what comes back. How Fredrin runs a board of agents.
Prompt: The text you give a model to act on — the instruction, plus whatever context is attached to it. In agent tools the visible prompt is only the last part of a much larger request the harness assembles from system instructions, project files, and conversation history.
Prompt engineering: Writing and refining instructions to get reliable output from a model: being specific about the goal, stating the format, giving examples, and saying what not to do. As models improved, the craft shifted from phrasing tricks toward supplying the right context and constraints.
Prompt injection: An attack where instructions hidden in content the model reads — a web page, an issue comment, a dependency's README — are followed as if they came from the user. It is the reason an agent with tool access should never be pointed at untrusted input without limits on what those tools can do.
RAG: Retrieval-augmented generation: searching a corpus for the passages most relevant to a question and putting them in the prompt, so the model answers from real documents instead of memory. It is how a tool answers questions about a codebase or wiki far larger than any context window.
Reasoning model: A model trained to work through a problem step by step before answering, spending extra tokens on internal deliberation. Reasoning models are slower and cost more per answer, and they earn it on planning, debugging, and multi-file changes — not on renaming a variable.
Sandbox: An isolated environment — a container, a VM, a throwaway checkout — where an agent can run commands without touching anything you care about. Sandboxing is what makes autonomous execution survivable: the worst case is a discarded environment rather than a wrecked machine.
Skill: A packaged set of instructions, and sometimes scripts, that an agent loads on demand for a specific kind of task — a deploy procedure, a review checklist, a house style for commits. Skills keep specialised knowledge out of the always-on prompt and load it only when the task calls for it.
Slop: Generated output that is technically fine and substantively worthless: padded prose, a comment restating the line below it, a pull request that touches forty files to change one behaviour. The word is a quality bar as much as an insult — code that ships is code someone read.
Spec-driven development: Writing a precise specification — the outcome, the acceptance criteria, the files in scope — and having the agent implement against it, instead of prompting incrementally. It costs more up front and pays off on anything an agent will run unattended, because the spec is what review is judged against.
Subagent: A separate agent session spawned by a main agent to handle a scoped piece of work — searching the codebase, reviewing a diff — and return only its conclusion. The point is context hygiene: the subagent burns its own window on the search and hands back the answer.
System prompt: The standing instructions a tool sends ahead of your message: who the model is acting as, which tools exist, how to format replies, and what it must never do. You do not usually see it, and it explains most of the behavioural difference between two products calling the same model.
Token: The unit a model reads and writes — roughly a short word or a fragment of one, so a page of English is about 500 to 800 tokens. Tokens are what context windows are measured in and what API pricing is billed on, which is why context is treated as a budget.
Tool call: A model's request to run something outside itself — read a file, query a database, hit an API — emitted as structured arguments that the surrounding program executes before feeding the result back. Tool calls are the mechanism that turns a text generator into an agent.
Vibe coder: Someone who builds software primarily by directing AI rather than typing every line — describing intent, reading what comes back, and steering the next round. The label spans career engineers who now delegate most implementation and people shipping their first product without a traditional programming background.
Vibe coding: Describing what you want in natural language and letting an AI write and run the code, staying with the intent rather than the syntax. Andrej Karpathy coined the phrase in February 2025 for the mode where you accept the diff and try the result; in practice the term now covers the whole spectrum from throwaway prototypes to reviewed, tested work. The tools people vibe code with.
Worktree: A second working copy of a git repository checked out to its own branch in its own directory, sharing one .git history. Worktrees are what let several agents edit the same project at once without stepping on each other's files or fighting over the checked-out branch. Git worktrees, explained.
YOLO mode: Running an agent with its approval prompts turned off, so it edits files and executes commands without asking. It is dramatically faster and occasionally catastrophic, which is why the usual advice is to pair it with a sandbox, a clean branch, or a machine you are willing to lose.

Knowing the words is the easy half. The rest is running the work.

Request invite See the tools