Claude Code Slash Commands, Shortcuts & CLI Reference

Claude Code has over 40 built-in slash commands, dozens of keyboard shortcuts, and a rich set of CLI flags. Most developers use about five of them. The rest sit undiscovered, which means missed opportunities to save time, reduce token costs, and automate repetitive workflows.

This is the reference you bookmark. Every slash command with what it does and when to use it. Every keyboard shortcut worth memorizing. Every CLI flag for scripting and automation. Plus how to build your own custom commands using Skills.

No fluff. Just the complete command reference for Claude Code in 2026.

Built-in Slash Commands

Type / at the start of your input to see all available commands. Type any letters after / to filter the list. Here is every built-in command, organized by what you use them for.

Session Management

These commands control your conversation lifecycle – starting fresh, resuming old work, and managing context.

When to use what:

• /compact when context usage exceeds 80% but you are still working on the same task. Add focus instructions to control what survives: /compact keep the database schema and error handling patterns
• /clear when switching to a completely different task. Old context would confuse Claude
• /resume when you closed a session yesterday and want to pick up where you left off

# Check context usage first
/context

# If context is getting full, compact with focus
/compact retain the authentication flow and test results

# If switching tasks entirely, clear everything
/clear

Information and Diagnostics

Commands that show you what is happening – costs, status, context usage, and environment health.

Power user tip: Run /cost periodically during long sessions. A single agentic loop can burn through tokens faster than you expect. If costs are climbing, use /compact to reduce context size or switch to a cheaper model with /model sonnet.

# Quick session health check
/cost          # How much have I spent?
/context       # How full is my context window?
/usage         # Am I near my rate limit?

Model and Mode Control

Switch models, toggle modes, and change how Claude behaves.

Model switching strategy: Start with Sonnet for most tasks – it handles 80% of work at lower cost. Switch to Opus for complex architecture decisions, subtle bugs, or tasks requiring deep reasoning. Switch back when the hard part is done.

# Start a session with Sonnet (default, cheaper)
/model sonnet

# Hit a tricky bug? Switch to Opus
/model opus

# Done with the hard part, switch back
/model sonnet

Configuration and Permissions

Manage settings, permissions, authentication, and project setup.

Code Review and PR Workflow

Commands for working with pull requests and code review.

These commands require the gh CLI to be installed and authenticated. If you have not set it up:

# Install GitHub CLI
brew install gh

# Authenticate
gh auth login

# Now you can use PR commands in Claude Code
/review 42        # Review PR #42
/pr-comments      # Show comments on current branch's PR
/security-review  # Security audit of uncommitted changes

Working Directories and Integration

Keyboard Shortcuts

Memorizing even a few of these shortcuts will noticeably speed up your workflow. Think of them like IDE shortcuts – the investment pays off every session.

Essential Shortcuts (Learn These First)

Navigation and Editing

Mode and Display Toggles

Multiline Input

Writing multi-line prompts requires special key combinations since Enter submits the message.

If Shift+Enter does not work in your terminal, run /terminal-setup to install the keybinding.

Quick Input Prefixes

The ! prefix is powerful – it runs a shell command directly and adds the output to conversation context without Claude interpreting or approving it. Use it for quick checks while maintaining context:

! npm test                # Run tests, output goes into context
! git log --oneline -5    # Check recent commits
! cat .env.example        # Show file contents

CLI Flags Reference

CLI flags let you customize Claude Code’s behavior from the command line. They are essential for scripting, CI/CD pipelines, and automation.

Session Control

Model and Behavior

Print Mode (Non-Interactive)

Print mode (-p) is the key to scripting with Claude Code. It sends a query and exits – no interactive session.

Practical scripting examples:

# Generate API docs and save to file
claude -p "Generate API documentation for src/api/" --output-format text > api-docs.md

# Get structured analysis as JSON
claude -p "Analyze the error handling in this project" --output-format json | jq '.result'

