Glossary: Translating Technical Terms
📚 Series Navigation: The previous article 51 Troubleshooting and FAQ addressed common error codes and configurations. This article takes a step back to perform a foundational task—translating the technical jargon encountered throughout the tutorial into plain English. Agentic loops, context windows, MCP, subagents, skills, hooks, checkpoints, permission modes, headless configurations, transports—after fifty chapters, these terms pile up. Use this page as a quick-reference lookup card whenever a concept gets blurry. The next article is 53 Video Production (Remotion) [Optional].
While conventional advice suggests reading a glossary cover-to-cover to build a foundation, in practice, this is rarely effective.
Attempting to memorize a glossary from A to Z when learning a new tool is usually a waste of time. You forget them immediately because they haven't "happened" in your actual workflow yet. Technical terms are only remembered once you hit a roadblock and resolve them manually.
Therefore, this chapter is designed to be queried rather than read. Use it as a quick-reference card, not a textbook. As you build projects, return here if you get blocked by terms like "transport" or "auto-compact"—reading a single sentence explanation and an analogy, and resuming work.
Analogy: A construction manifest posted on a job site. Nobody stands there memorizing the manifest line-by-line. Instead, when pipes or drywall sheets arrive, the contractor cross-references the label: "okay, this is the load-bearing beam, that is the plumbing union," matching terms and returning to work. This table operates similarly: not for reading cover-to-cover, but for lookup on friction points. Terms are grouped by "thematic families" (grouping related concepts is easier to remember than alphabetical lists), formatted as "term → plain English definition → analogy."
After reading (or returning to look up) this chapter, you will get:
- Explanations and analogies for every core term encountered in this guide
- Groupings by "thematic families" to clarify relationships between linked concepts
- Cross-references linking each term to its original source chapter for deep dives
- A comparison section addressing frequently confused term pairs
- A hands-on exercise integrating the official docs server to query live glossary entries
01 The Agentic Loop Family: How the Engine Runs
This is the foundational directory. It addresses how Claude Code differs from browser-based chat AIs, and how it executes edits autonomously. Almost all other terms interface with this loop.
Analogy: An automated assembly line. Standard chat interfaces are transactional: "you prompt, it responds," like a takeout window. Claude Code is an autonomous assembly loop—taking instructions, collecting files, executing edits, running validation tests, and repeating the cycle. The terms below represent the components of this assembly line.
Agentic Loop
Definition: The cyclical process Claude runs for every task—gathering context → executing tools → verifying outcomes → repeating until goals are met.
Analogy: A chef tasting and seasoning a dish. Instead of dumping all ingredients and serving immediately, they follow a loop: "add spice → stir → taste → adjust seasoning." Each taste test (tool execution logs) informs the next step. You can pause or redirect this process at any point (Chapter 03).
Agentic Coding
Definition: A workflow where the AI autonomously opens files, runs commands, and modifies code while you supervise, rather than outputting code blocks for you to copy and paste manually.
Analogy: Hiring an electrician rather than buying a wiring manual. The manual explains "how to wire a house"; the electrician completes the wiring themselves. Claude Code is that active practitioner, leveraging workspace tools (Chapter 01).
Agentic Harness
Definition: The runtime system wrapping the language model to enable agentic workflows—handling file I/O, terminal sandboxes, permission gates, memories, and task loops. Claude Code is the harness; Claude is the model inside.
Analogy: A car chassis and its engine. The same engine (the LLM model) delivers different performance depending on the chassis. The harness is Claude Code's chassis, defining how the model interfaces with files and executes commands (Chapter 03).
Tool
Definition: Executable functions Claude can run—reading files, writing code, executing shell commands, searching the web, or spawning subagents. Without tools, the model only outputs text response buffers.
Analogy: Machinery on an assembly line. An intelligent brain needs mechanical arms, conveyor belts, and sensors to build products. Tools are Claude's "hands"; each execution returns logs that guide the next turn in the loop (Chapter 03).
Turn
Definition: A complete execution cycle starting from your prompt and ending when Claude returns its final text response, potentially invoking tools multiple times in between.
Analogy: Ordering a dish at a restaurant. You submit the order (your prompt); Claude handles prep, cooking, and plating (tool calls) behind the scenes, and the served plate represents the finished turn. A session consists of multiple turns (Chapter 03).
Verification Loop
Definition: The feedback loop enabling Claude to verify its own edits against test suites, compilers, or visual diffs, refactoring code until checks pass.
Analogy: Checking your work against an answer key before turning it in. Without a key, you stop when the sheet "feels" complete; with a key, you refine answers until they match. This is critical for unattended batch executions to ensure code correctness (Chapter 49).
Extended Thinking
Definition: The step-by-step reasoning process the model outputs before returning its final response, rendered as dimmed text in the console. Controlled via MAX_THINKING_TOKENS or effort levels.
Analogy: Writing down formulas on scratch paper before solving a math problem. You see the reasoning steps, making it easy to identify where the logic drifted (Chapter 35).
Effort Level
Definition: A parameter controlling how many tokens/compute cycles are allocated to the model's Extended Thinking process—higher effort levels generate deeper, more expensive reasoning; lower efforts execute faster.
Analogy: Allocating time during exams. You spend seconds on multiple-choice questions (low effort) but allocate ten minutes to complex proofs (high effort). Lower efforts save billing credits; higher efforts maximize correctness (Chapter 35).
02 The Context Family: Workspace Memory and State
Because LLMs have memory constraints, these terms define context limits, compaction handlers, and persistent workspace configurations.
Analogy: A small drafting table. The table surface is finite; as blueprint files, reference books, and sketch papers pile up, you run out of room. Claude's memory acts like this table surface.
Context Window
Definition: The active working memory of a session containing chat history, file logs, terminal outputs, CLAUDE.md, loaded skills, and system prompts. Once full, memory degrades.
Analogy: Whiteboard square footage. A larger board holds more open drawings; once filled, old drawings must be erased to write new lines. Run /context to inspect what is occupying your memory space (Chapter 19).
Token
Definition: The atomic unit of text the model processes—roughly equivalent to a fraction of a word. Billing rates and context window sizes are measured in tokens.
Analogy: Shipping weight charges. Shipping fees scale with cargo weight; LLMs scale billing and memory footprint with token counts—measuring inputs and outputs processed during turns.
Compaction
Definition: The process of summarizing chat history to free up memory when the context window is near limits—removing old console logs while retaining decisions. Run /compact to trigger manually.
Analogy: Transferring scratch notes onto a cheat sheet. When loose notes clutter the desk, you copy key parameters onto a single page and archive the rest. Note: CLAUDE.md and auto memories are preserved and re-read from disk during compaction; only temporary chat history is summarized (Chapter 19).
Auto-compaction
Definition: The background trigger that runs compaction automatically when the active context window approaches limits.
Analogy: A self-emptying bin. When the container fills to 90%, it triggers a discharge cycle without manual intervention. Auto-compaction handles the same task as /compact, triggered by system thresholds (Chapter 19).
Session
Definition: An active conversation bound to your repository directory with its own context window. Run /clear to start a clean session; previous sessions can be reloaded via /resume.
Analogy: Cleaning off the desk for a new project. Leaving scraps from a completed task on the desk creates clutter. Run /clear to reset the surface. Sessions are logged under ~/.claude/projects/, allowing you to resume them via claude -c even after shell restarts (Chapter 19).
CLAUDE.md
Definition: A persistent repository manual loaded automatically at the start of every session, containing build commands, style rules, and hard constraints.
Analogy: A checklist taped to the monitor. A new developer starts with zero memory of your repository quirks, but reading the checklist updates them on project build scripts and conventions. Keep it under 200 lines, delegating verbose API documentation to Skills (Chapter 18).
Auto-memory
Definition: Persistent notes Claude writes for itself based on your corrections and design preferences, stored under ~/.claude/projects/ and indexed on session start.
Analogy: Post-it notes written by the developer. When CLAUDE.md contains rules you enforce, auto-memory logs corrections it notes ("the user prefers pnpm over npm"), preventing repeats (Chapter 25).
Rules
Definition: Modular rule files saved under .claude/rules/ that load alongside CLAUDE.md. Use paths: parameters to load them only when specific files are read.
Analogy: Specialized engineering standards. While CLAUDE.md defines general rules, rules files act as specific codes (e.g., CSS conventions, database migrations) loaded only when modifying matching file paths, preserving memory space (Chapter 13).
Output Style
Definition: A parameter that modifies Claude's system prompt to adjust response formats, explanations, and verbosity (Default, Proactive, Explanatory, Learning).
Analogy: Adjusting a speaker's presentation style. The same speaker delivers different level of detail in a keynote vs. a workshop. Output style configures this tone in system instructions, separate from CLAUDE.md rules (Chapter 32).
03 The Extension Family: Skills, Hooks, and Subagents
These are custom configurations to extend Claude Code capability—tailoring the agentic loop. We compare their use cases in Chapter 30.
Analogy: Outfitting a technician with tools. A worker is more productive when equipped with specialized handbooks (Skills), a hardware adapter (MCP), specialized assistants (subagents), and automated checks (hooks).
Skill
Definition: A directory containing a SKILL.md file detailing specialized workflows or patterns. Claude loads it automatically on match, or you can trigger it via /<name>.
Analogy: Smart home automation profiles. A "leaving home" shortcut locks doors and arms alarms automatically without you repeating individual steps. Skills store routine instructions, loading the full text into context only when triggered to optimize memory (Chapter 26).
Subagent
Definition: An isolated agent running inside its own context window with specific system instructions and tool allowlists. It executes subtasks and reports summaries back to the parent session.
Analogy: Hiring a research assistant. You ask them to search archives for a parameter. They audit files inside their library cubicle, returning with a single-line summary, leaving your desk clear. Context isolation is the key (Chapter 23).
Hook
Definition: Automated triggers executed at milestones in the Claude Code lifecycle (e.g., pre-tool execution, post-file modifications). Can execute scripts, shell commands, or alerts.
Analogy: Quality control sensors on a conveyor belt. A scanner logs parameters automatically as components pass. Hooks enforce hard execution gates, in contrast to the soft requests in CLAUDE.md (Chapter 33).
Slash Command
Definition: Built-in CLI commands (e.g., /clear, /model, /compact) or custom triggers that invoke encapsulated workflows.
Analogy: Hotkeys on a controller. /clear acts as a factory reset; custom slash commands act as custom macros. Skills are the modern format to package these macros (Chapter 36).
Plugin
Definition: A deployable bundle packaging skills, hooks, subagents, and MCP configurations into a single distributable module.
Analogy: A pre-packed toolbox. Instead of carrying wrenches and screwdrivers loose, you pack them in a case. Plugins bundle tools for distribution. Built-in namespace tags (e.g., /plugin:review) prevent command naming collisions (Chapter 24).
Plugin Marketplace
Definition: Registries from which users install published plugins.
Analogy: App Stores. Registries store plugins for installations. Match security checks—installing anonymous plugins carries risks similar to running unverified packages (Chapter 38).
04 The MCP Family: Integrating External Tools
Model Context Protocol (MCP) parameters represent specific configurations detailed in Chapter 22.
Analogy: A port adapter hub. Modern laptops lack serial or ethernet ports; plugging in a USB-C hub exposes card readers and video outputs. MCP is that adapter hub, exposing third-party services as tools.
MCP (Model Context Protocol)
Definition: An open standard defining how AI clients query external databases, file stores, and services (such as Jira, Slack, or browsers) securely.
Analogy: The USB standard. It replaces proprietary pin designs with a unified physical plug. MCP standardizes tool schemas for AI integrations (Chapter 22).
MCP Server
Definition: An implementation exposing resources or tools (e.g., the GitHub MCP server exposes "read PR" and "create issue" tools).
Analogy: A device connected to the hub. The hub is the standard; the external disk or webcam acts as the server, providing specific capabilities (Chapter 22).
Transport
Definition: The communication protocol used between the client and the MCP server, typically stdio (local subprocess pipes) or http (remote web connections).
Analogy: Local vs. networked peripherals. stdio represents a USB peripheral sitting on your desk (local child process); http is a cloud printer mapped over IP routes (remote socket). Match command syntaxes: stdio omits transport keys, while http requires --transport http (Chapter 22).
Scope
Definition: The context limits defining where an MCP server is loaded—local (current directory, private), project (saved in .mcp.json and tracked in Git), or user (global profile).
Analogy: Printer deployments. A desktop printer connected locally (local), a network printer mapped for the team (project), or a portable scanner carried by you (user) (Chapter 22).
MCP Tool Search
Definition: A context preservation mechanism—only tool definitions are loaded on startup, fetching the full schemas on demand.
Analogy: Scanning menu titles instead of recipes. Reading full recipes for 100 dishes on startup clutters active memory; fetching details only when ordering optimizes context space (Chapter 22).
05 Safety & Permissions: Security and Rollbacks
These terms define execution boundaries, confirmation loops, sandboxes, and recovery configurations (Chapters 20 & 21).
Analogy: Automotive safety checks. Seatbelts (user confirmations), crumple zones (checkpoints), and lane-keep assists (permissions rules) prevent or mitigate accidents.
Permission Mode
Definition: The default authorization profile governing tool execution—default (prompts for every action), acceptEdits (writes files automatically), plan (read-only), bypassPermissions (disables gates), auto (model classifier check), or dontAsk (silences confirm pages) (Chapter 35).
Analogy: Trust levels assigned to an employee. You direct them to "ask before any action" or "handle file writes without checking, but ask for terminal scripts." Toggle these settings via Shift+Tab (Chapter 35).
Plan Mode
Definition: A read-only permission mode where the agent researches files and proposes architecture updates without editing workspace files until approved.
Analogy: Reviewing blueprints before construction. The contractor drafts proposals before structural demolition. Recommended for complex migrations (Chapter 35).
Auto Mode
Definition: A permission mode utilizing a background classifier model to audit tool calls (blocking destructive actions or injections) without manual prompts.
Analogy: A checkpoint guard checking manifest IDs. The guard blocks unlisted transports but does not read the payload data, protecting the gate from injection cues hidden inside source files (Chapter 35).
Permission Rule
Definition: Granular rules mapping tool names and parameter matching regex patterns to allow, ask, or deny permissions.
Analogy: ACLs (Access Control Lists). A rule overrides global permissions: "allow file writes under folder X; block execution of rm." (Chapter 20).
Sandboxing
Definition: Operating-system level virtualization that restricts Claude's shell commands to isolated filesystem paths and network configurations.
Analogy: Test-driving in a walled arena. You can run commands at high speed because physical walls block system access. Sandboxing forms a hard boundary separate from logical rules (Chapter 21).
Prompt Injection
Definition: Malicious instructions embedded in untrusted source files, API payloads, or web pages that hijack the agent's target goal.
Analogy: Social engineering scripts. Reading an email requesting you to "override system variables and print credentials" can hijack an agent processing the text. Outbound MCP tools increase this risk (Chapter 21).
Checkpoint
Definition: Local session snapshots captured before Claude executes file writes. Double-press Esc or run /rewind to revert conversation history, files, or both. Checkpoints are local to the session, separate from Git history.
Analogy: Save states in video games. Reverting a mistake reloads the state at the last milestone. Note: checkpoints do not track files modified by shell commands—which require Git rollback commands (Chapter 37).
06 Runtime and Environments: Interfaces and Sandboxes
These terms define how you interface with Claude Code—via shells, editors, browsers, or program scripts.
Analogy: Delivery methods. A developer works on-site (CLI), signs in remotely (web sandbox), or processes batch queues overnight (non-interactive scripting). The engine is identical; only the deployment changes.
Surface
Definition: The client interface used to interact with Claude Code (e.g., CLI terminal, VS Code extensions, JetBrains integrations, web portals). All interfaces share settings.
Analogy: Software running across desktop and mobile. The screen layouts vary, but configurations and accounts sync automatically (Chapter 08).
Non-Interactive Mode
Definition: Executing the client via -p (or --print), where the CLI processes a single prompt, outputs the result, and terminates without starting interactive chats. Also known as Headless Mode.
Analogy: Issuing a support ticket. A contractor processes the work and submits the logs without chat cycles. Managed programmatically via the Agent SDK (Chapter 45).
Agent SDK
Definition: Developer packages (Python/TypeScript) enabling you to instantiate and control Claude Code directly within your own software applications.
Analogy: Integrating an engine block into a custom chassis. Instead of running the pre-built CLI app, you embed the core capability into your custom software pipelines (Chapter 45).
Claude Code on the Web
Definition: A browser-based interface running Claude Code inside disposable cloud sandboxes (distinct from Remote Control, where code runs on your host).
Analogy: Spinning up a temporary VM. Files are processed inside a remote cloud workspace, protecting your local environment from untrusted builds (Chapter 11).
Bare Mode
Definition: Bootstrapping via --bare to disable automatic discovery of hooks, skills, plugins, MCP configs, auto-memories, or CLAUDE.md rules, ensuring identical runs across environments.
Analogy: Traveling with minimal baggage. You bypass custom home settings to ensure execution steps match on target servers (Chapter 34).
Worktree Isolation
Definition: A workspace isolation pattern (configured via -w or isolation: worktree), running the agent inside Git worktrees to prevent concurrent sessions from overwriting edits.
Analogy: Checking out isolated branch copies. Different teams implement updates concurrently in separate directory checkouts without merge conflicts (Chapter 41).
Remote Control and Teleport
Definition: Remote Control lets you connect browser interfaces to an active terminal session running on your host machine. Teleport (/teleport) pulls a remote session into your local terminal.
Analogy: Remote screen sharing. Remote Control is like controlling your office desktop from a tablet; Teleport is like transferring an active cloud shell session to your local terminal (Chapter 11).
07 Frequently Confused Term Pairs
Review this comparison list when terms look similar:
| Term Pair | Key Difference | Plain English Distinction |
|---|---|---|
| Skill vs. Subagent | Context target | Skills load into your active context; subagents run in isolated contexts, returning summaries (Chapter 30) |
| CLAUDE.md vs. Skill | Loading trigger | CLAUDE.md loads on session start; Skills load on query match (Chapter 30) |
| Hook vs. Permission Rule | Enforcement scope | Hooks run custom scripts on events; permission rules allow/deny specific tools (Chapter 30) |
| Subagent vs. Agent Team | Interaction access | Subagents run inside a single session under parent control; Agent Teams span concurrent sessions you can query directly (Chapter 29) |
| Session vs. Turn | Granularity | A session is a chat history workspace; a turn is a single prompt-response cycle (Chapter 03) |
| Compaction vs. /clear | Memory preservation | Compaction summarizes logs to free memory; /clear wipes history to start a clean session (Chapter 19) |
| Permission Mode vs. Permission Rule | Precision | Permission mode is the global safety profile; permission rules are granular tool-argument filters (Chapter 20) |
| stdio vs. http (Transport) | Server location | stdio routes messages to local child processes; http connects to remote endpoints (Chapter 22) |
| CLAUDE.md vs. Auto-memory | Author | CLAUDE.md is compiled by you; auto-memory notes are compiled by the agent (Chapter 25) |
Understanding these distinctions optimizes tool selection—for example, delegating search tasks to subagents instead of writing them as Skills, which prevents context bloat from file reads.
08 Practice: Querying Terms via the Docs Server
To query live definition updates, use the official documentation MCP server configured in Chapter 22:
This remote HTTP server requires internet access.
Step 1: Add the documentation MCP server (in host shell)
claude mcp add --transport http claude-code-docs https://code.claude.com/docs/mcpStep 2: Verify connectivity
claude mcp listStep 3: Query a glossary definition inside the session
claudeQuery the claude-code-docs server to find the definitions for compaction and context window.
Provide a single sentence summary for each.Expected: Claude prompts you for tool authorization on first run (Chapter 20 permissions gate)—approve it. It returns the definitions, with the tool output tagged as claude-code-docs to indicate live queries.
Step 4: Cleanup (Optional)
claude mcp remove claude-code-docs09 Summary
This glossary acts as a quick-reference guide, triaged by thematic families:
| Family | Focus | Core Terms |
|---|---|---|
| Agentic Loop | How the autonomous engine runs | agentic loop, tool, harness, turn, extended thinking, effort level, verification loop |
| Context | Workspace memory and limits | context window, token, compaction, session, CLAUDE.md, auto-memory, rules, output style |
| Extensions | Custom modules and tools | skill, subagent, hook, command, plugin, marketplace |
| MCP | External protocol configurations | MCP, server, transport, scope, tool search |
| Security | Safety gates and rollbacks | permission mode, plan mode, auto mode, permission rules, sandboxing, prompt injection, checkpoints |
| Runtime | Interfaces and executions | surface, non-interactive (headless) mode, Agent SDK, web sandboxes, bare mode, worktree isolation, Remote Control |
You should now be able to: identify glossary terms, explain their core behavior and analogies, distinguish frequently confused pairs, and run live query lookups via the documentation MCP server. Keep this guide handy to check technical terms as you develop.
The core curriculum is complete—covering installations, optimizations, safety profiles, and terminologies.