Glossary

Plain-language definitions of the terms used across this knowledge base, for a mixed audience of engineers, PMs, and non-technical readers. Where a term connects to one of AI's three core limitations, that's flagged so the why stays in view:

• L1 — Limited memory / context: the model can only "see" a finite amount at once.
• L2 — No real thinking or learning between sessions: it doesn't persist what it learned, and "reasoning" is generated text, not understanding.
• L3 — Outdated knowledge: its training has a cutoff date and it doesn't know your private data.

Terms are alphabetized. Cross-links point to the page where a concept is explained in depth.

---

A

Adaptive thinking The mechanism on flagship Claude models where thinking is always on and the model scales how much it reasons to the difficulty of the task, controlled by an effort parameter rather than a fixed thinking-token budget. Still L2: the extra steps are generated text, not real understanding. See Effort and Reasoning model.

Agent / agentic loop A system where the model doesn't just answer once but runs in a loop: it decides on an action, takes it (often by calling a tool), observes the result, and repeats until the task is done. Claude Code is an agent. The "loop" is what lets it read a file, run a test, see the failure, and fix it without you driving each step. See Patterns for LLM Apps.

Agent teams A Claude Code capability where one operator orchestrates several sub-agents working together on a task (the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS setting). Distinct from a team of human developers, and a step beyond a single Subagent. See Working with AI as a team.

AGENTS.md See CLAUDE.md / AGENTS.md.

API (model API) The programmatic way to send a request to a model and get a response back inside your own software, rather than typing into a chat window. "Using AI via the API" means the model is a runtime component of your product — answering on your users' data, your infrastructure, and your budget — which is a different discipline from using it as a coding assistant. See Patterns for LLM Apps.

C

Chain-of-thought (CoT) Prompting the model to "think step by step" and write out its reasoning before the final answer. It often improves accuracy on multi-step problems. Important caveat (L2): this is generated text that looks like reasoning — a useful technique, not evidence of real thinking.

Chunking / indexing Splitting a large body of text or code into smaller pieces ("chunks") and building an index over them so the relevant pieces can be found later. The craft is cutting on natural boundaries (functions, sections) and keeping each chunk self-contained. Works around L1 — you can't fit everything in the context window. See Chunking & Retrieval.

CLAUDE.md / AGENTS.md A markdown file in your project that the coding agent reads at the start of every session — your coding standards, architecture decisions, preferred libraries, and review rules. CLAUDE.md is Claude Code's convention; AGENTS.md is a cross-tool equivalent used by other agents. Directly addresses L2: the model forgets between sessions, so you give it durable, re-readable rules. See Memory and Project Rules.

Compaction / auto-compact When a session's context fills up, the tool automatically summarizes and compresses earlier turns to free space ("auto-compact"). It keeps a long session running, but a summary loses detail — so it's often better to reset deliberately than to lean on it. A response to L1. See Knowing When to Reset.

Context degradation See "Lost in the middle".

Context engineering The discipline of deciding what goes into the model's context window, and when — which files, instructions, examples, and tool outputs to include, and which to leave out. It's the highest-leverage skill in working with AI. The direct response to L1. See Context Management.

Context window The maximum amount of text (measured in tokens) a model can consider at once — its working memory for a single request. Everything competes for this finite space: your instructions, the files it has read, and the conversation so far. This is L1 itself. See Context Management.

E

Effort A request parameter on flagship Claude models that sets how much thinking and compute the model spends before answering — higher for hard problems, lower for speed and cost. It replaces the manual thinking-token budget used by older or smaller reasoning models. See Adaptive thinking and Choosing Models.

Embeddings / vector store An embedding turns a piece of text into a list of numbers (a vector) that captures its meaning, so that texts with similar meaning sit close together. A vector store (or vector database) holds these vectors and finds the nearest ones to a query — the engine behind semantic search and many RAG systems. Works around L1 and L3. See Chunking & Retrieval.

Eval (evaluation) A repeatable test that measures how well a model or prompt performs on a task, using a fixed set of inputs and expected outcomes. Evals turn "it feels better" into "it scored 8% higher", and are the only honest way to choose models or compare prompts. See Choosing Models.

Extended thinking Letting a reasoning model spend more compute "thinking" before it answers, trading latency and cost for better performance on hard problems. On flagship Claude models this is adaptive (always on) and controlled by an effort parameter; some smaller or older models still use a manual thinking-token budget. See Reasoning model and Adaptive thinking.

