Glossary — Learn Claude Code

A

agent: A model running in a loop with tools: it reads your prompt, asks for a tool to be run, reads the result, and goes round again until it has an answer. See The Agent SDK.
AGENTS.md: A convention used by other coding harnesses for project-level instructions. Claude Code reads CLAUDE.md, not AGENTS.md; bridge the two with an @AGENTS.md import inside CLAUDE.md, or a symlink on platforms that support one. See Rules.
allowed-tools: A skill or subagent frontmatter field that restricts which tools the invocation may use. On a skill, the grant clears at the end of your next message rather than persisting for the session, and it is not gated by workspace trust: a project skill can grant itself broad access even in an untrusted folder. See Skills.
API: Application programming interface. The set of requests one program can send another over the network, and the replies it gets back. See The Agent SDK.
API key: A long secret string that identifies your account to a service. Anything holding it can spend your money, so it lives in an environment variable rather than in a file. See The Agent SDK.
argument: A value handed to a function when it is called. See The Agent SDK.
auto memory: A background feature, on by default, that writes what Claude Code learns about a project or user into ~/.claude/projects/<project>/memory/ as a MEMORY.md index plus topic files. Subagents do not inherit it, except forks. Toggle with /memory or autoMemoryEnabled: false.
await: The word that tells the runtime to wait for a slow result before running the next line. See Your First Program.

B

bind mount: A folder on your machine made visible inside a container, so what the program writes there appears in your editor as it happens. See Build a local web app.

C

callback: A function you hand to another piece of code so that code can call it later, when it has something to tell you. See Build a local web app.
.claude-plugin/: The one directory inside a plugin reserved for plugin.json. Every other component (skills/, agents/, hooks/, and the rest) lives at the plugin root, not inside this folder. See the plugin layout table.
CLAUDE.md: The file Claude Code reads at every level from the filesystem root down to your working directory. Unlike settings, memory files never override each other: every discovered file concatenates into context, in root-to-cwd order, with CLAUDE.local.md appended last in each directory. See Rules.
client: The half of an app running in the browser. The server is the half running on a machine you control. See Build a local web app.
command: A line you type in the terminal: the name of a program, then whatever you want to hand it. See Your First Program.
command (legacy): A flat file in .claude/commands/<name>.md, invoked by its file name. Commands still work but the docs describe them as merged into skills: a skill directory supports supporting files and more frontmatter, so new work should use .claude/skills/<name>/SKILL.md instead. See Your first command.
comment: A note left in a file for the person reading it. Node skips every line that starts with //. See Your First Program.
commit: One recorded version of the files, with a message saying what changed. See Build a local web app.
container: A sealed copy of an app with everything it needs to run inside it, including its own Node. See Build a local web app.
context window: The bounded amount of text a model can consider at once: your messages, its replies, tool results, and everything loaded in. When it fills, something has to be dropped or summarised. See Why it forgot what you told it.

D

dependency: A package your project needs in order to run. See Your First Program.
Docker: The program that builds containers and runs them. See Build a local web app.

E

effort: A frontmatter field on skills and subagents, one of low | medium | high | xhigh | max, that sets how much reasoning budget the invocation gets. Available at ${CLAUDE_EFFORT} for substitution inside a skill body.
environment variable: A named value your shell hands to every program it starts. See The Agent SDK.
example plugin: The plugin this series builds one directory at a time. Each module ships one subdirectory (skills/, agents/, hooks/hooks.json, and so on), and the final module packages the whole thing behind .claude-plugin/plugin.json and validates it with claude plugin validate --strict.
exit code 2: The hook exit code that blocks a tool call through the code alone, for most events. Exit 0 with no output is not approval; it is no decision, and the normal permission flow continues. Exit 1 does not block by itself. Claude Code reads JSON on stdout at every exit code, not only 0, so a hook that exits 1 while also printing a valid JSON decision still has that decision take effect. WorktreeCreate is the one event where any non-zero exit blocks, and PermissionRequest ignores exit 2 entirely, deciding only through the JSON decision field. See the hook decision table, the per-event pages, and Hooks.

F

