Claude Code Slash Commands: Custom Commands & Workflows 2026

Slash Commands sind das Herzstück von Claude Codes Terminal-Interface. Mit einem einzigen Befehl wie /commit oder /review löst du komplexe mehrstufige Workflows aus — kein Copy-Paste von Prompts, keine umständlichen Kontextwechsel. Und das Beste: Du kannst beliebig viele eigene Commands erstellen und mit deinem Team teilen.

In diesem Guide lernst du, welche Built-in Commands es gibt, wie du eigene Custom Commands schreibst, und wie du Hooks nutzt um Automatisierungen auszulösen — ohne einen einzigen Klick.

1. Built-in Slash Commands: Die Grundausstattung

Claude Code kommt mit einer Reihe von eingebauten Slash Commands die direkt einsatzbereit sind. Sie decken die häufigsten Entwickler-Workflows ab und können jederzeit per /help aufgerufen werden.

Command	Was er macht	Typ
/help	Zeigt alle verfügbaren Commands — built-in und custom	Built-in
/clear	Leert den Konversations-Kontext, startet frischen Dialog	Built-in
/compact	Komprimiert langen Kontext auf Kern-Informationen (spart Tokens)	Built-in
/commit	Analysiert Änderungen, generiert Commit-Message, führt git commit aus	Built-in
/review	Code-Review der aktuellen Änderungen oder eines bestimmten Files	Built-in
/test	Führt Test-Suite aus, analysiert Fehler, schlägt Fixes vor	Built-in
/doctor	Diagnostiziert Setup-Probleme (API-Keys, Pfade, Permissions)	Built-in
/init	Initialisiert CLAUDE.md im aktuellen Projekt	Built-in
/memory	Memory-System verwalten: recall, save, list	Built-in
/pr-comments	Holt PR-Kommentare aus GitHub und listet offene Review-Punkte	Built-in
/vim	Wechselt in Vim-Eingabemodus für längere Prompt-Eingaben	Built-in
/cost	Zeigt Token-Verbrauch und Kosten der aktuellen Session	Built-in

Tipp: /compact für lange Sessions

Nach 30–40 Minuten Arbeit sammeln sich Tokens an. /compact destilliert den Kontext auf das Wesentliche — du behältst den Überblick, sparst aber signifikant Tokens und bleibst responsiv.

Built-in Commands in Aktion

Typischer Workflow mit Built-in Commands: Du hast gerade Features implementiert und willst committen, reviewen und testen — alles in drei Befehlen:

# 1. Änderungen reviewen lassen
/review

# 2. Commit mit automatisch generierter Message
/commit

# 3. Tests ausführen + Fehler-Analyse
/test

Claude analysiert dabei den kompletten Diff, versteht den Kontext deines Projekts durch CLAUDE.md, und generiert Commit-Messages die wirklich erklären warum die Änderung gemacht wurde — nicht nur was sich geändert hat.

Built-in

/doctor — Setup-Diagnose

/doctor prüft deinen kompletten Claude Code Setup: API-Keys gesetzt? CLAUDE.md gefunden? Permissions korrekt? Memory-System erreichbar? Ideal wenn Claude Code unerwartet verhält — statt manuell zu debuggen einfach /doctor aufrufen.

2. Custom Commands erstellen: .claude/commands/

Der echte Game-Changer in Claude Code sind Custom Commands. Du schreibst eine einfache Markdown-Datei in .claude/commands/ — und Claude Code macht daraus einen aufrufbaren Slash Command. Kein Code, kein Kompilieren, keine Installation.

Verzeichnisstruktur

mein-projekt/ ├── .claude/ │ ├── CLAUDE.md # Projekt-Kontext für Claude │ └── commands/ │ ├── deploy.md # → /deploy │ ├── create-component.md # → /create-component │ ├── db-migrate.md # → /db-migrate │ └── pr-review.md # → /pr-review ├── src/ └── package.json

Aufbau einer Command-Datei

Jede .md-Datei in .claude/commands/ wird automatisch als Command registriert. Der Dateiname (ohne .md) wird zum Command-Namen. Die Struktur ist simpel:

# Datei: .claude/commands/deploy.md

---
description: "Deployed die App auf Staging und verifiziert die Erreichbarkeit"
allowed-tools: ["Bash", "Read", "WebFetch"]
---

