Reference

The Claude Code Glossary

77 terms, side by side comparisons, and the vocabulary behind agents, skills, MCP, and orchestration, explained the way we actually use it on client builds.

Core Concepts

19
  • Agent

    A language model that runs in a loop: it reads a goal, chooses tools, observes the result, and decides the next step on its own until the task is done or it stops.

  • Context Window

    The total amount of text (measured in tokens) a model can hold in memory at once: system prompt, conversation history, file contents, and tool output all share this budget.

  • Harness

    The surrounding program that wires a model up to tools, the file system, and a terminal, and runs the agent loop. Claude Code is a harness; the model itself is not.

  • System Prompt

    The instructions loaded before a session starts that shape how the model behaves: its role, constraints, and available tools. CLAUDE.md content is folded into this layer.

Building Blocks

15
  • Skill

    A packaged folder of instructions, and optionally scripts and reference files, that Claude loads on demand when a task matches its description. Skills teach a repeatable procedure instead of running as a always-on tool.

  • MCP (Model Context Protocol)

    An open protocol that lets Claude connect to external servers exposing tools, resources, and data, so one integration works the same way across many services instead of a bespoke connector per app.

  • Subagent

    A separate Claude instance dispatched by a parent session to handle one bounded piece of work in its own context window, then report back a summary instead of the full transcript.

  • Hook

    A shell command the harness runs automatically at a defined lifecycle event, such as before a tool call, after a file edit, or when a session starts, independent of what the model decides.

Orchestration Patterns

8
  • Orchestrator

    The top-level agent that plans work, dispatches subagents or workers for individual pieces, and assembles their results, rather than doing every step itself.

  • Worker Agent

    An agent dispatched by an orchestrator to handle a specific, scoped role, like reviewing code or writing content, as part of a larger coordinated fleet.

  • Parallel Agents

    Multiple agent sessions running at the same time on independent pieces of a larger task, each with its own context window, to finish faster than one agent working sequentially.

  • Handoff

    The moment one agent's output (a summary, a file, a decision) is passed to another agent or human to continue the work, typically written down so context is not lost between sessions.

Failure Modes

7
  • Context Rot

    Degraded reasoning quality that shows up as a context window fills with long, noisy, or repetitive history, even though the window technically still has room left.

  • Hallucination

    When a model states something confidently, an API method, a file path, a fact, that is wrong or does not exist, without any signal that it is uncertain.

  • Prompt Injection

    An attack where instructions hidden in content the agent reads (a web page, a file, a tool result) attempt to override its actual task, tricking it into taking unintended actions.

  • Sycophancy

    A tendency for a model to agree with or flatter the user's stated position instead of giving an accurate, independently reasoned answer, especially when pushed back on.

Patterns of Work

8
  • AFK (Away From Keyboard) Work

    A working style where an agent is given a bounded task and permission to run unattended for an extended stretch, with the human reviewing the result afterward instead of watching each step.

  • Human-in-the-Loop

    A workflow design where the agent pauses at defined checkpoints, such as before merging code or before an irreversible action, for explicit human approval before continuing.

  • Automated Review

    Using a separate agent pass, distinct from the one that wrote the code, to check a diff for bugs, security issues, or style problems before it reaches a human reviewer.

  • Plan Mode

    A working mode where the agent researches and proposes an approach without editing any files, so a human can approve the plan before implementation begins.

Loops, Goals & Automation

5
  • Loop

    A recurring prompt cycle that repeats a task, either on a fixed interval or by pacing itself, instead of running once and finishing.

  • Ralph Loop

    A named autonomous-coding pattern, originated by Geoffrey Huntley in July 2025, where each iteration runs in a clean context window and completes exactly one task before the next iteration starts fresh.

  • Goal

    A tracked target or objective an agent works toward across multiple sessions, as distinct from a single bounded task expected to finish in one run.

  • Workflow

    A defined multi-step process, often spanning several tool calls or even multiple agents, that runs in a specific sequence rather than being improvised turn by turn.

Skill vs MCPVS

Skill

