Claude Code Glossary

Prefix to run shell commands directly without Claude's involvement, e.g., `! git status`. Output lands in the conversation.

Syntax to reference specific files in prompts, e.g., `@src/auth.tsx`. Claude loads that file into context immediately.

Project-level directory containing agents, skills, commands, hooks, rules, and settings. `settings.local.json` is gitignored by convention.

Project-level file for MCP server configuration, committed to the repo so the whole team shares the same server setup.

Slash command that resets the session entirely, discarding all conversation history. Context drops to 0%.

Slash command that compresses conversation context by summarizing prior exchanges, freeing up context headroom without losing state.

Practical effective context limit where output quality degrades, even when the nominal window is larger.

Slash command showing usage graph, cost breakdown, favorite model, and streak (v2.1.118). Replaces `/cost` and `/stats`, which become aliases.

Slash command that generates a structured session recap: summary of what was accomplished, decisions made, and next steps.

Slash command to undo the last file-level change Claude made in the current session.

Slash command to enable proactive suggestions mode: Claude surfaces issues it notices without being asked.

Slash command to switch to Terminal UI mode: structured interface for session navigation and file browsing.

Slash command to restrict Claude to a specific file or directory scope for the current session.

Slash command that triggers deep review mode: comprehensive multi-dimension analysis of code changes.

Slash command to reduce the frequency of permission prompts while maintaining security boundaries.

Slash command to set reasoning effort level: low | medium | high | xhigh. `xhigh` is Opus 4.7 only (v2.1.76+).

Assemble, Check, Execute: the three-phase lifecycle for intentional context management.

Normal execution mode where Claude can read, write, and run commands. Opposite of Plan Mode.

Opus 4.6 feature: dynamically adjusts reasoning depth based on detected task complexity, without manual configuration.

A specialized AI persona defined in a markdown file with a role, tool list, and behavioral instructions. Stored in `.claude/agents/`.

Experimental feature (v2.1.32+) enabling multi-agent coordination and messaging within a single Claude Code session.

Development style where AI agents perform multi-step tasks autonomously with minimal per-step human intervention.

Practices for documenting and disclosing AI involvement in code, commits, and content: git trailers, PR labels, audit logs.

Settings key providing fine-grained tool permission control: allow or deny individual tools or by argument pattern.

Boris Tane's workflow pattern: annotate a custom markdown plan with implementation notes before Claude executes, creating a living spec.

Explicit instructions requiring Claude to verify claims against actual code or documentation before stating them as fact.

Anthropic research finding (AI Fluency Index, 2026) that users who produce AI artifacts are less likely to question the reasoning behind them.

Permission mode (`acceptEdits`) that auto-approves file edits while still prompting for shell commands. Good middle ground for trusted sessions.

Built-in mechanism that automatically compresses conversation context (~75% threshold in VS Code extensions, ~95% in CLI). Triggered silently unless you use `/compact` first.

Feature (v2.1.32+) where Claude automatically stores learned project context into a persistent memory file across sessions.

Settings array listing tools that are auto-approved without interactive prompts. More granular than permission modes.

Community-curated list of Claude Code resources, tools, and examples with 20K+ stars on GitHub.

Business-driven, Methodical AI Development: a structured planning framework for agentic AI projects (community methodology).

Horizontal scaling approach: run multiple Claude Code instances in parallel, each on a git worktree, then merge. Named after Boris Cherny, creator of Claude Code and Head of Claude Code at Anthropic.

Maximum autonomy mode via `--dangerously-skip-permissions`: auto-approves all tools. Use only in isolated/sandboxed environments.

Skill type that teaches Claude a new capability it does not have natively, as opposed to enforcing a style preference.

Community CLI tool for tracking Claude Code token consumption, cost per session, and model breakdown.

Independent verifier pattern: a second agent re-checks the first agent's output to prevent confirmation bias. arXiv:2309.11495.

A saved session state that can be restored via Esc×2 → /rewind. Created automatically before risky operations.

Anthropic's fastest and cheapest model. Best for high-volume tasks, simple lookups, and cost-sensitive CI workflows.

Anthropic's most capable model. Best for deep reasoning, architecture decisions, and complex multi-step analysis.

Anthropic's balanced default model. Best mix of speed and capability for daily development work.