## Deploy auf Staging

Führe folgende Schritte aus:

1. Prüfe ob alle Tests grün sind: `npm test`
2. Baue die App: `npm run build`
3. Deploye auf Staging: `./scripts/deploy-staging.sh`
4. Verifiziere HTTP 200 unter: `curl -s -o /dev/null -w "%{http_code}" $STAGING_URL`
5. Melde Ergebnis mit Staging-URL

Falls ein Schritt fehlschlägt: stoppe sofort und erkläre was schiefgelaufen ist.

$ARGUMENTS — dynamische Parameter

Mit dem Platzhalter $ARGUMENTS übergibst du Parameter an deinen Command. /deploy feature/auth setzt dann $ARGUMENTS auf feature/auth im Prompt. Perfekt für Branch-Namen, Umgebungen oder Dateinamen.

Command mit $ARGUMENTS

# Datei: .claude/commands/create-component.md

---
description: "Erstellt eine neue React-Komponente mit Tests und Storybook-Story"
allowed-tools: ["Write", "Read", "Bash"]
---

Erstelle eine neue React-Komponente namens **$ARGUMENTS**.

Folge dabei exakt unserer Projekt-Konvention:

1. `src/components/$ARGUMENTS/$ARGUMENTS.tsx` — Hauptkomponente
2. `src/components/$ARGUMENTS/$ARGUMENTS.test.tsx` — Unit-Tests mit Vitest
3. `src/components/$ARGUMENTS/$ARGUMENTS.stories.tsx` — Storybook Story
4. `src/components/$ARGUMENTS/index.ts` — Barrel Export

Verwende TypeScript mit strikten Types. Keine any-Typen.
Props mit JSDoc-Kommentaren versehen.
Tests: min. 3 Testfälle (render, props, events).

Aufruf: /create-component Button — Claude erstellt alle 4 Dateien, schreibt echte Tests und befüllt die Story mit sinnvollen Beispiel-Props.

3. Praktische Custom Commands: Echte Beispiele

Hier sind vier Custom Commands die in echten Entwickler-Workflows täglich eingesetzt werden. Jeder löst ein konkretes Problem und spart zwischen 5 und 30 Minuten manueller Arbeit.

deploy-staging.md — Sicheres Staging-Deployment

# .claude/commands/deploy-staging.md

---
description: "Vollständiges Staging-Deploy mit Pre-Flight Checks"
allowed-tools: ["Bash", "Read"]
---

Führe ein sicheres Staging-Deployment durch:

**Pre-Flight Checks:**
- `git status` — keine uncommitteten Änderungen?
- `npm run lint` — kein Lint-Fehler?
- `npm test -- --run` — alle Tests grün?

**Falls eine Prüfung fehlschlägt:** Sofort stoppen, Problem erklären.

**Deploy-Schritte:**
1. `npm run build` — Production Build
2. `rsync -avz dist/ staging-server:/var/www/app/` — Upload
3. `ssh staging-server "pm2 restart app"` — Restart
4. `curl -sf https://staging.example.com/health` — Health Check
5. Zeige Deployment-Summary: Version, Zeitstempel, URL

Custom

db-migrate.md — Datenbankmigrationen

Erstellt und führt Datenbankmigrationen sicher aus: prüft Backup-Status, generiert Migration aus Schema-Diff, führt Dry-Run durch, fragt nach Bestätigung, führt Migration aus und verifiziert Tabellenstruktur. Aufruf: /db-migrate add-user-preferences

# .claude/commands/db-migrate.md

---
description: "Erstellt und führt Datenbankmigrationen aus mit Safety-Checks"
allowed-tools: ["Bash", "Write", "Read"]
---

Erstelle und führe eine Datenbankmigration für: **$ARGUMENTS**

1. Analysiere aktuelles Schema: `cat prisma/schema.prisma`
2. Erstelle Migration: `npx prisma migrate dev --name $ARGUMENTS --create-only`
3. Zeige generierte SQL — frage nach Review
4. Führe Migration aus: `npx prisma migrate deploy`
5. Verifiziere: `npx prisma db pull && npx prisma validate`
6. Generiere Prisma Client: `npx prisma generate`

**NIEMALS** Migration ausführen wenn Schema-Validierung fehlschlägt.

pr-review.md — Automatisierter PR-Review

