Dictionary on Vibe Coding

Agent Skill

Mon, 01 Jan 0001 00:00:00 +0000

An agent skill is a self-contained folder of instructions — plus, optionally, helper scripts or reference documents — that teaches an agent a specific procedure it wouldn’t reliably do well from a generic system prompt alone, such as formatting a spreadsheet correctly or scaffolding an MCP server.

Agentic Loop

Mon, 01 Jan 0001 00:00:00 +0000

An agentic loop is the repeating cycle an AI coding agent uses to complete a task on its own: it plans a next step, takes an action (reads a file, edits code, runs a command), observes the result, and decides what to do next — looping until the task is done or it needs your input.

Chain of Thought

Mon, 01 Jan 0001 00:00:00 +0000

Chain of thought refers to breaking a problem into intermediate reasoning steps instead of answering in one leap — either because the model does this naturally or because it’s explicitly prompted to (“think step by step”). It’s the underlying technique that extended thinking builds on: the model is more likely to reach a correct answer on a multi-step problem when it works through the intermediate logic rather than pattern-matching straight to an output.

Context Engineering

Mon, 01 Jan 0001 00:00:00 +0000

Context engineering is prompt engineering’s broader successor. Instead of focusing only on how you phrase an instruction, it’s about managing the whole working set the agent sees: which files get loaded, which past turns are kept or summarized, which tool outputs are retained, and what gets trimmed. As agents run longer, multi-step tasks, this curation matters more than any single sentence of instruction.

Context Rot

Mon, 01 Jan 0001 00:00:00 +0000

Models don’t treat every token in their context window equally — attention tends to be strongest at the start and end of a long context and weaker in the middle. As a session accumulates file reads, search results, and tool output, the model has to search through more noise to find what’s relevant, and its reliability on that information drops, even without hitting the hard context-window limit.

Context Window

Mon, 01 Jan 0001 00:00:00 +0000

The context window is the maximum amount of text a model can hold in memory at one time, measured in tokens. Everything the model reasons about — your prompt, the conversation history, any files it has read — has to fit inside this window.

Diff Review

Mon, 01 Jan 0001 00:00:00 +0000

Diff review is reading the precise set of changes an agent proposes — added lines, removed lines, touched files — before they’re applied or committed. It’s the same discipline as reviewing a human teammate’s pull request, applied to AI output.

Embedding

Mon, 01 Jan 0001 00:00:00 +0000

An embedding is a list of numbers (a vector) that a model produces for a piece of text, positioned so that texts with similar meaning end up with similar vectors — even if they don’t share any of the same words. Comparing two embeddings mathematically gives a rough measure of how semantically related two pieces of text are.

Extended Thinking

Mon, 01 Jan 0001 00:00:00 +0000

Extended thinking is a setting, available in several current coding-agent tools, that lets a model work through a harder problem in a visible intermediate stage before committing to a final response or action. Rather than answering immediately, it reasons out loud — weighing tradeoffs, checking assumptions — and that reasoning is often surfaced to the user as a collapsible “thinking” block separate from the final answer.

Git Worktree

Mon, 01 Jan 0001 00:00:00 +0000

Normally, a Git repository has one working directory tied to whichever branch you’ve checked out — switching branches changes the files on disk. A worktree lets you attach a second (or third) working directory to the same repository, each checked out to a different branch, all sharing the same underlying Git history.

Hallucination

Mon, 01 Jan 0001 00:00:00 +0000

A hallucination is output that’s stated with full confidence but isn’t grounded in reality — an AI referencing a function that was never defined, importing a package that was never installed, or describing behavior a piece of code doesn’t actually have.

Headless Mode

Mon, 01 Jan 0001 00:00:00 +0000

Most coding agents default to an interactive mode: you type a request, watch it work, and respond to prompts. Headless mode strips that interface away — you pass in a task via a command-line flag or script, the agent runs to completion (or a defined stopping point) unattended, and the result comes back as output you can capture programmatically.

MCP (Model Context Protocol)

Mon, 01 Jan 0001 00:00:00 +0000

MCP (Model Context Protocol) is an open standard for connecting AI agents to external systems — a database, a project management tool, an internal API — through a single, consistent interface instead of a custom integration for every tool.

Plan Mode

Mon, 01 Jan 0001 00:00:00 +0000

In plan mode, an agent is restricted to read-only actions — it can read files, search the codebase, and ask clarifying questions, but it can’t make edits or run state-changing commands. What it produces instead is a written plan: what it understands the task to be, which files it intends to touch, and the approach it plans to take. You can then approve it, correct it, or send it back before any code changes.