flag: A word starting with one or two dashes that you add to a command to change what it does, such as -y or --version. See Your First Program.
folder, directory: The same thing under two names. Prose on this site says folder; code, error messages, and most commands say directory. See Your First Program.
frame: One message sent over an open connection. See Build a local web app.
frontmatter: The block between two --- lines at the top of a file, holding named fields that describe the file. Skills, commands, and agents all carry one. See Rules.
function: A block of lines that runs when something calls it rather than when the runtime reaches it. The values handed to it are available inside it under names it chooses. See Your First Program.

G

git: The program that records versions of a folder of files and lets you return to any of them. See Build a local web app.

H

handler: One executable step inside a hook's matcher group. Five types exist: command, http, mcp_tool, prompt, and the experimental agent. All handlers matched by an event run in parallel. See Hooks.
harness: The program wrapped around a model that runs its tools, keeps its history, and decides what it may do. Claude Code is one, and the Agent SDK exposes the same one as a library. See Why it forgot what you told it.
headless: Running a command with one prompt in and one answer out, with no screen to interact with. See The Agent SDK.
hook: A deterministic script or call that Claude Code runs at a defined point in its lifecycle, configured under the hooks key in a settings file or a plugin's hooks/hooks.json. Three levels of nesting: event, matcher group, handlers. See Hooks.
hook event: One of 33 documented points in the session lifecycle (PreToolUse, Stop, SessionStart, and so on) that a hook can attach to. Not every event can block: only a subset, including PreToolUse, UserPromptSubmit, and Stop, honor exit 2. Every event has a page stating what it fires on, what it reads, and what each exit code does there.

I

if filter: An optional hook field holding exactly one permission rule, evaluated only on the five tool-related events (PreToolUse, PostToolUse, PostToolUseFailure, PermissionRequest, PermissionDenied). On any other event, a hook with if set never runs: it is not silently ignored, it is fully suppressed. The filter also fails open: an unparseable Bash command still runs the hook. It has no &&, ||, or list syntax, and it is not a substitute for the permission system.
image (Docker): The saved snapshot a container starts from. See Build a local web app.

J

JavaScript: The language web pages are written in, and the language every program in this track is written in. See Read a program before you write one.
JSON: A text format for structured data, written with curly braces, names, and values. package.json is one. See Your First Program.

L

library: A package your program imports and calls. See The Agent SDK.
localhost: The name for the computer you are sitting at. http://localhost:3000 means port 3000 on this machine and reaches nowhere else. See Your First Program.
loop: An instruction that runs the same lines once for each item in a list. See Your First Program.
loopback, 127.0.0.1: The address only programs on your own machine can reach. 0.0.0.0 means every address the machine has, including one other people on the network can use. See Build a local web app.
LTS: Long-term support. The Node version that keeps receiving fixes for years, and the one to install. See Read a program before you write one.

M

managed settings: Organization-controlled configuration written by an administrator, loaded from a fixed OS path outside any project. It wins over every other settings file, including command-line flags, and a managed permission rule can never be overridden by a lower level. See Settings and themes.
marketplace: A .claude-plugin/marketplace.json manifest listing installable plugins by name and source. Adding a marketplace with claude plugin marketplace add makes its plugins available to /plugin install; it does not enable them.
matcher: The pattern a hook's matcher group uses to decide which tool calls it applies to. *, an empty string, or omitting it matches everything. A string built only from letters, digits, _, -, spaces, commas, and | is an exact match or an exact-match list; anything else is treated as an unanchored JavaScript regular expression.
MCP: Model Context Protocol: the open, vendor-neutral standard Claude Code uses to connect to external tool servers, declared in .mcp.json. It is the one surface the docs describe as portable across harnesses. See MCP.
MCP resource: Content an MCP server exposes for reference, addressed as @server:protocol://resource/path (for example @github:issue://123) and attached to a prompt with @ autocomplete. Distinct from an MCP tool, which the model calls rather than attaches.
MCP server: A process or endpoint speaking MCP, configured with a type of stdio, http, sse (deprecated), or ws. Scopes are local (this project, not shared), project (.mcp.json, checked into version control), and user (every project). See MCP.
mcp__server__tool: The runtime name of an MCP tool: server name and tool name joined by double underscores, for example mcp__github__list_issues. This is the form to use in permission rules, a skill's allowed-tools, a subagent's tools list, and hook matchers. A plugin-supplied server's tools carry an extra plugin_<plugin-name>_ segment.
module (a file): A file that can borrow tools from other files. Node treats a file ending in .mjs as one. The numbered pages of this course are also called modules, and the two meanings are unrelated. See Your First Program.