# .claude/commands/pr-review.md

---
description: "Vollständiger Code-Review eines Pull Requests"
allowed-tools: ["Bash", "Read", "Glob", "Grep"]
---

Führe einen gründlichen Code-Review von PR #$ARGUMENTS durch.

1. Hole PR-Details: `gh pr view $ARGUMENTS`
2. Analysiere Diff: `gh pr diff $ARGUMENTS`
3. Prüfe auf:
   - Security-Probleme (SQL Injection, XSS, unsichere Dependencies)
   - Performance-Probleme (N+1 Queries, unnötige Re-Renders)
   - Code-Style (Konsistenz mit bestehendem Code)
   - Fehlende Tests für neue Funktionalität
   - Typen-Sicherheit (TypeScript)

4. Erstelle strukturierten Review-Report:
   - 🔴 Must-Fix: Kritische Probleme
   - 🟡 Should-Fix: Empfehlungen
   - 🟢 Looks Good: Was gut gelöst wurde

5. Optional: Review posten mit `gh pr review $ARGUMENTS --comment`

Zeitersparnis in der Praxis

Teams die Custom Commands für ihre Standard-Workflows einsetzen berichten von 30–50% weniger Zeit für repetitive Aufgaben wie Deploy-Vorbereitung, Migrations-Handling und PR-Reviews. Der Aufwand für einen neuen Custom Command: unter 15 Minuten.

4. Team Commands: Shared Workflows im Git-Repo

Custom Commands in .claude/commands/ werden mit dem Git-Repository eingecheckt — damit teilst du deine Commands automatisch mit dem gesamten Team. Kein separates Setup, keine Dokumentation nötig: jeder der git pull macht, hat sofort alle Team-Commands verfügbar.

Versionierung und Pflege

Command entwickeln

→

In .claude/commands/ ablegen

→

git commit + push

→

Team hat Command sofort

Team

Shared Prompt Library

Behandle .claude/commands/ wie deine interne Prompt-Library. Jede Datei ist versioniert, reviewbar und iterierbar. Gute Commands entstehen iterativ: erst grob schreiben, dann nach Feedback von Teamkollegen verfeinern. Nach 3–4 Iterationen sind die Commands so präzise dass Claude zuverlässig das Gewünschte macht.

Team-Workflow: Empfohlene Command-Sammlung

.claude/commands/ ├── deploy-staging.md # /deploy-staging — Staging Deploy ├── deploy-prod.md # /deploy-prod — Prod Deploy + Rollback ├── create-component.md # /create-component $NAME ├── create-api-route.md # /create-api-route $NAME ├── db-migrate.md # /db-migrate $NAME ├── db-seed.md # /db-seed — Testdaten einspielen ├── pr-review.md # /pr-review $PR_NUMBER ├── release-notes.md # /release-notes — Changelog generieren ├── security-audit.md # /security-audit — OWASP Check └── onboard.md # /onboard — Setup für neue Devs

Der onboard-Command: Neues Teammitglied in 5 Minuten

Ein besonders wertvoller Team-Command ist onboard.md: Er erklärt neuen Entwicklern automatisch die Projekt-Architektur, zeigt wichtige Konfigurationsdateien, erklärt Namenskonventionen und listet die wichtigsten Custom Commands auf. Kein händisches Onboarding mehr.

# .claude/commands/onboard.md

---
description: "Erklärt das Projekt für neue Teammitglieder"
allowed-tools: ["Read", "Glob", "Bash"]
---

Begrüße den neuen Entwickler und führe durch das Projekt:

1. Lies `README.md`, `CLAUDE.md`, `package.json`
2. Erkläre die Ordnerstruktur: src/, tests/, scripts/
3. Zeige die wichtigsten npm-Scripts und was sie tun
4. Erkläre die Custom Commands in `.claude/commands/`
5. Zeige wie Branches benannt werden (z.B. feature/JIRA-123-beschreibung)
6. Erkläre den PR-Prozess und Merge-Kriterien
7. Checke ob alle Dependencies installiert sind: `npm install`
8. Führe erste Tests aus: `npm test`

Am Ende: Zeige 3 gute erste Tasks für neue Entwickler.

Achtung: allowed-tools bewusst setzen

