Claude Code Explained — Every Feature, Every Use Case

Claude Code has grown from a simple terminal chatbot into a full agentic development environment — slash commands, permission modes, MCP integrations, recurring automation, subagents, hooks, and persistent memory. This guide explains every major feature, what it's actually for, and when engineers reach for it.

What Is Claude Code?

Claude Code is Anthropic's official agentic coding tool. Unlike a typical chat assistant, it can directly read, write, and edit files, run shell commands, search the web, and orchestrate multi-step engineering tasks — all inside your actual project, under permission controls you configure. It runs as a CLI in the terminal, as IDE extensions (VS Code, JetBrains), as a desktop app, and as a web app.

The feature set below is organized the way engineers actually encounter it: commands you type, modes that control autonomy, integrations that extend its reach, and background systems (memory, hooks) that make it behave consistently across sessions.

Slash Commands — The Command Palette

Slash commands are typed directly into the prompt and trigger a specific action instead of a normal conversational turn. Here are the ones engineers use daily:

Custom slash commands are just Markdown files with optional frontmatter, stored in .claude/commands/ (project) or ~/.claude/commands/ (personal) — any team can define its own without writing code.

Permission Modes — Controlling Autonomy

Every action Claude Code takes — editing a file, running a command, pushing to git — is filtered through a permission mode. This is the single most important safety lever in the tool.

A project's CLAUDE.md file can pre-authorize specific categories of actions (e.g. "always commit and push without asking"), which is how teams run Claude Code close to fully autonomously on a given repo while still keeping a written record of what was pre-approved.

MCP — Model Context Protocol

MCP is an open standard that lets Claude Code talk to external tools and data sources through one consistent interface, instead of Anthropic building a custom integration for every possible service.

claude mcp add github --url https://mcp.github.com
claude mcp add postgres --command "npx @modelcontextprotocol/server-postgres"
claude mcp list

Common MCP servers connect Claude Code to:

• GitHub / GitLab — read issues, review PRs, manage repos directly
• Slack — post updates or read channel context
• Databases (Postgres, MySQL) — query schema and data safely
• Figma / Linear / Notion — pull design specs or ticket context into the coding session
• Custom internal APIs — any company-specific tool exposed as an MCP server

Because MCP is an open protocol, any team can write a server for their own internal systems and Claude Code will use it the same way it uses an official one.

/loop — Recurring Automation

/loop repeats a prompt or slash command on an interval — either a fixed cadence you specify, or a self-paced schedule the model chooses based on what it's waiting for.

/loop 5m /babysit-prs
/loop /check-deploy-status   (model self-paces the interval)

Typical uses: polling a CI pipeline until it finishes, checking for new pull-request comments, or running a recurring maintenance routine (e.g. a nightly dependency audit) without a human re-triggering it each time.

Subagents — Delegating Work

Subagents are specialized agents Claude Code can spawn mid-task, each with its own context window and its own tool access. This keeps large investigations from bloating the main conversation's context.

Subagents can run in the foreground (you wait for the result before continuing) or background (you keep working, and get notified when it finishes) — useful for parallelizing independent research or long-running builds.

Hooks — Automating Reactions to Events

Hooks run a command automatically at specific points in Claude Code's lifecycle — before or after a tool call, when a session starts, or when Claude finishes a turn.

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Write|Edit",
      "hooks": [{ "type": "command", "command": "prettier --write \"$FILE\"" }]
    }]
  }
}

Common hook use cases: auto-formatting code after every edit, logging every shell command Claude runs, blocking a specific dangerous command pattern outright, or running the test suite automatically after a change.

Memory — Persistent Context Across Sessions

Claude Code can maintain a file-based memory system that persists across separate conversations — remembering user preferences, past feedback, and ongoing project context so you don't have to re-explain them every session.

• User memory — your role, expertise, and how you like to work
• Feedback memory — corrections and confirmed approaches from past sessions
• Project memory — ongoing goals, deadlines, and decisions specific to this codebase
• Reference memory — pointers to where information lives in external systems (a Linear project, a Slack channel)

This is distinct from CLAUDE.md, which is checked into the repo and read by every contributor's Claude Code session — memory is personal and persists for one user across their own sessions.

Skills — Reusable Specialized Capabilities

Skills package specialized knowledge or workflows that Claude invokes by name — for example a data-visualization skill that enforces consistent chart design, or a code-review skill with a structured findings format. Skills can be built-in, project-specific, or installed from a plugin marketplace.

Artifacts — Shareable Web Output

Instead of dumping HTML into the chat, Claude Code can render a page as an Artifact — a hosted, shareable web view (dashboards, reports, diagrams, small tools). Each redeploy updates the same URL, so it behaves like a lightweight, disposable web app rather than a one-off file.

Workflows — Multi-Agent Orchestration

Workflows (sometimes triggered with the keyword "ultracode") coordinate multiple agents and a higher reasoning effort automatically for large, ambiguous tasks — planning, delegating, and merging work across subagents without you manually spinning each one up.

Background Tasks & Notifications

Long commands, subagents, and monitors can run in the background while you keep working in the foreground. Claude Code notifies you when they finish instead of blocking the conversation — useful for builds, test suites, deployments, or a Monitor watching logs for a specific event.

Checkpointing — /rewind

Claude Code snapshots file state before edits, so /rewind can restore a previous checkpoint if a change goes wrong — a safety net that doesn't require manual git stashing or reset.

Plugins & Marketplaces

Plugins bundle skills, commands, agents, and MCP servers together for one-click installation from a marketplace — letting teams distribute a whole workflow (not just one script) to every contributor on a project.

Quick Reference

Frequently Asked Questions