12 Claude Code-Features: detaillierte Erklärung mit Beispielen

1. Übersicht

Claude Code ist ein Coding Agent, der im Terminal läuft und deinen Code lesen, bearbeiten, Befehle ausführen und selbst überprüfen kann. Das Problem ist: Der Agent ist mächtig, aber bei Standardeinstellungen geht er leicht „verloren” – bearbeitet die falschen Dateien, verbraucht das gesamte Context Window, oder führt gefährliche Befehle aus. Dieser Artikel erklärt 12 Funktionen, mit denen du diesen Agent gezielt kontrollierst. Nach dem Lesen wirst du wissen, wie du CLAUDE.md, Permissions, Hooks, MCP … konfigurierst, damit Claude Code gemäß den Konventionen deines Teams an einem Beispiel-Spring-Boot-Projekt mit Order, Customer, PaymentService arbeitet.

2. CLAUDE.md

CLAUDE.md ist eine Memory-Datei, die Claude Code automatisch am Anfang jeder Session liest. Hier deklarierst du Code-Konventionen, Verzeichnisstruktur, Build-Befehle, Style Guide – damit der Agent nicht jedes Mal nachfragen muss.

# CLAUDE.md

## Architektur
- Package `com.nonladev.order`: Domain Order, Customer
- Package `com.nonladev.payment`: PaymentService, PaymentGateway (Interface)

## Konventionen
- Immer JUnit 5 + AssertJ Tests für neue öffentliche Methoden schreiben
- Niemals `@Autowired` Field Injection verwenden, nur Constructor Injection
- `mvn verify` ausführen, bevor du "fertig" meldest

## Häufig verwendete Befehle
- Build: `mvn -q clean verify`
- Lokal ausführen: `mvn spring-boot:run`

Claude liest diese Datei, bevor er eine Task in der Session ausführt. Wenn du aufforderst „Refund-Methode für PaymentService hinzufügen”, weiß der Agent automatisch, dass er Constructor Injection verwenden und Tests schreiben soll – ohne dass du es wiederholst.

Hinweis: Füge nicht zu viele Details zu CLAUDE.md hinzu. Eine lange Datei verschwendet das Context Window gleich zu Beginn der Session, während die meisten Inhalte nicht relevant für die aktuelle Task sind.

3. Permissions

Permissions kontrollieren, welche Tools Claude verwenden darf und welche blockiert sind – wichtig, da der Agent echte Shell-Befehle ausführen kann.

{
  "permissions": {
    "allow": [
      "Bash(mvn *)",
      "Edit(src/main/java/**)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Edit(src/main/resources/application-prod.properties)"
    ]
  }
}

Diese Datei settings.json liegt im Ordner .claude/. Die allow-Zeile erlaubt dem Agent, mvn-Befehle auszuführen und Dateien in src/main/java zu bearbeiten. Die deny-Zeile sperrt Befehle zum rekursiven Löschen und den Zugriff auf die Production-Config-Datei absolut. Wenn Claude eine Berechtigung überschreiten möchte, fragt er dich zur Bestätigung.

Häufiger Fehler: Permissions zu offen setzen (allow: ["*"]) lässt den Agent jeden Befehl ohne Nachfrage ausführen – gefährlich für sensible Config-Dateien oder Secrets.

4. Plan Mode

Plan Mode zwingt Claude, seinen Plan vor der Code-Änderung zu erklären. Du überprüfst den Plan, bearbeitest ihn falls nötig, dann startest du die Ausführung.

> Teilweise Rückerstattung für PaymentService hinzufügen

[PLAN MODE]
1. Methode refundPartial(Order order, BigDecimal amount) zu PaymentService hinzufügen
2. Validieren: amount <= order.getTotalPaid()
3. PaymentGateway.refund(...) aufrufen
4. PaymentServiceTest für 2 Fälle schreiben: gültig, Betrag überschreitet Limit

Möchtest du diesen Plan ausführen? [y/n/edit]

Wenn du edit antwortest, bearbeitet Claude den Plan nach deinen Vorschlägen (z. B. Audit-Logging hinzufügen) vor der tatsächlichen Code-Änderung. Das ist besonders nützlich für Tasks, die viele Dateien ändern – du erkennst falsche Richtungen schon in der Plan-Phase, nicht nach dem Chaos im Source Code.

5. Checkpoints

Checkpoints sind automatische Snapshots des Projekts an wichtigen Punkten in der Session und lassen dich „zurückspulen”, falls der Agent etwas kaputt macht.

# Session-Checkpoint-Verlauf ansehen
/rewind

