The Shorthand Guide to Everything Claude Code

title: "The Shorthand Guide to Everything Claude Code" description: "Complete setup from months of daily use: skills, hooks, subagents, MCPs, plugins, tips & tricks." section: "guide" readTime: "17 min" badge: "ECC"

A complete setup from months of daily Claude Code use: skills, hooks, subagents, MCPs, plugins, and what actually works.

The community configs referenced here come from the everything-claude-code (ECC) project. Anything about Claude Code itself is checked against the official docs.

Skills and Commands

Skills are the primary workflow surface. They act like scoped workflow bundles: reusable prompts, structure, supporting files, and codemaps when you need a particular execution pattern. Custom commands have been merged into skills: .claude/commands/review.md and .claude/skills/review/SKILL.md both create /review, and skills are the recommended form because they support supporting files and automatic loading.

After a long session of coding with Opus 5.5, you want to clean out dead code and loose .md files? A /refactor-clean skill can do it. Need testing? /tdd, /e2e, /test-coverage. Those slash entries are convenient, but the real durable unit is the underlying skill. Skills can also include codemaps — a way for Claude to quickly navigate your codebase without burning context on exploration.

Claude Code also ships bundled skills: /simplify (four parallel review agents that clean up changed code), /batch <instruction> (large changes split into 5 to 30 worktree units), and /loop (repeat a prompt on an interval).

ECC still ships a commands/ layer, but it is best thought of as legacy slash-entry compatibility during migration. The durable logic should live in skills.

• Skills: ~/.claude/skills/<name>/SKILL.md (personal) or .claude/skills/<name>/SKILL.md (project) — canonical workflow definitions
• Commands: ~/.claude/commands/ — still work, best kept as legacy slash-entry shims

# Example skill structure: each skill is a folder with a SKILL.md
~/.claude/skills/
  pmx-guidelines/        # Project-specific patterns
    SKILL.md
  coding-standards/      # Language best practices
    SKILL.md
  tdd-workflow/          # Multi-file skill: SKILL.md plus supporting files
  security-review/       # Checklist-based skill

Hooks

Hooks are trigger-based automations that fire on specific events. Unlike skills, they're constricted to tool calls and lifecycle events. Unlike CLAUDE.md instructions, they are deterministic: use a hook when something must always happen.

Commonly used events:

1. PreToolUse — Before a tool executes (validation, reminders; exit code 2 blocks the call)
2. PostToolUse — After a tool finishes (formatting, feedback loops)
3. UserPromptSubmit — When you send a message
4. Stop — Each time Claude finishes responding (not only at session end)
5. SessionStart / SessionEnd — Session lifecycle
6. PreCompact / PostCompact — Around context compaction
7. Notification — When Claude Code sends a notification, such as a permission prompt or idle prompt
8. SubagentStart / SubagentStop — Subagent lifecycle

There are more (for example PermissionRequest, PostToolUseFailure, FileChanged, CwdChanged); see the hooks reference. Handler types are command, http, mcp_tool, prompt, and agent.

Hooks live in ~/.claude/settings.json, .claude/settings.json, .claude/settings.local.json, a plugin's hooks/hooks.json, or skill and subagent frontmatter. Browse what is active with /hooks. Command hooks receive the event as JSON on stdin (read tool_name and tool_input with jq), not as environment variables.

A matcher is not an expression language: it is a tool name, a list such as Edit|Write, or a regex. To narrow by arguments, add an if field holding one permission-rule pattern.

Example: tmux reminder before long-running commands

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "if": "Bash(npm *)",
            "command": "if [ -z \"$TMUX\" ]; then echo '[Hook] Consider tmux for session persistence' >&2; fi"
          }
        ]
      }
    ]
  }
}

if takes a single rule, with no &&, ||, or lists. For pnpm, yarn, cargo, and pytest, add one handler per command. This reminder is informational; to feed a message to Claude or stop the call, use hook JSON output on stdout, or exit 2 with the reason on stderr to block.

Subagents

Subagents are processes your orchestrator (main Claude) can delegate tasks to with limited scopes. They can run in background or foreground, freeing up context for the main agent. They are not slash commands: Claude delegates to them automatically based on their description, or you can @-mention one (@agent-code-reviewer) to guarantee it runs. Press Ctrl+B to send a running task to the background.

