The Complete Guide to Claude's Slash Commands & Shortcuts

The Complete Guide to
Claude's Slash Commands
& Shortcuts

Claude is not just a chat interface — it's a programmable AI operating system. And like any powerful system, it has a command layer. Slash commands are the keyboard shortcuts of the AI era: they collapse multi-step workflows into a single keystroke, make your sessions smarter, and let teams share automation like version-controlled code.

Whether you're using Claude.ai in the browser, running Claude Code in your terminal, or integrating Claude through the Agent SDK, this guide gives you the complete picture — every built-in command, the keyboard shortcuts, and how to build your own.

Claude.ai — Web & App Commands

The claude.ai web and mobile interface keeps its command palette minimal by design. The intelligence is conversational, not command-driven. Here's everything that's available natively:

Mac users: Replace Ctrl with Cmd for all shortcuts above.

Claude Code — Built-in Slash Commands

Claude Code is where the real command power lives. These built-in commands are available the moment you launch claude in your terminal — no setup needed. Type /help at any time to see them all.

Claude Code — Keyboard Shortcuts

These work during any interactive Claude Code session in your terminal. Mastering them is the difference between a slow AI user and a fast one.

Pro tip: Use ! prefix (e.g. !git status) to run shell commands directly, bypassing Claude's conversational mode. Faster and uses fewer tokens.

How to Make Custom Commands — The Complete Guide

Custom commands are where Claude stops being a chat tool and becomes a programmable team member. There is no limit to how many you can create. Every repeated prompt, every workflow, every checklist — turned into a single /command that anyone on your team can run identically, every time.

As of 2026, Anthropic unified the older "commands" system with the newer "Skills" format. Both work. Skills are recommended because they support more features — but the underlying idea is identical: a Markdown file becomes a slash command.

Commands vs Skills — What's the difference?

Location determines scope — who can see and use the command.

Precedence rule: Project-level skills override global ones if they share the same name. This lets you set a global /review default but override it per-project with stricter or looser rules — without touching your global setup.

Minimal working example — 3 lines to a custom command

 # Terminal 
mkdir -p .claude/skills/commit
 cat > .claude/skills/commit/SKILL.md << 'EOF' 
 ---
name: commit
description: Generate a conventional commit message from staged changes
--- 

Look at the staged changes and write a conventional commit message.
Format: <type>(<scope>): <short description>

Types: feat, fix, docs, style, refactor, test, chore
Keep the subject line under 72 characters.

Staged diff:
!`git diff --cached`
 EOF 

Now type /commit in Claude Code. That's all it takes.

Every SKILL.md has two parts separated by ---: a YAML frontmatter block that configures behaviour, and a Markdown body that is the actual instruction Claude follows.

Full annotated SKILL.md — every option shown

 --- 
 # REQUIRED — becomes the /slash-command name 
 name : code-review

 # REQUIRED — drives auto-discovery. Front-load the key use case. 
 # Claude reads this to decide when to invoke automatically. 
 # Capped at 1,536 chars. Be specific, not vague. 
 description : Comprehensive code review for security, quality, and performance.
 Use when reviewing PRs, checking recent changes, or auditing a file.

 # Pre-approve tools — Claude won't ask permission for these 
 allowed-tools : Read, Grep, Glob, Bash(git diff:*), Bash(git log:*)

 # Override the model for this specific command 
 # Use Haiku for speed/cost, Opus for complex multi-step reasoning 
 model : claude-opus-4-6

 # Shown in autocomplete — tells user what args to pass 
 argument-hint : [file-or-PR-number]

 # Run in isolated subagent — keeps your main context window clean 
 # Great for research-heavy or long-running tasks 
 context : fork

 # Which subagent persona to use (Explore, Plan, or custom) 
 agent : Explore

 # Hide from /help menu — Claude invokes automatically, you don't type it 
 # Good for background context skills, not user-facing commands 
 user-invocable : false

 # Prevent Claude from auto-triggering — ONLY manual /command invocation 
 # Use for anything with side effects: deploys, sends, publishes 
 disable-model-invocation : true

 # Restrict auto-invocation to specific file paths 
 paths :
 - src/**/*.ts
 - src/**/*.tsx
 --- 

 ## Everything below this line is the instruction Claude follows 

Review the following changes for:
1. Code quality and readability
2. Security vulnerabilities (SQL injection, XSS, exposed secrets)
3. Performance — unnecessary re-renders, N+1 queries, memory leaks
4. Test coverage — are edge cases handled?
5. Documentation — are public APIs documented?