# Output
Checkpoint 1 - 10:02 - vor PaymentService-Änderung
Checkpoint 2 - 10:05 - nach refundPartial hinzugefügt
Checkpoint 3 - 10:09 - nach Test-Änderung (fehlerhaft)

# Zurück zu Checkpoint 2
/rewind 2

Anders als Git Commits erstellt Claude Code Checkpoints automatisch – du musst sie nicht manuell anlegen. Wenn der Agent Tests falsch bearbeitet (z. B. Assertions auskommentiert, damit sie „bestehen”), spulst du zurück, ohne manuell git reset zu tippen.

Hinweis: Checkpoints existieren nur in der aktuellen Session, nicht als Ersatz für Git. Committe dennoch echte Code, wenn du einen Milestone erreichst.

6. Skills

Skills sind wiederverwendbare Richtlinien-Dateien, die Claude automatisch anwendet, wenn die Task passt – du musst den Namen nicht jedes Mal nennen.

---
name: spring-boot-test-writer
description: Verwende dies, um Tests für Service-Layer in Spring-Boot-Projekten zu schreiben
---

Beim Schreiben von Tests für eine Service-Klasse:
1. JUnit 5 + AssertJ verwenden, nicht Hamcrest
2. Dependencies mit Mockito mocken, Variable heißt `mock<Dependency>`
3. Test-Methoden nach Schema `should_<expected>_when_<condition>` benennen

Diese Datei liegt in .claude/skills/spring-boot-test-writer.md. Wenn du aufforderst „Tests für PaymentService schreiben”, erkennt Claude die passende Skill und wendet die Convention an:

class PaymentServiceTest {

    private final PaymentGateway mockGateway = mock(PaymentGateway.class);
    private final PaymentService paymentService = new PaymentService(mockGateway);

    @Test
    void should_refundAmount_when_amountIsWithinPaidTotal() {
        Order order = new Order("ORD-1", BigDecimal.valueOf(200));

        paymentService.refundPartial(order, BigDecimal.valueOf(50));

        verify(mockGateway).refund(order.getId(), BigDecimal.valueOf(50));
    }

    @Test
    void should_throwException_when_amountExceedsPaidTotal() {
        Order order = new Order("ORD-2", BigDecimal.valueOf(100));

        assertThatThrownBy(() -> paymentService.refundPartial(order, BigDecimal.valueOf(150)))
            .isInstanceOf(IllegalArgumentException.class);
    }
}

Skills unterscheiden sich von CLAUDE.md: CLAUDE.md wird immer geladen, Skills nur wenn nötig – spart Context Window für Projekte mit vielen spezialisierten Konventionen.

7. Hooks

Hooks führen deine Shell-Skripte an bestimmten Punkten in Claudes Lifecycle aus, z. B. PreToolUse (vor Tool-Aufruf) oder PostToolUse (nach Tool-Aufruf).

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "command": "mvn -q -pl . checkstyle:check"
      }
    ]
  }
}

Jedes Mal, wenn Claude eine Datei fertig bearbeitet hat (Edit Tool), lädt der Hook automatisch checkstyle:check. Falls der Befehl fehlschlägt, bekommt Claude die Ausgabe, repariert den Code und führt Check erneut aus – ohne dass du manuell eingreifst.

[PostToolUse] mvn checkstyle:check
ERROR: PaymentService.java:42: Zeile ist länger als 120 Zeichen
→ Claude kürzt Zeile 42 und führt Check erneut aus

Wann nicht verwenden: Hooks laufen bei jedem Tool-Aufruf. Ein aufwändiges Skript (vollständiger Build) macht die Session langsam. Hook nur für schnelle Checks verwenden.

8. MCP

MCP (Model Context Protocol) verbindet Claude mit externen Systemen – Datenbank, interne API, Issue Tracker – als standardisiertes Tool.

{
  "mcpServers": {
    "postgres-orders": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://localhost:5432/orders_db"]
    }
  }
}

Nach Registrierung in .claude/settings.json kannst du direkt fragen:

> Wie viele Orders im Status PENDING sind in der Tabelle orders?

[MCP: postgres-orders] SELECT COUNT(*) FROM orders WHERE status = 'PENDING';
→ 37 Orders warten auf Verarbeitung

Claude generiert SQL, ruft es über MCP auf und bekommt echte Daten von der Datenbank – ohne manuell Queries in Terminal zu kopieren.

9. Plugins

Plugins sind vorgefertigte Bundles, die Skills, MCP Server und Hooks zusammenfassen. Eine Installation statt mehrere einzelne Konfigurationen.

/plugin install spring-boot-toolkit

Dieser Befehl installiert ein Plugin mit: Skill für Spring-Boot-Tests, Hook für mvn verify nach jeder Edit, und MCP Server für Spring Boot Actuator. Statt 3 separate Konfigurationsdateien schreiben (Skill, Hook, MCP) packst du alles in ein Plugin, das du mit Teams teilen kannst.