Subagents work nicely with skills — list skills in the subagent's skills frontmatter and they are preloaded at startup. They can also be sandboxed with specific tool permissions.

Claude Code has built-in subagents: Explore (read-only, fast codebase search), Plan (read-only research during plan mode), and general-purpose.

# Example subagent structure
~/.claude/agents/            # personal; use .claude/agents/ for a project
  planner.md             # Feature implementation planning
  architect.md           # System design decisions
  tdd-guide.md           # Test-driven development
  code-reviewer.md       # Quality/security review
  security-reviewer.md   # Vulnerability analysis
  build-error-resolver.md
  e2e-runner.md
  refactor-cleaner.md

Each is a Markdown file with YAML frontmatter; the body is the system prompt:

---
name: code-reviewer
description: Reviews code for quality and security. Use after code changes.
tools: Read, Glob, Grep
model: sonnet
---
 
You are a code reviewer. Give specific, actionable feedback.

Only name and description are required. Scope each subagent with tools (allowlist) or disallowedTools (denylist), pick a model, and optionally set permissionMode, mcpServers, skills, hooks, memory, or isolation: worktree. (The field is tools, not allowed-tools, which is a skill field.) Ask Claude to create subagents or edit the files directly; /agents just prints a reminder on current versions. claude --agents '<json>' defines session-only subagents.

Rules and Memory

Claude Code reads CLAUDE.md files (user ~/.claude/CLAUDE.md, project, and organization levels) at the start of every session, and /init generates a starter file for a project. For modular guidance, put .md files in .claude/rules/ (project) or ~/.claude/rules/ (personal). Two approaches:

1. Single CLAUDE.md — Everything in one file (user or project level)
2. Rules folder — Modular .md files grouped by concern

~/.claude/rules/
  security.md      # No hardcoded secrets, validate inputs
  coding-style.md  # Immutability, file organization
  testing.md       # TDD workflow, 80% coverage
  git-workflow.md  # Commit format, PR process
  agents.md        # When to delegate to subagents
  performance.md   # Model selection, context management

Claude treats these as context, not enforced configuration. When something must be guaranteed, use a hook or a permission rule instead. Claude also keeps auto memory notes of its own; manage both with /memory.

Example rules:

• No emojis in codebase
• Refrain from purple hues in frontend
• Always test code before deployment
• Prioritize modular code over mega-files
• Never commit console.logs

MCPs (Model Context Protocol)

MCPs connect Claude to external services directly. Not a replacement for APIs — it's a prompt-driven wrapper around them, allowing more flexibility in navigating information.

Example: A Supabase MCP lets Claude pull specific data, run SQL directly upstream without copy-paste. Same for databases, deployment platforms, etc. Prefer a vendor's own remote (HTTP) server where one exists; several of the original reference servers (GitHub, Postgres, Puppeteer, Slack, Brave Search) were archived and replaced.

claude mcp add --transport http notion https://mcp.notion.com/mcp
claude mcp add --transport stdio --env API_KEY=YOUR_KEY myserver -- npx -y some-mcp-server
claude mcp list

Scopes: local (default, this project only, private), project (.mcp.json, shared via git), and user (all your projects).

Claude in Chrome: Official browser integration that lets Claude control your browser to test and automate web apps. Start with claude --chrome (or --no-chrome to disable). It needs the Chrome extension.

# Inside a session: list servers, toggle, reconnect, authenticate
/mcp
 
# Toggling a server off in /mcp is recorded per project in ~/.claude.json.
# To block a server from a project's .mcp.json, use the disabledMcpjsonServers setting.

Plugins

Plugins package tools for easy installation instead of tedious manual setup. A plugin can bundle skills, subagents, hooks, MCP servers, and LSP servers. A plugin is a folder with an optional .claude-plugin/plugin.json manifest, installed from a marketplace (a catalog with .claude-plugin/marketplace.json), not from npm.

Installing plugins:

# Add a marketplace (GitHub owner/repo, git URL, local path, or marketplace.json URL)
claude plugin marketplace add your-org/plugins
 