F

Few-shot Including a handful of worked examples in the prompt to show the model the pattern you want, rather than only describing it ("zero-shot"). A few good examples often beat a paragraph of instructions. Note (L1): examples consume context, so use the fewest that do the job. See Prompting Best Practices.

Fine-tuning Further training of a base model on your own examples so it specializes in a task or style. It's powerful but heavyweight — it costs time and money, can go stale, and is usually unnecessary; good prompting and retrieval solve most problems first. Distinct from prompting, which changes nothing about the model. See Choosing Models.

Fork Branching a conversation or session to explore a variation without contaminating the original line of work. Lets you try an alternative approach and throw it away cleanly. A context-hygiene tool (L1). See Parallel Sessions and Worktrees.

Function calling See Tool use / function calling.

G

Git worktree A native Git feature that gives you multiple working copies of the same repository in separate folders, sharing one history. It lets several agents work in genuinely isolated workspaces at once, so parallel tasks don't step on each other. See Parallel Sessions and Worktrees.

H

Hallucination When a model states something false with full confidence — an invented API, a wrong fact, a citation that doesn't exist. It happens because the model generates plausible-sounding text, not verified truth. Tied to L3 (and L2): gaps in knowledge get filled with confident guesses. The defenses are retrieval, verification, and human review. See Verification and Review.

Hook A shell command a coding agent runs automatically at defined points in its lifecycle — before a tool runs, after a file is edited, when a session starts — to enforce a rule or automate a step (formatting, tests, guards). See Skills, Plugins, MCP & Subagents and MCP and config.

I

Inference A single run of a trained model: you send an input, it computes an output. "At inference time" means "when the model is actually answering," as opposed to when it was trained — each inference call is what you pay for and wait on. Distinct from training and fine-tuning, which change the model itself.

L

LLM (large language model) The kind of AI behind Claude, GPT, and Gemini: a model trained on vast amounts of text to predict and generate language, which turns out to also reason, write code, and use tools. "An LLM app" is a product that uses one as a runtime component. The three limitations this knowledge base is built around — limited memory, no compounding learning, outdated knowledge — are properties of today's LLMs. See AI limitations.

"Lost in the middle" / context degradation The well-documented effect where a model pays most attention to the beginning and end of a long context and is most likely to miss information buried in the middle. As a context fills with tool output, dead ends, and tangents, overall quality quietly drops. A core consequence of L1 — and the reason more context is not better context. See Context Management.

LSP (Language Server Protocol) An open, editor-world standard that lets a background "language server" (tsc, Pyright, rust-analyzer) answer precise questions about your source code — type errors, go-to-definition, unused symbols. Wiring one into a coding agent gives it real diagnostics instead of correctness inferred from reading text, cutting hallucinated APIs. Like MCP it connects the agent to a separate process, but LSP is fixed and code-only, where MCP is open and do-anything. See Skills, Plugins, MCP & Subagents.

M

MCP (Model Context Protocol) An open standard for connecting AI tools to external data sources and tools — live documentation, a ticketing system, a browser, an internal API. An "MCP server" exposes tools and resources the model can call. Helps with L3 by giving the model fresh, real data instead of stale training knowledge. See Skills, Plugins, MCP & Subagents.

Persistent memory Any mechanism that carries information across sessions, since the model itself doesn't: project files like CLAUDE.md, saved markdown notes, or an agent's auto-saved learnings (build commands, debugging insights). The standing workaround for L2. See Memory and Project Rules.

N

Non-determinism The property that the same prompt can produce different outputs on different runs. It stems partly from sampling (see temperature) and partly from how models run at scale. It's why you can't assume one good result will repeat, and why evals use multiple runs rather than one. See Choosing Models.

P

Permission modes / allowlist The controls that decide what a coding agent may do without asking — from prompting on every action, to an allowlist of pre-approved commands, to fully autonomous. The allowlist names the specific tools or commands that can run unattended; everything else still stops for a human. See Security, Permissions & Sandboxing and MCP and config.

Plan mode A mode (in Claude Code and similar tools) where the agent investigates and proposes a plan without making changes, so you can approve or correct the approach before any code is written. Catches wrong assumptions cheaply. See Plan and Design First.