Commands mit allowed-tools: ["Bash"] können beliebige Shell-Befehle ausführen. Für Team-Commands empfiehlt sich ein Review im Code-Review-Prozess — genau wie bei anderen Scripts. Gib nur die Werkzeuge frei die der Command wirklich braucht.

5. CLAUDE.md Integration: Kontext trifft Commands

CLAUDE.md und Custom Commands sind kein getrenntes System — sie arbeiten zusammen. Claude liest CLAUDE.md automatisch beim Start jeder Session und kennt damit den Projektkontext wenn dein Custom Command ausgeführt wird.

CLAUDE.md als Grundlage für Commands

# .claude/CLAUDE.md — Projekt-Kontext

## Projekt: E-Commerce Backend

### Stack
- Runtime: Bun 1.2, TypeScript 5.4
- Framework: Hono.js
- Datenbank: PostgreSQL 16 via Prisma ORM
- Tests: Vitest + Supertest für API-Tests
- Deploy: Docker → Kubernetes (namespace: ecommerce-prod)

### Konventionen
- Branches: `feature/SHOP-{nummer}-{beschreibung}`
- Commit-Format: `[type] SHOP-{nummer}: kurze Beschreibung`
- API-Routen: REST, kebab-case URLs, Versionierung via Header
- Fehlerhandling: NIEMALS stumme Catches — immer loggen

### Custom Commands verfügbar
- `/deploy-staging` — Deploy auf Staging (requires VPN)
- `/create-component` — React-Komponente mit Tests
- `/db-migrate` — Prisma Migration erstellen + ausführen
- `/pr-review` — PR-Review via GitHub CLI

Wenn du nun /create-component ProductCard aufrufst, weiß Claude bereits: TypeScript, Vitest für Tests, Hono.js ist kein React-Projekt (also keine JSX-Komponenten im Backend), und Commits folgen dem SHOP-Format. Der Custom Command muss das nicht nochmals erklären.

Startup Commands in CLAUDE.md

In CLAUDE.md kannst du auch Startup-Verhalten definieren — was Claude beim Session-Start automatisch tun soll:

# .claude/CLAUDE.md — Startup-Sektion

## Session-Start (automatisch ausführen)

Bei jeder neuen Session:
1. `git status` — prüfe ob uncommittete Änderungen vorhanden
2. `npm run typecheck 2>&1 | tail -5` — TypeScript-Fehler checken
3. Falls Fehler: sofort melden, BEVOR anderer Task begonnen wird
4. Zeige aktuellen Branch und letzten Commit

## Pflicht-Regeln
- NIEMALS `any` in TypeScript verwenden
- NIEMALS Migrations ohne Backup-Check ausführen
- IMMER Tests nach Code-Änderungen ausführen
- Commit-Message auf Englisch

Built-inCustom

Commands + CLAUDE.md: Das Zusammenspiel

CLAUDE.md definiert das Was (Kontext, Regeln, Stack) — Custom Commands definieren das Wie (konkrete Workflows). Zusammen entsteht ein System das Claude in deinem Projektkontext agieren lässt als würde es das Projekt seit Monaten kennen. Neue Teammitglieder profitieren sofort vom akkumulierten Kontextwissen.

6. Hooks & Automatisierung: PreToolUse / PostToolUse

Hooks sind die fortgeschrittenste Automatisierungsebene in Claude Code. Sie werden in settings.json konfiguriert und feuern automatisch vor oder nach Werkzeug-Aufrufen — ohne dass du einen Slash Command eingeben musst.

Hook-Typen

Hook	Wann er feuert	Typischer Einsatz
PreToolUse	Bevor Claude ein Werkzeug aufruft	Validierung, Safety-Checks, Logging
PostToolUse	Nachdem ein Werkzeug erfolgreich war	Format-on-save, Lint-Trigger, Notifications
PreSessionStart	Beim Start jeder Session	Environment-Setup, Dependency-Check
PostSessionEnd	Beim Beenden der Session	Cleanup, Summarizing, Reporting

Hooks konfigurieren: settings.json

// .claude/settings.json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$TOOL_INPUT_FILE_PATH\" 2>/dev/null || true"
          }
        ]
      },
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx eslint --fix \"$TOOL_INPUT_FILE_PATH\" 2>/dev/null || true"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo \"[$(date -u +%H:%M:%S)] Bash: $TOOL_INPUT_COMMAND\" >> /tmp/claude-audit.log"
          }
        ]
      }
    ]
  }
}