A markdown-plus-scripts folder that Claude reads when relevant. It changes how Claude uses the tools it already has, for example a checklist for reviewing a pull request or a template for writing a report. No new capability is added, just instructions and reusable assets.

MCP

A protocol connecting Claude to an external server that exposes genuinely new tools, such as querying a specific database, calling a paid API, or controlling a specific SaaS product. It extends what Claude can technically do, not just how it does it.

Verdict: Use a Skill to standardize a process. Use MCP when the task requires a capability or data source Claude does not already have access to.

Skill vs SubagentVS

Skill

Stays inside the current context window. It loads extra instructions and optional scripts, and the same agent keeps working with that added knowledge. No new context window is created.

Subagent

A distinct Claude instance with its own context window, dispatched to handle a bounded piece of work, then returns a summary to the parent. Used to parallelize work or to keep large exploratory output out of the main session's context.

Verdict: Reach for a Skill to change how the current agent works. Reach for a Subagent when the work is large enough, or independent enough, to isolate in its own context window.

Skill vs PluginVS

Skill

A single unit of packaged know-how: instructions plus optional supporting files, scoped to one job (like generating an image, or running a specific audit).

Plugin

An installable bundle that groups multiple pieces together, potentially several skills, slash commands, hooks, and MCP server definitions, and ships them as one versioned unit other people or projects can install.

Verdict: A Skill is a component. A Plugin is a distribution container that can hold many components, including skills, at once.

Skill vs Slash CommandVS

Skill

Has a description the model reads at session start. When a task matches, Claude loads the skill's full instructions on its own, without the user needing to name it.

Slash Command

A saved prompt triggered explicitly by typing /name. It runs only when the user calls it, not automatically based on task relevance.

Verdict: Use a Skill for knowledge the agent should recognize and apply on its own. Use a Slash Command for an action the user wants to trigger deliberately, on demand.

MCP vs Direct APIVS

MCP

A shared protocol: any MCP-compatible client can connect to any MCP server and discover its tools automatically. One implementation on the server side works with many different agent clients.

Direct API

A bespoke integration written against a specific service's REST or GraphQL endpoints, wired into the harness or application code by hand for that one use case.

Verdict: MCP trades some flexibility for reuse across tools and projects. A direct API integration is more work up front but can be tuned exactly to one use case.

Subagent vs AgentVS

Agent

The general term for a model running a tool-use loop toward a goal. Any Claude Code session, top-level or dispatched, is an agent in this sense.

Subagent

An agent specifically spawned by another agent (the orchestrator or parent session) to handle one scoped piece of work, with its own context window, that then hands a result back up.

Verdict: Agent is the category. Subagent is a role within it: one agent working under another agent's direction.

Hook vs SkillVS

Hook

A shell command wired to a specific event (session start, before a tool call, after a file edit) that always fires when that event happens. The model has no say in whether it runs.

Skill

A block of instructions the model reads and decides to use based on the current task. It shapes behavior through the model's own reasoning, not through a forced, unconditional trigger.

Verdict: Use a Hook when a rule must hold every single time, no exceptions. Use a Skill when the right behavior depends on judgment about the current task.

MCP vs PluginVS

MCP

A protocol and a live server connection exposing tools that reach an outside system, a database, an API, a service the agent could not otherwise touch. Defined by the connection, not by how it is packaged.

Plugin

A packaged, installable bundle of skills, hooks, and commands, all local to the harness, distributed and versioned together as one unit. Defined by packaging, not by any external connection.

Verdict: These solve different problems rather than competing directly. MCP is about reaching something outside the agent's existing capabilities. A Plugin is about packaging and distributing capabilities the harness already runs locally as one shareable set, and can even include the configuration for connecting to an MCP server inside it.

Agent vs AssistantVS

Agent

A model wired to tools and a task loop: it can act, observe the real result of that action, and decide the next step itself, repeating until a goal is met.

Assistant

A model that primarily produces one helpful reply per input, with little or no ability to take real actions or verify its own output against the real world beyond that reply.