Target: $ARGUMENTS 

Current diff:
 !`git diff HEAD~1` 

Output your review as:
- **Summary** (2 sentences max)
- **Critical issues** (must fix before merge)
- **Suggestions** (nice to have)
- **Verdict**: APPROVE / REQUEST CHANGES

Commands become dynamic when they accept input. Three argument patterns cover almost every use case:

Argument patterns

 # Pattern 1: Single argument — $ARGUMENTS gets everything after the command 
 # Usage: /fix-issue 247 
Fix GitHub issue $ARGUMENTS following our coding standards.
Commit message: "fix: resolve #$ARGUMENTS" 

 # Pattern 2: Positional args — $1, $2, $3... 
 # Usage: /migrate-component Button Modal 
Migrate the $1 component to use the $2 pattern.
Read the existing $1 implementation first, then rewrite.

 # Pattern 3: Named args via $ARGUMENTS[key] (advanced) 
 # Usage: /deploy --env staging --version 2.1.4 
Deploy to environment: $ARGUMENTS[env] 
Version: $ARGUMENTS[version] 

The !`command` syntax runs a shell command at invocation time and injects its output into the prompt. Claude always has live, accurate data — never stale context.

Useful shell injections

 # Git context 
Current branch: !`git branch --show-current` 
Recent commits: !`git log --oneline -10` 
Staged changes: !`git diff --cached` 
Changed files: !`git diff --name-only HEAD~1` 
Open PRs: !`gh pr list --state open` 

 # Project context 
Package version: !`cat package.json | grep '"version"'` 
Test results: !`npm test -- --passWithNoTests 2>&1 | tail -20` 
Build errors: !`npm run build 2>&1 | grep -i error | head -20` 
Env vars: !`cat .env.example` 

 # System / date context 
Today: !`date +%Y-%m-%d` 
Directory tree: !`find src -name "*.ts" | head -30` 

 # Live docs fetch — always current, never stale 
Docs: !`curl -s https://api.example.com/docs/llms.txt` 

One of the key advantages of the Skills format over flat commands: your skill folder can contain templates, examples, scripts, and reference docs that Claude loads on demand.

Example skill folder with supporting files

.claude/skills/new-feature/
├── SKILL.md ← main instructions 
├── template.md ← Claude fills this in 
├── examples/
│ ├── good.ts ← show Claude what "good" looks like 
│ └── bad.ts ← show what to avoid 
├── checklist.md ← pre-launch checklist 
└── conventions.md ← your team's coding style guide 

 # In SKILL.md — reference your supporting files 
 ---
name: new-feature
description: Scaffold a new feature following team conventions
--- 

Read our conventions first: @conventions.md
Use this template: @template.md
Match the style of: @examples/good.ts
Avoid the patterns in: @examples/bad.ts

Now implement: $ARGUMENTS 

The instruction body of your SKILL.md is a prompt. The same prompt engineering principles apply — but in a persistent, reusable form. A few rules that separate good commands from great ones:

This is the compounding value. Once a command is in your repo, every team member runs the same workflow. When someone improves it, everyone benefits on next git pull.

Team setup pattern

 # Commit your skills directory 
git add .claude/skills/
git commit -m "feat: add team Claude Code skills" 
git push

 # Add a README so teammates know what's available 
 cat > .claude/skills/README.md << 'EOF' 
## Team Claude Skills

| Command | What it does |
|---------------------|-------------------------------------------|
| /code-review | Full review: quality, security, perf |
| /commit | Conventional commit from staged diff |
| /test-gen | Generate tests for a file or function |
| /security-scan | OWASP Top 10 scan across codebase |
| /api-scaffold | REST endpoint scaffold with RBAC |
| /docs | Generate JSDoc / docstrings |
| /release-notes | Changelog from git log since last tag |

Add new skills here and document them in this table.
 EOF 

 # Reference in CLAUDE.md so Claude knows about them 
 echo "## Available Skills\nSee .claude/skills/README.md" >> CLAUDE.md

Hot reload: As of January 2026, skills you create or modify activate immediately in a running Claude Code session — no restart needed. Edit a SKILL.md, save it, and the updated command is live in seconds.

15 Ready-to-Use Commands

Below are production-ready SKILL.md bodies. Create the folder, paste the content, and start using them immediately.

/commit — Smart conventional commit

 ---
name: commit
description: Generate a conventional commit message from staged git changes
allowed-tools: Bash(git diff:*), Bash(git status:*)
model: claude-haiku-4-5
--- 