N

Node: A runtime that runs JavaScript without a browser. Install it once, then node <file> runs a file. See Your First Program.
node_modules: The folder npm downloads packages into. You do not edit it by hand. See Your First Program.
npm: The command that installs alongside Node and downloads packages. npm install <name> puts one in node_modules and records it in package.json. See Your First Program.

O

object: A group of named values written inside curly braces. message.type reads the value stored under the name type. See The Agent SDK.
output style: A file in output-styles/ that modifies the system prompt rather than appending a user message. It takes effect only after /clear or a new session, does not apply to subagents except forks, and across nested project directories the definition closest to your working directory wins. See Shaping the model.

P

package

Code someone else wrote that you download into your project and import the same way as a tool that came with Node. See Your First Program.

package.json

The file holding your project's name and the list of packages it depends on. npm init -y creates it. See Your First Program.

path

The address of a file or folder, written as the folders you pass through to reach it. See Your First Program.

permission mode

The session-wide setting that decides how much Claude Code asks before acting: default (read-only, called Manual in the UI), acceptEdits, plan, auto (a classifier reviews actions instead of you), dontAsk (auto-denies anything not pre-approved), and bypassPermissions (skips prompts, including protected-path writes). See Permissions and sandbox.

permission rule

One entry in permissions.allow, ask, or deny, written as Tool or Tool(specifier). Rules evaluate deny, then ask, then allow, first match wins, and specificity never matters: a broad deny beats a narrower allow. A bare tool name in a deny rule removes the tool from Claude's context entirely, rather than merely blocking calls to it.

plugin

A folder that packages skills, agents, hooks, MCP servers, and commands so Claude Code can load them as one unit. The manifest, .claude-plugin/plugin.json, is the file that names it. See Build the plugin.

port

A numbered door on a computer. A server picks one, and anything that reaches that number reaches that server. See Your First Program.

precedence

Which definition wins when two sources define the same name. The order is different per surface, and on one pair of surfaces it inverts.

Precedence order per surface
Surface	Highest to lowest
Skills	enterprise > personal > project
Subagents	managed > `--agents` > project > user > plugin
Settings	managed > CLI > project-local > shared project > user

The pair that trips people

Skills and subagents invert against each other. For skills, your personal definition beats the project's. For subagents, the project's definition beats yours. Generalize from one surface to the other and you get a bug both surfaces load without complaint.

See the full precedence table, which also covers settings and CLAUDE.md.

process

One running program. Two runs of the same program are two processes. See The Agent SDK.

program

A text file of instructions. A runtime reads it from the top and does each line in order. See Your First Program.

progressive disclosure

The economics behind a skill's two-part loading: its description stays in context for the whole session so Claude can decide when to reach for it, while the body of SKILL.md and any supporting files load only when the skill is actually invoked. See Skills.

prompt (model)

The text you send to Claude for it to work on. This sense and the terminal sense share the word and nothing else. See Your First Program.

prompt (terminal)

The line the terminal shows when it is ready for your next command. While a program is still running, that line does not come back. See Your First Program.

protected path

A directory or file (.git, .claude, shell startup files, .mcp.json, and others) whose writes are never auto-approved by an allow rule, in any mode except bypassPermissions. The check runs before allow rules are even read, so a permission rule cannot pre-clear it.

protocol

The agreed list of messages two programs may send each other, and what each one means. See Build a local web app.

R

regular expression (regex): A pattern for matching text: most characters match themselves, and a few such as . and * stand for "anything" and "repeat". See Hooks.
repository: A folder git is recording versions of, together with that history. See Build a local web app.
request, response: What the browser asked for, and the answer sent back to it. See Your First Program.
.claude/rules/: A directory of markdown files, discovered recursively, that load with the same priority as a project's CLAUDE.md. The only supported frontmatter field is paths, a list of globs scoping when the rule loads; without it, a rule loads unconditionally at launch. See Rules.
runtime: The program that reads your file and carries out the instructions in it. Node is the runtime this track uses. See Your First Program.

S

