Plain English definitions for every Claude Code term — CLAUDE.md, hooks, subagents, MCP, tokens, and more. The only glossary you need.
Claude Code
An AI assistant you run in your terminal that reads, writes, and edits code on your computer — without you ever copying and pasting.
Think of it like hiring a very fast junior developer who lives inside your command line. You describe what you want in plain English, and it goes off to actually open files, write code, run tests, and fix bugs — all on its own. You stay in charge; it does the legwork.
Beginners encounter this term the moment they start learning about AI-powered coding tools. It’s the name of the whole product, so everything else in this glossary builds on top of it.
Example:
You type: “Add a dark mode toggle to my React app” — and the assistant finds the right files, writes the CSS, updates the component, and tells you exactly what it changed.
Related terms: Agentic Coding, Claude Code CLI, CLAUDE.md
Learn more: What Is Claude Code? A Beginner’s Guide →
CLAUDE.md
A plain-text file you put in your project folder to tell the AI assistant how your project works and what rules to follow.
Imagine leaving a sticky note for a new contractor before they arrive: “We use tabs not spaces, always write tests, and never touch the legacy/ folder.” This file is that sticky note — except the assistant actually reads and follows it every single time it starts working on your project.
You’ll encounter this once you want to stop re-explaining your preferences every session. It’s one of the first “power user” moves beginners make, and it pays off immediately.
Example:
# CLAUDE.md
## Project Rules
- Use TypeScript, never plain JavaScript
- Always write a test for every function you create
- Never edit files inside /vendor/
- Run `npm test` after every change
Related terms: SKILL.md, Context Window, Claude Code
Learn more: What Is CLAUDE.md and How Do You Use It? →
Context Window
The maximum amount of text — your instructions, the conversation, and your code files — that the AI can hold in its head at one time.
Picture a whiteboard in a meeting room. You can only write so much before the board is full and you have to erase something to make room. The AI’s memory works the same way: once the whiteboard fills up, older information gets pushed off. If your codebase is huge or your session has been running a long time, you might hit this limit.
Beginners run into this when working on large projects and notice the assistant starting to “forget” things it knew earlier. Understanding this limit helps you plan when to start fresh sessions and how much to include in your CLAUDE.md.
Example:
You’re refactoring a big app and the assistant suddenly seems to forget the coding rules you set at the start of the session — that’s the context window filling up and older instructions getting pushed out.
Related terms: Token, CLAUDE.md, context:fork
Learn more: Tokens and Context Windows Explained →
Token
A small chunk of text — roughly a word or part of a word — that the AI uses as its basic unit of reading and writing.
The AI doesn’t read letter-by-letter or word-by-word the way you do. Instead it breaks everything into small puzzle pieces called tokens. The word “running” might be one token; “unbelievable” might be two. Think of them like the individual LEGO bricks that text gets snapped into before the AI can process it.
You’ll hear this term when people talk about how much something costs (AI pricing is measured in tokens) or how much fits in a context window (measured in tokens too). As a beginner you don’t need to count them manually — just know that longer conversations and bigger files use more tokens.
Example:
The sentence “Hello, world!” is roughly 4 tokens. A 500-line JavaScript file might be 3,000–4,000 tokens. Most AI models handle 100,000+ tokens in a single session.
Related terms: Context Window, CLAUDE.md, Subagent
Learn more: Tokens and Context Windows Explained →
Slash Command
A shortcut you type starting with “/” that triggers a saved set of instructions, so you don’t have to type the same long prompt over and over.
Think of slash commands like keyboard shortcuts for your most-used prompts. Instead of typing “Please review my code for security issues, check for SQL injection, verify all inputs are sanitised, and output a bullet-point report” every time, you just type /security-check and the whole instruction fires automatically.
Beginners discover these once they find themselves repeating the same kinds of requests. They’re stored as markdown files in your .claude/commands/ folder and are one of the fastest ways to speed up your workflow.
Example:
# Instead of typing this every time:
"Write tests for this function using Jest, cover edge cases,
aim for 90% coverage, and name tests descriptively."
# You just type:
/write-tests
Related terms: Skill, SKILL.md, CLAUDE.md
Learn more: What Are Slash Commands in Claude Code? →
Skill
A saved set of instructions that teaches the AI a specific way to do a particular type of task — like a recipe it can follow on demand.
A skill is like training a new employee with a detailed how-to guide for one specific job. Once you’ve written the guide (the skill), they can follow it perfectly every time without you having to explain it again. You might have a skill for “writing database migrations,” another for “reviewing pull requests,” and another for “generating API documentation.”
Beginners encounter skills when they want consistent, repeatable results on tasks they do regularly. Skills are more detailed than slash commands — they describe a full workflow, not just a single prompt.
Example:
You create a “code-review” skill that instructs the AI to always check for security issues first, then performance, then style — in that exact order, with a specific output format. Every code review now follows the same thorough process.
Related terms: SKILL.md, Slash Command, CLAUDE.md
Learn more: What Are Skills in Claude Code? →
SKILL.md
The actual text file where you write down the instructions for a skill — it’s the recipe card that a skill is made of.
If a Skill is the recipe, then SKILL.md is the physical recipe card you write it on. It’s a plain markdown file that lives in a specific folder and contains step-by-step instructions telling the AI exactly how to perform a particular task. The AI reads it when that skill is activated and follows it to the letter.
Beginners create their first SKILL.md once they want to customise how the AI works on specific tasks. The format is simple markdown — just headers, bullet points, and plain instructions — so you don’t need to know how to code to write one.
Example:
# File: ~/.claude/skills/database-migration/SKILL.md
## When to use this skill
When the user asks to create a new database migration.
## Steps to follow
1. Ask for the table name and the changes needed
2. Generate the UP migration SQL
3. Generate the DOWN (rollback) migration SQL
4. Add a timestamp prefix to the filename
Related terms: Skill, Slash Command, CLAUDE.md
Learn more: How to Create a Skill in Claude Code →
Hook
An automatic action that runs whenever something specific happens during a session — like a tripwire that fires your own code at the right moment.
Imagine you’ve set up a security camera that automatically turns on a light whenever someone walks past. You don’t have to press anything — it just happens. Hooks work the same way: you define “when X happens, automatically do Y” and the system handles the rest. For example: “whenever a file is saved, automatically run the linter.”
Beginners encounter hooks once they want to automate repetitive quality checks or safety rules. They’re one of the more advanced features, but even a simple hook can save hours of manual checking over time.
Example:
You set up a hook so that every time the AI tries to write to a file, your hook first checks whether that file is in a protected folder. If it is, the hook blocks the action automatically — no manual supervision needed.
Related terms: PreToolUse, PostToolUse, Stop Hook
Learn more: What Are Hooks in Claude Code? →
PreToolUse
A type of hook that runs your code before the AI uses a tool — giving you a chance to check, block, or modify the action before it happens.
Think of it like a bouncer at a club who checks IDs before letting anyone in. A PreToolUse hook intercepts the AI right before it’s about to do something — read a file, run a command, search the web — and runs your check first. Your code can say “yes, go ahead,” “no, stop,” or even “change this before you do it.”
Beginners use PreToolUse hooks when they want guardrails on what the AI is allowed to do. Common uses include blocking access to production databases, preventing edits to certain folders, or logging every action for review.
Example:
# This PreToolUse hook blocks any bash command
# that contains "rm -rf" before it runs
if "rm -rf" in tool_input["command"]:
block("Deletion commands require manual approval")
Related terms: Hook, PostToolUse, Stop Hook
Learn more: PreToolUse Hooks Explained →
PostToolUse
A type of hook that runs your code after the AI has used a tool — so you can inspect the result, log it, or trigger a follow-up action.
If PreToolUse is the bouncer checking people coming in, PostToolUse is the security camera watching what happens after they enter. The action has already occurred — a file was written, a command was run — and now your hook gets a chance to see the result, record it, or kick off another process in response.
Beginners use PostToolUse hooks for things like automatic formatting after a file is written, sending a Slack notification when a task finishes, or logging every file change to a changelog automatically.
Example:
Every time the AI writes a Python file, your PostToolUse hook automatically runs black to format the code — so every file saved is always perfectly styled without you having to ask.
Related terms: Hook, PreToolUse, Stop Hook
Learn more: PostToolUse Hooks Explained →
Stop Hook
A type of hook that runs when the AI finishes a task — letting you do cleanup, send notifications, or decide whether the session should actually end.
Think of it as the closing ceremony at the end of a shift. When the AI thinks it’s done and is about to hand back control to you, a Stop Hook fires first. You can use that moment to run final checks, save a summary of what happened, send yourself a text, or even tell the AI “actually, you’re not done — go fix this one more thing.”
Beginners find Stop Hooks useful for end-of-session reporting and quality checks. For example, you can make sure tests always pass before the AI declares itself finished, rather than having to check manually.
Example:
You configure a Stop Hook that runs your test suite when the AI finishes a coding task. If any tests fail, the hook sends the failures back to the AI with the message “Tests are failing — please fix before finishing.”
Related terms: Hook, PreToolUse, PostToolUse
Learn more: Stop Hooks Explained →
Subagent
A separate AI helper that the main AI can spin up and give a specific job to — like a manager delegating work to an assistant.
Imagine you’re a project manager and you need to simultaneously write documentation, update the database schema, and refactor the API layer. Instead of doing all three yourself, you hire three specialists and give each one a focused job. Subagents are exactly that — the main AI can create smaller helpers, each with a specific task and its own fresh working memory, and run them in parallel.
Beginners encounter subagents when working on complex projects that benefit from parallelism or specialisation. They’re particularly useful for large codebases where different parts of the task need independent focus without polluting each other’s context.
Example:
You ask the AI to “audit my entire codebase for security issues.” Rather than reading every file sequentially, it spins up multiple subagents — one per module — each scanning a section at once, then reports all findings back to you together.
Related terms: context:fork, Context Window, Agentic Coding
Learn more: What Are Subagents in Claude Code? →
context:fork
A way to create a fresh copy of the current conversation and give it to a subagent, so the helper starts with everything already known but works independently.
Picture making a photocopy of a whiteboard before erasing it and starting a new drawing. A fork duplicates the current conversation state — all the files read, all the decisions made so far — and hands that copy to a subagent as its starting point. The subagent can then work on its task without interfering with the main session.
Beginners encounter context:fork when using advanced subagent workflows. It solves the problem of “how does the helper know what the main AI already figured out?” — the answer is: it gets a copy of the whole memory up to that point.
Example:
The main AI has spent 30 minutes understanding your codebase. Instead of making a subagent start from scratch, context:fork hands the subagent a snapshot of everything learned so far — it inherits the knowledge and gets straight to work.
Related terms: Subagent, Context Window, Agentic Coding
Learn more: context:fork Explained →
MCP (Model Context Protocol)
A standard way for the AI to connect to outside tools and services — like a universal plug socket that lets it talk to GitHub, Slack, databases, and more.
Out of the box, the AI can only read and write files on your computer. MCP is the system that lets it reach out to the wider world. Think of it like a USB standard: because everyone uses the same plug shape, any device from any manufacturer can connect to your laptop. MCP works the same way — tool builders follow one standard, and then the AI can connect to all of them.
Beginners encounter MCP when they want the AI to do things like create a GitHub issue, query a database, check a Slack message, or look something up in Notion. You don’t need to understand the protocol itself — you just need to know it’s what makes those connections possible.
Example:
You connect a GitHub MCP Server and tell the AI: “Create a pull request for the changes you just made.” Because of MCP, it can talk to GitHub’s API directly and open the PR — no copy-pasting, no browser switching.
Related terms: MCP Server, MCP Registry, Claude Code
Learn more: What Is MCP (Model Context Protocol)? →
MCP Server
A small program that acts as a bridge between the AI and one specific external service — like an interpreter who translates between two people who speak different languages.
Each MCP Server handles one connection: there’s a GitHub MCP Server for GitHub, a Supabase MCP Server for Supabase, a Slack MCP Server for Slack, and so on. The server knows how to talk to that service and translates the AI’s requests into something the service understands. You add a server once, and from then on the AI can use that service freely.
Beginners set up their first MCP Server when they want to extend what the AI can do beyond the local file system. The setup is usually just one command in your terminal, and many popular services already have servers ready to install.
Example:
# Add the GitHub MCP Server with one command:
claude mcp add github -- npx -y @modelcontextprotocol/server-github
# Now you can say:
"List my open pull requests" # AI talks to GitHub directly
Related terms: MCP, MCP Registry, Context Window
Learn more: How to Add an MCP Server to Claude Code →
MCP Registry
A searchable directory of all available MCP Servers — like an app store where you browse and find plugins to connect the AI to different tools.
Before the registry existed, finding an MCP Server meant digging through GitHub repos and hoping someone had built one for the tool you wanted. The registry is a curated, searchable catalogue of ready-to-install servers — you search for the service you need, find the server, and follow the install steps. Much easier.
Beginners head to the registry when they want to connect the AI to a new tool and aren’t sure if a server exists for it yet. It’s usually the first place to check before building your own.
Example:
You want to connect the AI to your Notion workspace. You search “Notion” in the MCP Registry, find the official Notion MCP Server, copy the install command, paste it in your terminal, and you’re done — the AI can now read and write your Notion pages.
Related terms: MCP, MCP Server, Claude Code
Learn more: The MCP Registry — How to Find and Install Servers →
Plan Mode
A setting that makes the AI stop and show you its full step-by-step plan before doing anything — so you can approve, edit, or redirect it first.
Think of it like a surgeon explaining exactly what they’re going to do before making the first cut. In Plan Mode, the AI reads your request, figures out all the steps it would take, and presents that plan to you in writing. Nothing actually happens until you say go. This gives you a chance to catch misunderstandings before any files are touched.
Beginners should use Plan Mode whenever they’re working on anything important or unfamiliar. It’s especially useful for big refactors, migrations, or anytime the AI might be interpreting your request differently than you intended.
Example:
You ask: “Migrate my app from PostgreSQL to MySQL.” In Plan Mode, the AI responds with: “Here’s what I’ll do: 1) audit all SQL queries, 2) convert syntax differences, 3) update the connection config, 4) update the ORM models.” You review and say “looks good, go ahead” — only then does it start.
Related terms: Auto Plan Mode, Agentic Coding, Claude Code
Learn more: Plan Mode in Claude Code Explained →
Auto Plan Mode
A setting that automatically triggers planning before any large or complex task — so the AI decides when to pause and check with you, rather than you having to remember to ask.
Regular Plan Mode only kicks in when you manually switch it on. Auto Plan Mode is smarter — it watches what you’re asking for and automatically inserts a planning step whenever the task looks big enough to warrant one. Think of it as cruise control versus manually pressing the brakes: you set the preference once, and the system handles the judgement calls.
Beginners who forget to turn on Plan Mode for complex tasks will appreciate Auto Plan Mode as a safety net. It reduces the chance of the AI running off and making large changes you didn’t fully intend.
Example:
You ask for a quick one-line fix — the AI just does it. You ask to “restructure the entire authentication system” — Auto Plan Mode automatically kicks in, produces a plan, and waits for your go-ahead before touching anything.
Related terms: Plan Mode, Agentic Coding, Hook
Learn more: Claude Code Modes Explained →
Agentic Coding
A style of programming where you give an AI a goal and it independently figures out the steps, takes actions, and completes the work — with minimal hand-holding from you.
Traditional AI coding assistants are like autocomplete on steroids — they suggest the next line and you accept or reject it. Agentic coding is completely different: it’s like handing a competent contractor the keys to the building and saying “fix the plumbing” — they figure out what that means, buy the parts, do the work, and hand you the result. The AI acts autonomously across multiple steps rather than waiting for your approval at each one.
This is the core idea behind the whole product. Everything else in this glossary — hooks, subagents, Plan Mode, MCP — exists to make agentic coding more powerful, more safe, and more controllable for beginners.
Example:
Old way: you ask for a function, review it, ask for a test, review it, ask for docs, review them — dozens of back-and-forths. Agentic way: you say “build a user authentication system with tests and docs” and the AI figures out all the steps, does them in the right order, and delivers the finished result.
Related terms: Claude Code, Subagent, Plan Mode, Vibe Coding
Learn more: What Is Claude Code? A Beginner’s Guide →
Vibe Coding
A casual, fast-moving style of building software where you describe what you want in natural language and let the AI figure out all the technical details.
The name captures the feeling perfectly: you’re not grinding through syntax and documentation, you’re just… vibing. You describe the thing you want (“make it so users can log in with Google”), the AI handles the how, and you keep the creative momentum going. It’s less about writing code and more about directing a build — like being a film director rather than the camera operator.
Beginners often discover vibe coding first, before they learn all the structured tools in this glossary. It’s the easiest entry point into AI-assisted development — just describe what you want and see what happens. The rest of these terms exist to help you vibe more effectively and with more control.
Example:
Instead of writing a React component from scratch and looking up the useState docs, you type: “Add a live search bar to the top of my product list page that filters as the user types.” The AI builds it. You look at it, say “make it a bit faster and add a clear button,” and it updates. No syntax, just direction.
Related terms: Agentic Coding, Plan Mode, Claude Code, Slash Command
Learn more: Vibe Coding with Claude Code →