Staged changes:
 !`git diff --cached` 

Write a conventional commit message:
- Format: <type>(<scope>): <description>
- Types: feat, fix, docs, style, refactor, test, chore, perf
- Subject line: max 72 chars, imperative mood, no period
- Add a body if the change is non-obvious (what + why, not how)
- Reference issue numbers if relevant

Output ONLY the commit message, nothing else.

/security-scan — OWASP vulnerability check

 ---
name: security-scan
description: Security vulnerability scan. Use before merging PRs or deploying.
allowed-tools: Read, Grep, Glob
model: claude-opus-4-6
context: fork
--- 

Scan the codebase for security vulnerabilities. Check for:

**Injection**
- SQL injection (string concatenation in queries)
- Command injection (user input in shell commands)
- XSS (unescaped output in HTML)

**Secrets & Auth**
- Hardcoded credentials, API keys, tokens
- Weak password hashing (MD5, SHA1, no salt)
- Insecure session management

**Data Exposure**
- Sensitive data in logs
- Unencrypted PII in transit or at rest
- Verbose error messages in production

**Dependencies**
- Known vulnerable packages (check package.json)

Target: $ARGUMENTS (or entire codebase if no argument given)

Output as: CRITICAL / HIGH / MEDIUM / LOW findings with file:line references.

/test-gen — Comprehensive test generation

 ---
name: test-gen
description: Generate comprehensive tests for a function, file, or module
allowed-tools: Read, Grep, Glob, Bash(npm test:*), Bash(npx:*)
argument-hint: [file-or-function]
--- 

Generate tests for: $ARGUMENTS 

Before writing any tests:
1. Read the target file to understand function signatures and types
2. Find the existing test directory — read 1-2 tests to match their pattern exactly
3. Identify the testing framework (Jest, Vitest, pytest, etc.)

Generate tests covering:
- **Happy path** — expected inputs produce expected outputs
- **Edge cases** — empty, null, zero, max values, empty arrays
- **Error cases** — invalid inputs should throw or return errors
- **Async behaviour** — if async, test both success and failure
- **Boundary conditions** — off-by-one, overflow, type coercion

Match the exact import style, describe block naming, and assertion patterns from existing tests.
Run the tests after writing: report pass/fail and fix any failures.

/standup — Daily standup from git history

 ---
name: standup
description: Generate a standup update from yesterday's git activity
allowed-tools: Bash(git log:*), Bash(git diff:*), Bash(gh pr:*)
model: claude-haiku-4-5
--- 

Today: !`date +"%A, %B %d"` 
Yesterday's commits:
 !`git log --since="yesterday 00:00" --until="today 00:00" --oneline --author="$(git config user.name)"` 

Open PRs:
 !`gh pr list --author @me --state open 2>/dev/null || echo "gh CLI not configured"` 