Plugin A shareable, versioned bundle for a coding agent that can contain skills, subagents, hooks, MCP servers, and language servers. It's a container, not a capability of its own — the delivery mechanism that ships those things to a whole team at once. Installed once, then its contents activate by their own rules. See Skills, Plugins, MCP & Subagents.

Prompt / system prompt A prompt is the instruction you give the model. The system prompt is a special top-level instruction that sets the model's role, rules, and standing behavior for the whole conversation, separate from the user's individual messages. Think of the system prompt as the job description and the prompt as the task. See Prompting Best Practices.

Prompt caching A feature that lets you reuse a large, unchanging chunk of context (a long system prompt, retrieved documents) across many requests without re-paying its full latency and cost each time. A practical mitigation for the cost of L1 when you must include a lot of context. See Chunking & Retrieval.

Prompt injection An attack where malicious instructions hidden in content the model reads — a web page, a file, a tool result — hijack it into doing something you didn't intend. OWASP ranks it the top LLM risk (LLM01). The defenses are least privilege, sandboxing, and treating all external content as untrusted. See Security, Permissions & Sandboxing.

R

RAG (retrieval-augmented generation) The standard pattern for letting a model use data it wasn't trained on: Retrieve the relevant pieces, Augment the prompt with them, then Generate the answer. The standard answer to "the model doesn't know my data" (L3) and a way to fit large corpora through a small window (L1). See Chunking & Retrieval.

Reasoning model A model trained to spend extra compute "thinking" (generating internal reasoning steps) before answering, which improves performance on hard, multi-step problems at the cost of more latency and tokens. On flagship Claude models this thinking is adaptive (always on) and tuned by an effort parameter rather than a manual budget. Useful for genuinely complex tasks; overkill for simple ones. Still L2: the extra steps are generated text, not real understanding. See Choosing Models.

S

Sandbox / sandboxing An isolated environment — a container, VM, or restricted workspace — where an agent can run code and commands without being able to touch the rest of your system, network, or secrets. It contains the blast radius of a mistake or a prompt injection, which is why risky or autonomous work belongs in one. See Security, Permissions & Sandboxing.

Schema-guided reasoning / structured output Constraining the model to return data in a defined shape (e.g. JSON matching a schema) so your code can reliably consume it. Beyond convenience, giving the model a structure to fill in often improves the quality of its reasoning. Always validate the output and handle the malformed case. See Patterns for LLM Apps.

Skill A reusable playbook (instructions plus optional scripts) that teaches a coding agent how to do a recurring task. It's model-invoked — the agent triggers it automatically when your request matches the skill's description — or you can call it explicitly as a slash command. See Skills, Plugins, MCP & Subagents.

Slash command A command you invoke by typing /name — built-in (/init, /clear), or contributed by skills, plugins, and MCP servers. User-invoked, as opposed to a skill that fires automatically. See Skills, Plugins, MCP & Subagents.

Subagent A separate agent with its own fresh context and tools that the main agent dispatches for a focused task, often in parallel, and which reports back a result. A context-management tool (L1): the messy work happens in the subagent's context, keeping the main one clean. See Skills, Plugins, MCP & Subagents.

Sycophancy The tendency of a model to agree with you, flatter your idea, or cave to pushback rather than hold a correct position — telling you what you want to hear. A known failure mode, and a signal to reset when the agent stops offering real resistance. See Knowing When to Reset.

System prompt See Prompt / system prompt.

T

Temperature A setting that controls randomness in the model's output. Low temperature makes it focused and repeatable (good for code, extraction, classification); high temperature makes it more varied and creative (good for brainstorming, copy). A lever on non-determinism. See Choosing Models.

Token The unit models read and write — roughly a word-piece (a short word is one token; a long word is several). Context windows, pricing, and speed are all measured in tokens. The unit in which L1 is counted: the context window is a token budget. See Context Management.

Tool use / function calling The mechanism that lets a model call external functions you (or the platform) define — search the web, run code, query a database — instead of only producing text. The model decides when to call a tool based on the request and the tool's description, then uses the result. The foundation of agents. Helps with L3 by reaching live data. See Patterns for LLM Apps.

Training cutoff The date after which a model has no built-in knowledge, because its training data stops there. Ask about anything newer and it will guess or hallucinate. This is L3 itself. The fixes are tool use, RAG, and up-to-date docs via MCP. See AI limitations.

V

Vector store See Embeddings / vector store.