Persistent memory file loaded automatically at session start. Contains project rules, conventions, and context. The foundation of Claude Code configuration.

Git trailer convention (`Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>`) for attributing AI-assisted commits.

The growing gap between code an AI produces and the developer's actual understanding of what it does and why.

Three-tier precedence for CLAUDE.md: Local (`.claude/`, gitignored) > Project (committed) > Global (`~/.claude/CLAUDE.md`). More specific always wins over more general.

Anthropic's value framework (per published system prompt) defining Claude's priority order: safety > ethics > Anthropic principles > user utility.

The finite token allocation that must be distributed across instructions, code, conversation history, and tool results in a single session.

The discipline of intentionally designing what goes into an AI model's context window to maximize output quality.

Framework measuring how well a team's context engineering practices have evolved, from ad-hoc prompts to measured pipelines.

Technique of densely encoding information (structured markdown, symbols, tables) to maximize useful signal per token.

The gradual degradation of Claude's situational awareness in long-running sessions as relevant context gets pushed out or buried.

The deliberate decision about what information is worth putting in context upfront vs. loading on demand via tools.

Total amount of text (in tokens) Claude can process in a single session. Claude Sonnet 4.6: 200K; extended API: 1M.

Keyboard shortcut to background a running task, keeping it alive while you continue other work in the session.

Reliability pattern that transitions between CLOSED (normal), OPEN (failing), and HALF_OPEN (probing) states to prevent cascading failures in multi-agent pipelines. Each document or task gets its own instance to isolate failures.

Process of aligning a model's stated confidence scores to actual accuracy rates using labeled validation sets. Platt scaling maps raw logit-derived scores to calibrated probabilities for structured extraction tasks.

Metadata attached to extracted fields or generated content indicating evidential support: `well-supported`, `partially-supported`, or `gap`. Prevents silent omissions from appearing as complete answers.

Flag that bypasses Claude Code's native OS-level sandboxing. Should only be used in already-isolated environments.

Base permission mode requiring explicit user approval for all file edits, shell commands, and commits.

Community tool (@peteromallet, Feb 2026) that installs a workflow skill into Claude Code and runs a scan→fix→score loop to raise code quality.

Testing strategy that runs `git diff --name-only` first to identify routes affected by a change, then focuses QA testing on those pages before broader coverage. Part of the `/qa` command workflow.

The practice of reading Claude's proposed file changes before accepting or rejecting. One of the Five Golden Rules.

Settings key that blocks specific tools from being invoked in a session or globally.

Container-based isolation for running Claude Code with strict resource and filesystem limits.

Permission mode (`dontAsk`) that silently denies tools not in the pre-approved list, without prompting.

Pattern by Jon Williams: one Claude instance creates a detailed plan, a separate instance executes it: preventing context contamination.

Skill type that enforces specific conventions, style choices, or constraints Claude would not apply by default.

Org-level policies for AI tool usage: usage charter, MCP server registry, guardrail tiers, and audit trail.

Testing framework for systematically measuring agent behavior, output quality, and skill effectiveness against defined criteria.

Pattern where external events (Linear tickets, GitHub PRs, Jira webhooks) automatically trigger Claude Code agent workflows.

Model feature enabling deeper reasoning via dedicated "thinking tokens" processed before the visible response. Activated with `--thinking`.

Three canonical signals that should route a task to a human: explicit user request, policy gap (no defined procedure exists), and inability to progress after exhausting available attempts. Frustration signals are not escalation triggers.

Mode (v2.1.36+) running 2.5x faster at 6x the token cost, on the same underlying model. Toggle with `/fast`.

Find, Isolate, Remediate, Evaluate: DevOps/SRE troubleshooting methodology for incident response with Claude Code.

Review pattern distinguishing AUTO-FIX (mechanical issues a senior engineer would fix without discussion: dead code, N+1, stale comments, magic numbers) from ASK (judgment calls: security vulnerabilities, race conditions, design decisions, changes >20 lines). Part of the enhanced `/review-pr` workflow.

Deliberately starting a new session when the current one has accumulated irrelevant context or its output quality has degraded.

Technique providing 2-4 input/output examples in the prompt to steer format, tone, or tool use patterns. Effective for calibrating false-positive rates and output style; not a substitute for instruction compliance on safety or security constraints.