Prompt Caching

Mon, 01 Jan 0001 00:00:00 +0000

When a model processes a prompt, it does real computational work to “read” every token, even ones it’s seen before. Prompt caching lets a provider skip that repeated work for content that hasn’t changed since the last call — a long system prompt, a set of tool definitions, a large file — storing an intermediate representation and reusing it, rather than recomputing from scratch each time.

Prompt Engineering

Mon, 01 Jan 0001 00:00:00 +0000

Prompt engineering is the practice of writing instructions — wording, structure, examples, constraints — so a model produces the output you actually intend, reliably, rather than something that merely looks plausible.

Prompt Injection

Mon, 01 Jan 0001 00:00:00 +0000

A prompt injection attack works by planting text designed to look like an instruction somewhere the agent will read it — a code comment, a README, a scraped webpage, an API response. If the agent doesn’t distinguish content it’s reading from commands it should follow, it can end up doing something the attacker wanted instead of what the user asked for.

Repo Map

Mon, 01 Jan 0001 00:00:00 +0000

A repo map is a condensed representation of a codebase — file names, function and class signatures, import relationships — that gives an agent a sense of the overall structure without loading every file’s full contents into its context window.

Retrieval-Augmented Generation (RAG)

Mon, 01 Jan 0001 00:00:00 +0000

RAG combines a search step with a generation step. Before the model writes its answer, a separate process retrieves the most relevant chunks of text from an external source — a set of docs, a codebase, a knowledge base — and inserts them into the context window. The model then answers using that retrieved material rather than guessing from memory alone.

Sandboxing

Mon, 01 Jan 0001 00:00:00 +0000

A sandbox limits what an agent’s actions can actually affect: it might run in a disposable container with no network access, a copy of your repo instead of the original, or an OS-level permission boundary that blocks writes outside a specific folder. If something goes wrong — a bad command, a misunderstood instruction, a prompt injection — the damage is contained to the sandbox instead of your real machine or production systems.

Subagent

Mon, 01 Jan 0001 00:00:00 +0000

Instead of one agent doing everything in a single, ever-growing context, a main agent can delegate a self-contained piece of work — researching how a library’s API works, searching a large codebase for a pattern — to a subagent. That subagent runs its own mini agentic loop in an isolated context, then returns a summary, keeping the noisy intermediate steps (file reads, failed searches) out of the main conversation.

System Prompt

Mon, 01 Jan 0001 00:00:00 +0000

A system prompt is a set of instructions given to a model before any conversation begins, establishing how it should behave, what tools it can use, and what rules it must follow — as distinct from the individual messages a user sends afterward.

Temperature

Mon, 01 Jan 0001 00:00:00 +0000

Temperature is a parameter that controls how much randomness a model applies when choosing its next output token. Low temperature makes output more deterministic and focused; high temperature makes it more varied and, at the extreme, less coherent.

Token

Mon, 01 Jan 0001 00:00:00 +0000

A token is the basic unit of text a language model processes — often a whole short word, but sometimes a fragment of a longer word or a piece of punctuation. Models don’t read raw characters; they read sequences of tokens.

Tool Use (Function Calling)

Mon, 01 Jan 0001 00:00:00 +0000

On its own, a language model just predicts text. Tool use (also called function calling) is the layer that lets it take real actions: the model is given a list of available functions with descriptions of what they do, and when it decides one is needed, it outputs a structured request to call it — the surrounding system executes the function and feeds the result back in.

Vector Database

Mon, 01 Jan 0001 00:00:00 +0000

A vector database indexes embeddings so that, given a new query, it can quickly return the most similar entries out of potentially millions — a search that would be far too slow to do by brute-force comparison. It’s the storage-and-retrieval layer that most semantic search and RAG systems sit on top of.

Vibecoding

Mon, 01 Jan 0001 00:00:00 +0000

Vibecoding is the practice of building software primarily through natural-language direction of an AI agent — describing intent, letting the agent write and edit code, and steering the result — while still applying the judgment of an experienced engineer: reviewing diffs, verifying behavior, and making architectural calls.

YOLO Mode

Mon, 01 Jan 0001 00:00:00 +0000

YOLO mode (also called auto-approve or auto-accept in different tools) lets an agent execute its planned actions — file edits, shell commands, even commits — without pausing to ask for confirmation on each step.