sandbox: The built-in isolation layer for Bash and PowerShell commands: Seatbelt on macOS, bubblewrap plus socat on Linux and WSL2. By default it allows writes to the working directory and the session temp dir, and reads almost the entire filesystem except explicitly denied paths. It is not a substitute for a container: the docs are explicit that bypassPermissions depends on whatever isolation boundary you choose. See Permissions and sandbox.
SDK: Software development kit. A package made for building programs on top of someone else's product. See Your First Program.
server: A program that does not finish. It waits to be asked for something, answers, and waits again. See Your First Program.
session: One run of the agent loop, from a prompt to its final answer. See The Agent SDK.
settings precedence: The five-level order settings files resolve in: managed, then command-line arguments, then project-local (.claude/settings.local.json), then shared project (.claude/settings.json), then user (~/.claude/settings.json). List-valued keys such as permissions.allow merge across levels rather than one replacing another; a few whole-value keys like fallbackModel are exceptions. See the precedence table.
shell: The program inside the terminal window that reads what you type and starts other programs. bash and zsh are the usual shells on macOS and Linux, PowerShell on Windows, and the same command can differ between them. See Your First Program.
skill: A directory under .claude/skills/<name>/ (or ~/.claude/skills/, or a plugin's skills/) containing a SKILL.md and optionally supporting files or scripts. Skills are the current, merged form of both slash commands and reusable capabilities: the docs state outright that custom commands have been merged into skills. See Skills.
SKILL.md: The required file inside a skill directory. Every frontmatter field is optional; only description is recommended, since that is what tells Claude when to use the skill. The directory name, not the frontmatter name field, determines what you type to invoke a personal or project skill.
stdin, stdout: The text a program reads in, and the text it prints out. Together they are called stdio, and they are how two programs on one machine usually talk. See The Agent SDK.
stream: Values that arrive one at a time over time rather than all at once. for await is the loop for reading one. See The Agent SDK.
streaming: Text shown as it arrives rather than after the whole answer is ready. See Build a local web app.
string: A piece of text inside quotes. The quotes mark where the text starts and ends and are not part of it. See Your First Program.
subagent: A separately configured agent, defined in a markdown file under .claude/agents/, with its own system prompt, tool allowlist, and model. It runs in an isolated context window and does not inherit the main session's conversation history, output style, or auto memory. name and description are the only required fields. See Subagents.
system prompt: The instruction block set once at the start of a conversation, distinct from a user message. Output styles modify it directly; --append-system-prompt adds to it from the command line. Understanding this split is the point of Shaping the model.

T

tag (git): A name git pins to one commit. git checkout <tag> puts every file back the way it was at that commit. See Build a local web app.
terminal: The window where you type commands instead of clicking. It is always standing in one folder, and a command acts on that folder unless you tell it otherwise. See Your First Program.
theme: A named color scheme for the CLI interface, selected with the theme setting. Custom themes live at ~/.claude/themes/<slug>.json, with three optional fields (name, base, overrides) and hot reload; an invalid token is ignored rather than breaking the theme. See Settings and themes.
token (design): A named value in a theme, such as a color or a size, defined once and reused across an interface. See Settings and themes.
token (model): The unit models read and write text in, a piece of a word around four characters of English. Costs and context windows are measured in them. See Skills.
tool search: The mechanism that keeps large MCP tool catalogs out of context by default: only tool names and server instructions load at session start, and full schemas fetch on demand. Controlled with ENABLE_TOOL_SEARCH; a server can opt out of deferral with alwaysLoad: true.
turn: One round trip inside the loop: the model asks for something, a tool runs, the result goes back. maxTurns caps how many a session may take. See The Agent SDK.

V

variable: A name attached to a value so later lines can use it. const names = ... makes names stand for whatever the right-hand side produced. See Your First Program.

W

WebSocket: A connection between a browser and a server that stays open, so either side can send at any moment. See Build a local web app.
working directory: The folder a program is standing in while it runs. A file name with no path in front of it means a file in that folder. See Your First Program.
workspace trust: The one-time dialog a project asks you to accept before its permissions.allow rules and additionalDirectories take effect. deny and ask rules apply immediately regardless of trust. Trust is keyed to the git repository root, and a headless -p run never sees the dialog at all. See Permissions and sandbox.