10. Context

Context ist das aktuelle Context Window deiner Session – alle gelesenen Dateien, Gesprächsverlauf, Command Output. /context zeigt dir die aktuelle Nutzung.

/context

Context-Nutzung: 48.200 / 200.000 Token (24%)
- CLAUDE.md: 1.200 Token
- Dateien gelesen: PaymentService.java, Order.java, PaymentServiceTest.java (6.400 Token)
- Gesprächsverlauf: 38.000 Token
- Tool-Ausgaben: 2.600 Token

Wenn der Gesprächsverlauf den Großteil nimmt, weißt du, dass du komprimieren oder eine neue Session starten solltest – sonst vergisst Claude wichtige frühere Details.

11. Slash Commands

Slash Commands sind Shortcuts für oft wiederholte Tasks – tippe / und den Namen, nicht die lange Eingabeaufforderung jedes Mal neu.

---
name: review-pr
description: Review aktuellen Diff mit Standard-Checkliste
---

Review Code-Diff mit Checkliste:
1. Gibt es Tests für neue Logik?
2. Werden sensible Daten geloggt (Kartennummer, Passwort)?
3. Wird Constructor Injection Convention eingehalten?

Antworte mit: PASS/FAIL für jeden Punkt mit Begründung.

Speichere in .claude/commands/review-pr.md, dann aufrufen:

/review-pr

1. PASS - PaymentServiceTest existiert für refundPartial
2. FAIL - log.info enthält order.getCardNumber() auf Zeile 58
3. PASS - Constructor Injection verwendet

Slash Commands unterscheiden sich von Skills: Skills aktivieren automatisch, Commands brauchst du bewusst – passend für feste Checklisten wie PR Review.

12. Compaction

Compaction komprimiert lange Gesprächsverläufe zu einer Zusammenfassung, gibt Token frei ohne wichtige Info zu verlieren.

/compact

Vor Compaction: 182.000 / 200.000 Token
Nach Compaction:  24.000 / 200.000 Token

Zusammenfassung behält:
- Aktuelle Task: refundPartial zu PaymentService hinzufügen
- Abgeschlossen: PaymentServiceTest (2 Test Cases bestanden)
- Ausstehend: OpenAPI-Spec für /refund-Endpoint aktualisieren

Statt dass Claude alles vergisst wenn Context voll wird, behält Compaction Meilensteine (aktive Task, Abgeschlossenes, Ausstehend) als kurze Zusammenfassung. Rufe /compact bewusst auf nach jeder großen Teil-Task, bevor du zur nächsten wechselst.

13. Subagents

Subagents lassen Claude mehrere Agent-Prozesse parallel starten – jeder mit eigenem Aufgabenbereich in einem größeren Workflow.

---
name: test-writer
description: Spezialisiert auf Unit Tests für die angegebene Klasse
tools: Read, Edit, Bash
---

Schreibe nur Tests, bearbeite keine Business-Logik. JUnit 5 + AssertJ verwenden.

Mit dieser Subagent-Definition in .claude/agents/test-writer.md kannst du eine große Task zuweisen und Claude verteilt automatisch:

> Refund-Modul fertigstellen: Logik hinzufügen, Tests schreiben, Docs aktualisieren

[Main Agent] Verteile auf 3 parallele Subagents:
  → subagent "code-writer": refundPartial zu PaymentService hinzufügen
  → subagent "test-writer": PaymentServiceTest schreiben
  → subagent "doc-writer": README.md aktualisieren

[3 Subagents laufen parallel] ... fertig nach 42s

Statt sequenziell (Code → Test → Docs, dreifache Zeit) arbeiten unabhängige Tasks gleichzeitig – besonders für Workflows ohne enge Abhängigkeiten.

Wann nicht verwenden: Wenn Schritte sequenziell abhängig sind (Tests brauchen fertigen Code), macht Parallelität Fehler. Nur für wirklich unabhängige Tasks einsetzen.

14. Fazit

Die 12 Funktionen teilen sich in drei Gruppen auf: Gruppe Agent-Lenkung (CLAUDE.md, Skills, Plan Mode), Gruppe Sicherheit (Permissions, Checkpoints, Hooks), Gruppe Fähigkeiten-Erweiterung (MCP, Plugins, Subagents). Context, Slash Commands und Compaction sind die Infrastruktur für lange effiziente Sessions. Du musst nicht alle 12 gleichzeitig verwenden – starte mit CLAUDE.md und Permissions, dann füge Hooks oder MCP hinzu, wenn dein echte Workflow danach verlangt.