# Limit spending on expensive operations
claude -p --max-budget-usd 2.00 --max-turns 5 "Refactor the auth module"

# Pipe content for analysis
cat error.log | claude -p "What caused this crash?"

# CI/CD: Check code quality with budget cap
claude -p --max-budget-usd 1.00 --output-format json \
  "Review the last commit for security issues" | jq '.result'

Permission and Tool Control

The --allowedTools flag is the safer alternative to skipping permissions entirely. You get automation without giving Claude carte blanche:

# Allow only read operations and git commands
claude -p --allowedTools "Bash(git log:*)" "Bash(git diff:*)" "Read" "Grep" "Glob" \
  "Generate a code review for the last 3 commits"

System Prompt Customization

For most use cases, --append-system-prompt is the safest option – it keeps Claude Code’s built-in capabilities while adding your custom rules:

# Add project-specific rules
claude --append-system-prompt "Always use TypeScript. Never use any. Include JSDoc comments."

# Load rules from a file for team consistency
claude --append-system-prompt-file ./team-rules.txt

MCP and Extensions

Other Useful Flags

Custom Commands with Skills

Built-in commands cover general needs. But your team has specific workflows – deployment checklists, code review processes, documentation formats. This is where custom commands come in.

Claude Code supports two approaches: legacy slash commands (files in .claude/commands/) and the newer Skills system (files in .claude/skills/). Skills are the recommended approach – they do everything commands do, plus auto-triggering and supporting files.

Creating a Custom Skill

A Skill is a folder containing a SKILL.md file with YAML frontmatter and Markdown instructions.

Step 1: Create the skill directory.

# Project-level skill (shared with team via Git)
mkdir -p .claude/skills/deploy

# Personal skill (available in all your projects)
mkdir -p ~/.claude/skills/deploy

Step 2: Write the SKILL.md file.

---
name: deploy
description: Deploy the application to staging or production. Use when the user mentions deploying, releasing, or shipping.
---

# Deployment Workflow

## Pre-deployment Checks
1. Run the full test suite: `npm test`
2. Check for uncommitted changes: `git status`
3. Verify you're on the correct branch

## Deploy Steps
1. Build the production bundle: `npm run build`
2. Run database migrations if needed
3. Deploy using: `./scripts/deploy.sh <environment>`
4. Verify the deployment health check

## Post-deployment
1. Monitor error rates for 15 minutes
2. Run smoke tests against the deployed environment
3. Update the deployment log

Step 3: Use it.

# Manual invocation
/deploy

# Or just describe what you want -- Claude auto-detects the skill
"Deploy the latest changes to staging"

Skill Frontmatter Options

The YAML frontmatter controls how and when your skill activates:

---
name: code-review
description: Thorough code review following team standards
# Optional fields:
user_invocable: true       # Allow manual /code-review invocation (default: true)
auto_invocable: true       # Allow Claude to auto-trigger (default: true)
model: opus                # Force a specific model for this skill
tools:                     # Restrict which tools this skill can use
  - Read
  - Grep
  - Glob
---

Skills vs Legacy Commands

Legacy commands keep working. If you have existing .claude/commands/ files, they will continue to function. Migrate when convenient – or do not. A Skill and a command with the same name will resolve to the Skill.

For a deep dive on building advanced Skills, see our Claude Code Skills Guide.

Environment Variables

Environment variables configure Claude Code at a deeper level than settings or flags. Set them in your shell profile (~/.zshrc, ~/.bashrc) or per-session.

Authentication

Cloud Provider Configuration

Model Configuration

Bash Execution

Feature Toggles

Setting environment variables:

# In ~/.zshrc or ~/.bashrc
export ANTHROPIC_API_KEY="sk-ant-..."
export CLAUDE_CODE_EFFORT_LEVEL="high"
export CLAUDE_CODE_MAX_OUTPUT_TOKENS=64000