Dieses Beispiel macht Folgendes: Jedes Mal wenn Claude eine Datei schreibt, wird Prettier und ESLint automatisch darüber laufen. Jeder Bash-Befehl wird in ein Audit-Log geschrieben. Du musst nie wieder manuell formatieren oder dich fragen was Claude in der Shell gemacht hat.

Praktischer Hook: TypeScript-Fehler sofort prüfen

// PostToolUse Hook — TypeScript nach jeder Write-Operation prüfen
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx tsc --noEmit 2>&1 | head -20"
          }
        ]
      }
    ]
  }
}

Hook

Format-on-Save: Automatisch und unsichtbar

Mit dem PostToolUse Write-Hook läuft Prettier automatisch nach jeder Datei-Änderung durch Claude. Das bedeutet: Claude schreibt Code in seinem Format, Prettier bringt ihn sofort in Projekt-Standard. Kein manuelles npm run format, kein "vergessen zu formatieren" vor dem Commit mehr.

Sicherheits-Hook: Gefährliche Befehle abfangen

# PreToolUse Safety-Hook via Shell-Script
#!/bin/bash
# .claude/hooks/pre-bash-check.sh

COMMAND="$TOOL_INPUT_COMMAND"

# Blockiere gefährliche Befehle
if echo "$COMMAND" | grep -qE "(rm -rf /|DROP TABLE|DELETE FROM [a-z]+ WHERE 1)"; then
  echo "BLOCKED: Gefährlicher Befehl erkannt: $COMMAND" >&2
  exit 1
fi

# Produktionsdatenbank-Schutz
if echo "$COMMAND" | grep -q "prod-db" && [ "$NODE_ENV" != "production" ]; then
  echo "BLOCKED: Prod-DB-Zugriff nur aus Production-Environment erlaubt" >&2
  exit 1
fi

exit 0

// settings.json — Safety-Hook einbinden
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/pre-bash-check.sh"
          }
        ]
      }
    ]
  }
}

Wenn der Hook mit Exit-Code 1 beendet wird, bricht Claude den Werkzeug-Aufruf ab und erklärt dem Benutzer warum. So verhinderst du destruktive Aktionen — auch in automatisierten Workflows.

Best Practices für Hooks

Idempotent gestalten: Hooks laufen oft — sie müssen bei mehrfacher Ausführung dasselbe Ergebnis liefern
Fail fast: Hooks die scheitern sollen mit Exit-Code 1 beenden und eine klare Fehlermeldung ausgeben
Nicht blockieren: Langsame Hooks (>2s) verlangsamen Claude — asynchron loggen wenn möglich
Minimal halten: Jeder Hook ist ein potenzieller Failure-Point — nur nötige Checks einbauen
In Git einchecken: .claude/settings.json gehört ins Repo damit das Team dieselben Hooks hat

Hooks in CI/CD-Umgebungen

In CI-Pipelines (GitHub Actions, GitLab CI) werden Hooks aus .claude/settings.json nur ausgeführt wenn Claude Code explizit im non-interaktiven Modus gestartet wird. Prüfe mit claude --doctor ob Hooks korrekt geladen werden.

Fazit: Slash Commands als Team-Multiplier

Slash Commands — built-in wie custom — sind kein Nice-to-have. Sie sind der Unterschied zwischen Claude Code als "schlaues Autocomplete" und Claude Code als vollständigem Entwickler-Workflow-System.

Die Progression ist logisch: Erst Built-in Commands für Grundaufgaben nutzen. Dann Custom Commands für projekt-spezifische Workflows schreiben. Commands ins Git einchecken damit das Team profitiert. Hooks für automatische Qualitäts-Gates einrichten. Am Ende entsteht ein System das Konventionen durchsetzt, Workflows automatisiert und Wissen kodiert — ohne dass jemand es aktiv erklären muss.

Der Einstieg ist einfach: Schreib heute einen Custom Command für deinen häufigsten Workflow. Wahrscheinlich sparst du morgen schon 20 Minuten.

Claude Code für dein Team einrichten?

SpockyMagicAI zeigt dir wie du Custom Commands, CLAUDE.md und Hooks zu einem kompletten Workflow-System verbindest — fertig konfiguriert für dein Projekt.

Kostenlos testen →