Official MCP server for the Claude Code Ultimate Guide. Install with `npx -y claude-code-ultimate-guide-mcp`. Provides 9 tools: search, digest, cheatsheet, templates, release notes: query the guide directly from inside Claude Code without cloning the repo.

Steve Yegge's multi-agent workspace manager for running multiple coordinated Claude Code instances with a shared task queue.

Git feature creating parallel working directories from the same repo. Used for multi-instance Claude Code workflows without branch switching.

Pragmatic, outcome-focused development methodology: ship fast, validate with real usage, iterate based on feedback.

Garry Tan's 6-skill workflow suite: strategic gate + architecture review + code review + release notes + browser QA + retrospective.

Four enterprise security enforcement levels: Starter (awareness), Standard (review gates), Strict (approval flows), Regulated (full audit).

When an AI model generates plausible-sounding but factually incorrect information, often with high apparent confidence.

An automation script triggered by Claude Code lifecycle events. Defined in `settings.json`. Runs synchronously before or after tool execution.

Four execution types: `command` (shell script), `http` (POST webhook), `prompt` (single-turn LLM call), `agent` (full multi-turn sub-agent).

Orchestration pattern where a coordinator agent decomposes tasks, dispatches to specialized workers, aggregates results, and drives refinement cycles, without performing domain work itself. Enables parallel execution and isolates concerns.

Core principle of the `/investigate` command: NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST. Prevents applying patches that mask symptoms without understanding why they occurred, which leads to recurring bugs and compounding technical debt.

Open-source secrets manager used for injecting credentials into Claude Code sessions without storing them in CLAUDE.md or env files.

Session history stored as JSON Lines files in `~/.claude/projects/`. Can be searched, replayed, and analyzed programmatically.

Standard file format (placed at site root) for AI-optimized documentation. Claude Code reads `llms.txt` files from project roots.

Security-focused review category for AI-generated code. Checks that LLM-generated values are not written to a database without format validation, and that structured tool output is not accepted without type/shape checks. Part of the enhanced `/review-pr` Defensive Code Auditor agent.

Attention phenomenon (Liu et al. 2023, arXiv:2307.03172) where models show degraded recall for information in the middle of long contexts. U-shaped performance curve: primacy and recency positions show 27-98% accuracy vs 27% for middle positions.

Claude Code's core execution cycle: receive input → select tools → execute → observe results → respond. Repeats until task complete.

Open protocol developed by Anthropic for connecting AI models to external tools, databases, and APIs in a standardized way.

Pattern of layering multiple Claude Code mechanisms (Plan Mode + extended thinking + MCP) for maximum reasoning on critical decisions.

Three-tier CLAUDE.md precedence: Local > Project > Global. Each level extends the one below and can override it for its own scope.

Shorthand names that resolve to current model versions: `default`, `sonnet`, `opus`, `haiku`, `sonnet[1m]`, `opusplan`. Opus 4.7 is the most powerful (claude-opus-4-7), with xhigh effort for maximum reasoning.

Pattern of splitting CLAUDE.md into focused modules loaded dynamically via path-scoped rules, reducing per-session token overhead.

Community self-hosted multi-agent spawner using tmux + git worktrees. Runs N Claude Code instances in parallel.

Agentic loop parameter capping tool-use cycles before halting. Recommended ranges: 5 (simple tasks), 20-30 (research workflows), 50+ (extended pipelines). Check `stop_reason == "max_turns"` after each loop to detect premature halts.

Anthropic API endpoint for submitting up to 100 requests in a single batch at 50% cost reduction. Processes asynchronously within 24 hours via poll-and-retrieve. Incompatible with multi-turn tool use and streaming.

Claude Code's built-in OS-level sandboxing: Seatbelt on macOS, bubblewrap on Linux. Limits filesystem and network access.

Schema pattern (`{"type": ["string", "null"]}`) that forces a model to explicitly emit `null` for absent values instead of hallucinating a plausible default. Required for reliable structured extraction across diverse document types.

Most powerful Claude model (claude-opus-4-7). Supports xhigh effort for maximum reasoning budget. Default high thinking on Pro/Max plans (v2.1.117).

Hybrid mode: Opus 4.7 (or 4.6) handles planning (with thinking), Sonnet executes. Activates with `/model opusplan`.