Verdict: The line is the loop and the tools: an assistant answers, an agent acts, checks the result, and adjusts. A question answered correctly in one shot is assistant behavior even from a very capable model. A task completed by editing files, running commands, and confirming the result actually worked is agent behavior, regardless of how the model is branded.

Loop vs GoalVS

Loop

The mechanism: a task that repeats, on a fixed interval or self-paced, until a stop condition tells it to end. A loop says nothing on its own about what success looks like, only that the same cycle runs again.

Goal

The target: an objective tracked over time, possibly across many sessions, that defines what 'done' actually means. A goal can be pursued with a loop, but doesn't require one, a single long session working straight through can also chase a goal.

Verdict: Loop answers how work repeats. Goal answers what the repeating, or even non-repeating, work is actually trying to reach. A loop with no real goal or stop condition just runs indefinitely without a way to know it's finished; a goal pursued with no loop and no tracked state just relies on one session doing everything in a single pass.

Loop vs Ralph LoopVS

Loop

The general concept: any recurring or self-pacing prompt cycle. It makes no claim about how context is handled between iterations, that detail is left entirely to whoever builds the specific loop.

Ralph Loop

One specific, named pattern: each iteration starts a genuinely fresh Claude Code instance with a clean context window, reads a progress file and AGENTS.md, completes exactly one task fully, and commits before the next fresh instance picks up.

Verdict: Every Ralph Loop is a loop, but not every loop is a Ralph Loop. What earns the specific name is the clean-context-per-iteration discipline: memory survives through git history and a progress file instead of a continuous conversation, which is a deliberate design choice a generic loop is free to skip.

Loop vs CronVS

Loop

Can be self-paced: the agent decides when the next iteration should run based on what it actually finds, checking again sooner if something looks urgent, later if nothing has moved.

Cron

Always fixed-interval: a scheduled trigger fires on a clock, every five minutes, every morning, regardless of whether anything has changed or whether now is genuinely the right moment to run again.

Verdict: Cron is one specific way to drive a loop, the fixed-interval way. A loop doesn't require cron at all, it can pace its own next run based on progress instead of a clock. Reach for cron when the right cadence is genuinely fixed and known ahead of time; reach for a self-paced loop when the right moment to check again actually depends on what the work itself turns up.

Workflow vs SkillVS

Workflow

A defined sequence: do this, then this, then this, in a specific order every time. A workflow can use one or more skills along the way, but the sequence itself, not any single capability, is what defines it.

Skill

A packaged set of instructions the model loads on demand for one job. A skill changes how the current agent handles a task, it doesn't define a fixed multi-step sequence the way a workflow does.

Verdict: A skill teaches an agent how to do one thing well. A workflow defines the order several things happen in, and can call on one or more skills as it goes. Skill is an ingredient; workflow is the recipe that decides when each ingredient gets used.

Workflow vs SubagentVS

Workflow

The plan: a defined sequence of steps a process moves through in order. A workflow can be executed entirely by one agent working straight through, or can hand individual steps off to separate subagents.

Subagent

One dispatched unit of execution: a separate agent run with its own context window, given a bounded piece of work, that reports a result back. A subagent handles one step, it is not a sequence of steps itself.

Verdict: Workflow is the sequence; subagent is one way to execute a single step in that sequence in isolation. A workflow can run start to finish without ever dispatching a subagent, and a subagent can be dispatched for a one-off task with no formally defined workflow behind it at all.

Goal vs Plan ModeVS

Goal

The target itself: what an agent or a fleet is ultimately trying to accomplish, possibly across many sessions, defined independent of how any one session goes about reaching it.

Plan Mode

A working mode for a single session: the agent researches and proposes an approach without editing any files, so a human can approve the plan before implementation begins. It produces a plan for reaching a goal, it isn't the goal itself.

Verdict: A goal is where the work is ultimately headed. Plan Mode is a deliberate stop, inside one session, to work out the route before touching anything real. A single goal can pass through several separate rounds of Plan Mode, one per session, before it's actually reached, especially on work that's long-running or genuinely risky.