# Install from it (user scope by default; --scope project|local)
claude plugin install my-plugin@your-marketplace
 
# Or inside a session: open the plugin manager (Discover, Installed, Marketplaces, Errors tabs)
/plugin

Anthropic's official marketplace, claude-plugins-official, is added automatically the first time you start an interactive session (for example /plugin install commit-commands@claude-plugins-official). Run /reload-plugins to apply changes in the current session, and claude plugin details <name> to see what a plugin adds to every session. Skills from a plugin appear as /plugin-name:skill-name.

LSP plugins are particularly useful if you run Claude Code outside editors frequently. Language Server Protocol gives Claude type errors after edits and precise go-to-definition without needing an IDE open. Browse the code intelligence plugins in /plugin.

# Examples of plugin@marketplace IDs (confirm names in /plugin before installing)
typescript-lsp@claude-plugins-official  # TypeScript intelligence
pyright-lsp@claude-plugins-official     # Python type checking

Same warning as MCPs — watch your context window. Disable plugins you don't use.

Tips and Tricks

Keyboard Shortcuts

• Ctrl+U — Delete from cursor to line start (repeat to clear multiple lines)
• ! — Bash mode prefix (run a command directly)
• @ — Search for files to mention
• / — Initiate slash commands and skills
• Shift+Enter — Multi-line input (run /terminal-setup if your terminal needs it)
• Shift+Tab — Cycle permission modes (default, acceptEdits, plan, then auto when available)
• Alt+T (Option+T on macOS) — Toggle extended thinking, on models that allow it
• Ctrl+O — Toggle transcript viewer
• Ctrl+G — Edit the current prompt in your external editor
• Ctrl+B — Send a running command or agent to the background
• Esc — Interrupt Claude
• Esc Esc — Clear the draft, or on an empty prompt open the rewind menu

Parallel Workflows

• /branch — Branch the conversation to try a different direction; return to the original with /resume
• /fork [prompt] — Copy the conversation into a new background session and keep working here
• Git Worktrees — For overlapping parallel Claudes without conflicts. Each worktree is an independent checkout

claude --worktree feature-branch   # or -w; creates <repo>/.claude/worktrees/feature-branch
# or manage them yourself
git worktree add ../feature-branch feature-branch

tmux for Long-Running Commands

Stream and watch logs/bash processes Claude runs:

tmux new -s dev
# Claude runs commands here, you can detach and reattach
tmux attach -t dev

In tmux, press Ctrl+B twice to background a task, since tmux uses it as its prefix.

mgrep

mgrep (Mixedbread) is semantic search over local files; its README also documents --web for web search. Install it with its own CLI, which registers the Claude Code plugin:

npm install -g @mixedbread/mgrep
mgrep login
mgrep install-claude-code
 
mgrep "function handleSubmit"               # Local search
mgrep --web "Next.js 15 app router changes" # Web search

The project reports ~2× fewer tokens than grep-based workflows in its own 50-task benchmark; treat that as vendor data and try it on your codebase.

Other Useful Commands

• /rewind — Rewind code and/or conversation to a previous checkpoint, or summarize from a point (aliases /checkpoint, /undo). Bash-made file changes are not tracked
• /statusline — Customize with branch, context %, cost (a script that reads session JSON on stdin)
• /compact [instructions] — Manually trigger context compaction
• /context — Visualize context usage
• /usage — Token and cost estimate, plan usage breakdown
• /model, /effort — Switch model and effort level
• /plan [task] — Enter plan mode directly
• /btw <question> — Side question that stays out of the conversation

GitHub Actions CI/CD

Run /install-github-app to install the Claude GitHub App and generate the workflow for the anthropics/claude-code-action action. Mention @claude in PRs and issues, or select the review workflow so Claude posts review comments on pull requests. Anthropic's separate Code Review feature reviews PRs without you maintaining a workflow.

Sandboxing

Use /sandbox for risky operations. Sandbox mode adds OS-level isolation for Bash commands (restricted filesystem and network access), on supported platforms. For unattended work, permission modes and allow/deny rules matter too.

On Editors