Agent role responsible for decomposing a high-level goal into subtasks, dispatching them to worker agents, and aggregating results. Does not execute domain work directly. Distinct from the workers it coordinates.

Tool that distributes coding standards as `CLAUDE.md` files, slash commands, and skills across repositories and AI tools (Claude Code, Cursor, Copilot).

Five autonomy levels: Default, Auto-accept, Plan, Don't Ask, Bypass Permissions. Set per session or in `settings.json`.

Read-only mode where Claude can analyze, search, and propose but cannot modify files. Activated with Shift+Tab or `/plan`.

A distributable package bundling agents, skills, commands, and hooks under a `plugin.json` manifest. Installable from the marketplace.

Hook event fired after a tool completes execution. Used for post-processing, formatting, validation, and logging.

Hook event fired before Claude executes a tool. Can block, allow, or modify the tool call based on arguments.

Attack where malicious text in files or external inputs attempts to override Claude's instructions or exfiltrate information.

A verbatim prompt section (max 500 tokens) containing stable facts that must be preserved exactly across context refreshes. Positioned at the start for primacy advantage; compatible with prompt caching for zero cost on repeated calls.

API feature that caches the static prefix of a prompt across calls, reducing latency and cost for repeated prefixes. Marked with `cache_control: {"type": "ephemeral"}`. Cache TTL: 5 minutes. Significant savings on long system prompts.

Also "Ralph Wiggum Loop" (Geoffrey Huntley). Iterative refinement cycle: generate → review → correct → repeat, until output meets quality bar.

Three levels of undo: reject change inline, /rewind to session checkpoint, `git restore` as nuclear reset.

Pattern of running multiple rounds of deep analysis and planning before executing, to surface edge cases and failure modes early.

Claude Code's undo mechanism. Reverts file changes and/or conversation state to a prior checkpoint. Trigger: Esc×2.

CLI proxy that reduces token consumption 60-90% by filtering and compressing command output before it reaches Claude.

Auto-loaded markdown files providing always-on instructions. Loaded at every session start, independent of which skills are active.

Cloud automation feature (April 14, 2026): schedule recurring agents to run on a defined interval without requiring an active local session. Think cron jobs for Claude Code.

Context management strategy that compresses conversation history when a session reaches a trigger threshold (typically 65% capacity). Preserves factual decisions and open questions; discards exhausted threads before starting the next iteration.

Community plugin implementing Chain-of-Verification with independent review agents for automated output validation. Based on Meta's CoVe research (arXiv:2309.11495).

When a PR or session modifies files outside the intent stated in the plan. Detected by cross-referencing `~/.claude/plans/` plan file against `git diff --stat`. The enhanced `/review-pr` command flags scope drift automatically.

Named reference patterns in CLAUDE.md (e.g., `## Architecture`) that Claude reliably finds and follows across sessions.

A single Claude Code conversation with its own context window, history, checkpoints, and tool state.

Manually starting a new session and passing a summarized context document from an exhausted or degraded previous session.

Hook events fired when a session begins or closes. Used for setup scripts, logging, and cleanup automation.

Keyboard shortcut to toggle between Plan Mode and Act Mode.

A minimal but fully working project template generated by Claude to establish architecture patterns before full implementation begins.

A reusable knowledge module (folder + SKILL.md entry point) providing domain expertise or behavioral instructions on demand.

Automated evaluation criteria that measure skill quality, invocation reliability, and output consistency. Part of Skills 2.0.

Evolution of the skills system introducing Capability Uplift types, Encoded Preference types, evals, and lifecycle management.

Custom commands defined as markdown files in `.claude/commands/`, invoked with `/command-name`. Support `$ARGUMENTS` substitution.

Unwanted, unreviewed AI-generated content: the AI equivalent of spam. Term coined by Simon Willison in May 2024.

Community remapping of OpusPlan: Sonnet handles planning, Haiku handles execution. Cheaper than OpusPlan for lighter tasks.

Addy Osmani's pattern: write a detailed specification document before any implementation begins. Reduces scope creep and clarifies edge cases.

Hook event fired when Claude is about to stop responding. Used for quality gates, cleanup tasks, and completion notifications.

