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.

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.

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.

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`.

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.

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

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).

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.

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`.

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.

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

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

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.

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.

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

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.

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.

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

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.

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