Your editor choice significantly impacts Claude Code workflow. Claude Code works from any terminal, and official integrations exist for VS Code (and forks such as Cursor) and JetBrains IDEs. Pairing it with a capable editor gives you file tracking, quick navigation, and integrated diffs.

Editor-Agnostic Tips:

1. Split your screen — Terminal with Claude Code on one side, editor on the other
2. Ctrl + G — Opens your current prompt in your default text editor for longer edits
3. Auto-save — Enable autosave so Claude's file reads are always current
4. Git integration — Use editor's git features to review Claude's changes before committing
5. File watchers — Most editors auto-reload changed files, verify this is enabled

VS Code / Cursor

The extension gives a native panel with inline diffs, plan review, and @-mentions of selected line ranges (VS Code 1.94 or later). Alternatively, run claude in the editor's integrated terminal and use /ide to connect to the editor, or start with claude --ide, which connects automatically when exactly one IDE is available.

Other editors

Fast native editors such as Zed are a popular pairing in the community because they stay responsive while Claude edits many files. Check each editor's own docs for Claude Code support, since integration details vary.

My Setup

Plugins (a handful enabled at a time)

# Names as used in the ECC author's setup; marketplace IDs change, so confirm in /plugin
frontend-design        # UI/UX patterns
commit-commands        # Git workflow (official marketplace)
security-guidance      # Security checks
typescript-lsp         # TS intelligence
hookify                # Hook creation
context7               # Live documentation
mgrep                  # Better search

MCP Servers (user level)

# Prefer vendor-hosted HTTP servers; verify each URL in the vendor's docs before use
claude mcp add --scope user --transport http vercel https://mcp.vercel.com
claude mcp add --scope user --transport stdio firecrawl -- npx -y firecrawl-mcp
claude mcp add --scope user --transport stdio sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking

Keep only the servers you need enabled per project; use /mcp to toggle the rest off. The ECC repo keeps larger example MCP configs under mcp-configs/.

Key Hooks

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "if": "Bash(git push *)", "command": "~/.claude/hooks/review-before-push.sh" }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          { "type": "command", "if": "Edit(*.ts)", "command": "~/.claude/hooks/format-and-typecheck.sh" }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "~/.claude/hooks/check-console-log.sh" }
        ]
      }
    ]
  }
}

Each script reads the event JSON from stdin. Stop takes no matcher. if takes a single rule, so add a second handler for .tsx or .js files. Typical scripts: run prettier --write and tsc --noEmit on edited files, warn about console.log, or block creating stray .md files by exiting 2 from a PreToolUse hook that matches Write. (For permission deny rules, use Edit(...) patterns, which cover all file edits.)

Custom Status Line

affoon:~ ctx:65% Opus 5.5 19:52
▌▌ plan mode on (shift+tab to cycle)

Rules Structure

~/.claude/rules/
  security.md      # Mandatory security checks
  coding-style.md  # Immutability, file size limits
  testing.md       # TDD, 80% coverage
  git-workflow.md  # Conventional commits
  agents.md        # Subagent delegation rules
  patterns.md      # API response formats
  performance.md   # Model selection (Haiku vs Sonnet vs Opus)
  hooks.md         # Hook documentation

Subagents

~/.claude/agents/
  planner.md             # Break down features
  architect.md           # System design
  tdd-guide.md           # Write tests first
  code-reviewer.md       # Quality review
  security-reviewer.md   # Vulnerability scan
  build-error-resolver.md
  e2e-runner.md          # Playwright tests
  refactor-cleaner.md    # Dead code removal
  doc-updater.md         # Keep docs synced

Key Takeaways

1. Don't overcomplicate — treat configuration like fine-tuning, not architecture
2. Context window is precious — disable unused MCPs and plugins
3. Parallel execution — branch or fork conversations, use git worktrees
4. Automate the repetitive — hooks for formatting, linting, reminders
5. Scope your subagents — limited tools = focused execution

References

• Plugins Reference
• Hooks Documentation
• Checkpointing
• Interactive Mode
• Memory System
• Subagents
• MCP
• Commands
• The Longform Guide — Advanced patterns (token economics, memory persistence, evals, parallelization)