Pre-implementation product review step in the gstack workflow. Ensures the feature is worth building before any code is written.

A child Claude instance spawned by the main session to handle a delegated task in isolation, with its own context.

Exploiting trusted dependencies (MCP servers, plugins, community skills) to inject malicious behavior or exfiltrate data.

Using a synthetic assistant turn containing a JSON state object as working memory for an agentic loop. The model reads and updates the scratchpad each iteration, maintaining continuity across turns without relying on conversation history alone.

Reliability bias (15-30% self-preference rate) where a model generating content and then reviewing it tends to favor its own output regardless of quality. Mitigated by using a separate review instance with no access to the generation context.

Four-criteria test for agentic task decomposition quality: Specific (single action), Programmatically Evaluable (verifiable output), Explicit scope (named files or tables), Constrained (has acceptance criteria). Tasks failing any criterion are too broad for reliable autonomous execution.

Field in the Anthropic API response indicating why generation stopped: `end_turn` (natural completion), `max_tokens` (limit hit), `tool_use` (tool call initiated), `max_turns` (agentic loop cap), `stop_sequence` (triggered sequence matched).

Anthropic API beta feature (`anthropic-beta: output-schema-2025-02-19`) using constrained decoding to guarantee JSON output matches a provided schema. Guarantees schema conformance; does not guarantee semantic accuracy or field-level correctness.

Built-in task management system (v2.1.16+) with dependency tracking, status management, and cross-session persistence. Replaces TodoWrite.

Decision framework: patterns in >20% of sessions → CLAUDE.md rules; 5-20% → skills; <5% → commands.

Vercel engineering blog finding (Gao, 2026) that agents invoke on-demand skills only 56% of the time, defaulting to native knowledge instead.

Addy Osmani's observation: AI reliably handles 80% of a task; the remaining 20% is where human expertise and judgment determine success.

Core advanced pattern combining Plan Mode + Extended Thinking + Sequential MCP for maximum reasoning depth on critical decisions.

Internal reasoning tokens consumed during extended thinking. Not visible in Claude's response but counted toward the context budget.

The basic unit of text that language models process. Roughly 3/4 of an English word, or ~4 characters. 1K tokens ≈ 750 words.

Minimizing token consumption while maintaining output quality. Key for cost management, context headroom, and session longevity.

Attack where a malicious MCP server registers tools with names matching Claude Code's built-in tools to intercept or hijack calls.

Permission pattern blocking a tool based on argument values, e.g., `Read(file_path:*.env*)` to prevent reading secrets files.

Canary monitoring principle: only alert on errors or regressions that persist across 2+ consecutive checks. Avoids false positives from one-off network glitches or cold-start delays. Core to the `/canary` command logic.

Framework for matching verification effort to the actual risk level of AI-generated code: avoiding both blind acceptance and paranoid review.

Anthropic API parameter controlling tool invocation: `auto` (model decides), `any` (must invoke a tool), `{"type": "tool", "name": "X"}` (force a specific tool), `none` (disable all tools). The forced-tool pattern is the standard approach for guaranteed structured output.

Hook event fired when the user submits a prompt, before Claude begins processing. Used for prompt enrichment, logging, and validation.

The accumulated risk of AI-generated code that was not reviewed at the time of creation, compounding over successive sessions.

The tension between needing rigorous verification of AI code while increasingly relying on AI tools to perform the verification.

A task scoped to one user-facing behavior, crossing all architectural layers (UI → API → DB). Preferred unit for AI-assisted implementation.

Style of development where you describe high-level intent and iterate rapidly on AI output, prioritizing shipping speed over precision.

Intermediate verification layer between blind acceptance and full line-by-line review. Faster for low-risk changes, still catches obvious issues.

Community plugin for codebase hotspot detection via a combined score of git churn × complexity × module coupling centrality.

Pattern for structured extraction failures: submit a 3-part feedback payload containing the original document, the failed JSON, and a per-field error list. Budget 3 attempts before escalating to human review or returning a degraded partial result.

Structured prompt format: what to do, where in the codebase, how to approach it, how to verify success. Reduces ambiguity in agentic tasks.

Maximum reasoning budget level for Opus 4.7 (claude-opus-4-7). Set via `/effort xhigh` or API. Provides the deepest analysis for critical decisions.