Write a standup update in this format:
**Yesterday:** (what was completed — be specific, reference PR/issue numbers)
**Today:** (what's planned — infer from open PRs and recent work)
**Blockers:** (none unless you ask me)

Keep it concise — 3-5 bullet points max across all sections.
Use plain language, not technical jargon.

/release-notes — Changelog from git log

 ---
name: release-notes
description: Generate release notes and changelog from git history since last tag
allowed-tools: Bash(git log:*), Bash(git tag:*), Read
argument-hint: [version-number]
--- 

New version: $ARGUMENTS 
Last tag: !`git describe --tags --abbrev=0 2>/dev/null || echo "no previous tag"` 
Changes since last tag:
 !`git log $(git describe --tags --abbrev=0 2>/dev/null)..HEAD --oneline` 

Generate release notes in this format:

## v $ARGUMENTS — !`date +"%B %d, %Y"` 

### ✨ New Features
(group feat: commits)

### 🐛 Bug Fixes
(group fix: commits)

### ⚡ Performance
(group perf: commits)

### 🔧 Maintenance
(chore, refactor, docs commits)

### 💥 Breaking Changes
(anything with BREAKING CHANGE in commit body)

Write in plain English — not commit messages. What does each change mean for users?

/docs — Generate documentation

 ---
name: docs
description: Generate or update documentation for a file, function, or module
allowed-tools: Read, Edit, Glob
argument-hint: [file-path]
--- 

Generate documentation for: $ARGUMENTS 

1. Read the target file completely
2. Detect the language and its doc convention (JSDoc, TSDoc, docstrings, etc.)
3. Read 1-2 neighbouring files to understand the doc style in use

Generate:
- Function/method docs: params, return types, throws, examples
- Class/interface docs: purpose, usage pattern, example instantiation
- Module-level docs: what does this module do, when to use it
- Inline comments for non-obvious logic only (not noise comments)

Rules:
- Don't document what the code obviously does
- DO document WHY, not what
- Include at least one usage example per public API
- Update existing docs in place rather than duplicating

/fix-issue — Fix a GitHub issue by number

 ---
name: fix-issue
description: Fix a GitHub issue. Pass the issue number as argument.
allowed-tools: Read, Edit, Bash(gh issue:*), Bash(git:*)
argument-hint: [issue-number]
disable-model-invocation: true
--- 

Issue: $ARGUMENTS 
Issue details:
 !`gh issue view $ARGUMENTS 2>/dev/null || echo "Run: gh auth login"` 

1. Read the issue description and comments carefully
2. Search the codebase for relevant files
3. Understand the root cause before writing any code
4. Implement the fix — minimal, targeted change
5. Write or update tests for the fix
6. Create a commit: "fix: resolve #$ARGUMENTS — <short description>" 

If you're unsure about the expected behaviour, stop and ask before writing code.

/competitive-research — Structured competitor analysis

 ---
name: competitive-research
description: Structured competitive research and analysis for a product or company
allowed-tools: WebFetch
argument-hint: [company-or-product-name]
context: fork
model: claude-opus-4-6
--- 

Research target: $ARGUMENTS 

Conduct a structured competitive analysis. Research:
1. **Product** — core features, positioning, unique differentiators
2. **Pricing** — model, tiers, free vs paid limits
3. **Target customer** — who they're built for, job titles, company size
4. **Go-to-market** — how they acquire customers, key channels
5. **Strengths** — what they do genuinely well
6. **Weaknesses** — gaps, complaints, limitations (check reviews, Reddit, G2)
7. **Recent moves** — new features, funding, partnerships, hiring signals

Output as a structured markdown report.
End with: "How we should respond" — 3 specific tactical recommendations.

Command Ideas by Team Role

Slash Commands in the Agent SDK

If you're building on Claude via the Agent SDK, slash commands are available programmatically. The SDK exposes them on session init, and you send them as prompt strings.

 // Discover available commands at session start 
 import { query } from "@anthropic-ai/claude-agent-sdk" ;

 for await ( const message of query({
 prompt: "Hello" ,
 options: { maxTurns: 1 }
})) {
 if (message.type === "system" && message.subtype === "init" ) {
 console.log( "Commands:" , message.slash_commands);
 // ["/compact", "/clear", "/help", "/refactor"] 
 }
}

 // Send a slash command 
 for await ( const msg of query({
 prompt: "/compact" ,
 options: { maxTurns: 1 }
})) {
 if (msg.type === "system" && msg.subtype === "compact_boundary" ) {
 console.log( "Compacted. Pre-tokens:" , msg.compact_metadata.pre_tokens);
 }
}

Garage Labs note: If you're building AI-powered products on top of Claude, custom commands checked into your project repo are the cleanest way to standardise your Claude behaviour across your entire team. Everyone's running the same prompts, version-controlled and improvable.

MCP Server Commands

Connected MCP (Model Context Protocol) servers expose their own prompts as slash commands — automatically surfaced in /help. This means integrations like GitHub, Figma, HubSpot, Google Drive, and others each bring their own command vocabulary.

 # Add an MCP server 
 claude mcp add github npx @anthropic-ai/mcp-server-github

 # Or reference it in your SDK call 
mcp_servers: [
 {
 type: "url" ,
 url: "https://mcp.github.com/sse" ,
 name: "github-mcp" 
 }
]

Once connected, MCP tools appear as commands in session. Common integrations used by teams at Garage Labs include Figma (design context), HubSpot (CRM actions), Google Drive (doc reading), Gmail (email drafting), and n8n (workflow triggers).

Why This Matters

The shift from "chatting with AI" to "commanding AI" is significant. Slash commands turn Claude from a conversational assistant into a programmable workflow engine. Your best prompts stop living in your head and start living in version-controlled Markdown files that your whole team can use, improve, and ship with.

At Garage Labs, we see teams unlock serious leverage when they treat their Claude command library the same way they treat their codebase — with ownership, iteration, and craft. Start with the built-ins. Add one custom command for your most-repeated task. Build from there.

Start here: Run /init in your project today. Claude will read your codebase, understand its structure, and create a CLAUDE.md that makes every future session smarter from the first prompt.