# Per-session override
CLAUDE_CODE_EFFORT_LEVEL=low claude -p "Quick summary of this file"

# For AWS Bedrock users
export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-east-1

Power User Tips

1. Chain Commands for Context Efficiency

Instead of sending multiple messages, front-load context before your request:

# Bad: multiple turns, wastes tokens
"What does the auth module do?"
"Now add rate limiting to it"
"Now write tests for the rate limiting"

# Good: single prompt with full context
"Add rate limiting to the auth module in src/auth/ and write tests.
 Rate limit: 100 requests per minute per IP.
 Use the existing Redis connection for storage.
 Follow the test patterns in tests/auth/"

2. Monitor Costs with /cost

Get into the habit of checking /cost every 15-20 minutes during active sessions. Token usage can spike during agentic loops where Claude reads files, edits, runs tests, and iterates.

If costs are climbing faster than expected:

• Run /compact to reduce context size
• Switch to /model sonnet for less complex subtasks
• Break large tasks into smaller, focused sessions

3. Use /compact Strategically

/compact is not just a panic button when context is full. Use it proactively:

# After finishing a subtask, compact before starting the next
/compact retain the API schema and test results, discard the debugging steps

# Before a complex operation, make room
/compact keep only the project architecture and current task requirements

4. Script Repetitive Workflows

Combine -p mode with shell scripting for tasks you run regularly:

#!/bin/bash
# daily-review.sh -- Morning code review routine

echo "=== Reviewing yesterday's changes ==="
claude -p --max-budget-usd 1.00 --output-format text \
  "Review all commits from the last 24 hours. Flag any security issues,
   missing tests, or code quality problems. Be concise." \
  --allowedTools "Bash(git log:*)" "Bash(git diff:*)" "Bash(git show:*)" "Read" "Grep"

echo "=== Done ==="

5. Background Long-Running Commands

When Claude is running a slow command (tests, builds, deployments), press Ctrl+B to send it to the background. You can keep working on your prompt while the command finishes:

# Claude starts running "npm test" (takes 2 minutes)
# Press Ctrl+B to background it
# Continue typing your next instruction
# Claude retrieves the output when it's done

6. Use Vim Mode for Complex Prompts

If you write long, detailed prompts, enable Vim mode with /vim. You get full Vim navigation (hjkl, word motions, text objects) and editing (dd, ciw, yy) right in the Claude Code input. Toggle it off anytime with /vim again.

7. Define Subagents for Specialized Tasks

Use the --agents flag to create focused subagents that Claude can delegate to:

claude --agents '{
  "test-writer": {
    "description": "Writes comprehensive tests. Use after any code change.",
    "prompt": "You write thorough tests. Cover happy path, edge cases, and error conditions.",
    "tools": ["Read", "Edit", "Bash"],
    "model": "sonnet"
  },
  "security-reviewer": {
    "description": "Reviews code for security vulnerabilities.",
    "prompt": "You are a security expert. Find injection, auth, and data exposure risks.",
    "tools": ["Read", "Grep", "Glob"],
    "model": "opus"
  }
}'

Quick Reference Card

Here is the cheat sheet. Print it, pin it, or keep it in a second terminal.

Daily essentials:

Keyboard shortcuts:

Scripting pattern:

claude -p "your query" \
  --output-format json \
  --max-turns 5 \
  --max-budget-usd 2.00 \
  --allowedTools "Read" "Grep" "Glob"

Related Reading

• Claude Code Guide 2026: Everything You Need to Know – The hub page linking all Claude Code guides
• Claude Code Hooks: Automate Your AI Workflow – Deterministic automation with lifecycle hooks
• Claude Code Skills Guide: Create Custom Workflows – Deep dive into building Skills
• CLAUDE.md Best Practices: Write Files That Actually Work – Effective project configuration
• Install Claude Code in 5 Minutes – Getting started from zero
• 10 Claude Code Mistakes Beginners Make – Common pitfalls to avoid