So automatisieren Sie Refactoring mit Claude Code

Warum Refactoring mit Claude Code?

Jeder weiß, dass Refactoring wichtig ist, aber manuell ist es mühsam und wird oft aufgeschoben. Claude Code versteht Ihr gesamtes Projekt und kann Refactoring eigenständig über mehrere Dateien hinweg durchführen.

Muster 1: Typsicherheit verbessern

any-Typen eliminieren

> Durchsuche das Projekt nach allen any-Typen und ersetze sie durch passende Typen.
> Überprüfe nach den Änderungen, dass npx tsc --noEmit durchläuft.

So geht Claude Code vor:

1. Sucht nach Dateien, die any-Typen enthalten
2. Leitet passende Typen aus dem umgebenden Code ab
3. Erstellt bei Bedarf Typ-Definitionsdateien
4. Führt den Typ-Checker aus, um die Kompilierung zu überprüfen

Vorher und Nachher

// Vorher
function processData(data: any): any {
  return data.items.map((item: any) => item.name);
}

// Nachher
interface DataPayload {
  items: Array<{ name: string; id: number }>;
}

function processData(data: DataPayload): string[] {
  return data.items.map((item) => item.name);
}

Muster 2: Funktionen aufteilen und Zuständigkeiten klären

Das Aufteilen überdimensionierter Funktionen ist eine Aufgabe, die Claude Code besonders gut bewältigt.

> Die Funktion createOrder in src/services/orderService.ts hat über 200 Zeilen.
> Teile sie in kleinere Funktionen auf, die dem Single-Responsibility-Prinzip folgen.
> Stelle sicher, dass die bestehenden Tests weiterhin bestehen.

Prompt zum Aufteilen

> Teile die Funktion nach diesen Richtlinien auf:
> - Jede Funktion sollte maximal 30 Zeilen haben
> - Trenne Validierung, Geschäftslogik und Persistenz
> - Füge JSDoc-Kommentare zu jeder Funktion hinzu
> - Passe die Tests an die neuen Funktionsgrenzen an

Muster 3: Fehlerbehandlung standardisieren

Vereinheitlichen Sie Fehlerbehandlungsmuster im gesamten Projekt.

> Standardisiere die Fehlerbehandlung im gesamten Projekt:
> - Verwende eine eigene Fehlerklasse (AppError)
> - Definiere Fehlercodes als Konstanten
> - Füge in try-catch-Blöcken immer Logging hinzu

Hier ein Beispiel, was Claude Code generiert:

// src/errors/app-error.ts
export class AppError extends Error {
  constructor(
    public readonly code: string,
    message: string,
    public readonly statusCode: number = 500,
    public readonly cause?: Error
  ) {
    super(message);
    this.name = 'AppError';
  }
}

// Fehlercode-Konstanten
export const ErrorCodes = {
  USER_NOT_FOUND: 'USER_NOT_FOUND',
  INVALID_INPUT: 'INVALID_INPUT',
  DB_CONNECTION_ERROR: 'DB_CONNECTION_ERROR',
} as const;

Muster 4: Tests hinzufügen und verbessern

Tests dort hinzufügen, wo die Abdeckung mangelhaft ist.

# Coverage-Berichte zur Steuerung der Test-Ergänzungen nutzen
npx vitest run --coverage | claude -p "Identifiziere Dateien mit niedriger Coverage und füge die fehlenden Testfälle hinzu"

> Bringe die Testabdeckung für alles unter src/services/ auf mindestens 80 %.
> Decke nicht nur Happy Paths ab, sondern auch Grenzfälle und Fehlerszenarien.

Muster 5: API-Antwortformate standardisieren

> Standardisiere alle API-Endpunkt-Antworten auf dieses Format:
>
> Erfolg: { success: true, data: T }
> Fehler: { success: false, error: { code: string, message: string } }
>
> Aktualisiere den Frontend-Code entsprechend dem neuen Format.

Tipps für sicheres Refactoring

1. Tests zuerst überprüfen

> Führe zuerst npm test aus und stelle sicher, dass alle bestehenden Tests bestehen.
> Wenn Tests fehlschlagen, melde sie, bevor du Änderungen vornimmst.

2. Schrittweise vorgehen

Refaktorisieren Sie Modul für Modul, statt alles auf einmal.

> Beginne mit dem Refactoring von nur src/services/userService.ts.
> Überprüfe, dass die Tests nach den Änderungen bestehen, bevor du weitermachst.

3. Den Diff überprüfen

> Zeig mir den git diff. Wenn er zu groß ist, fasse die Änderungen dateiweise zusammen.

4. Einen separaten Branch verwenden

git checkout -b refactor/error-handling
claude
> Starte das Refactoring der Fehlerbehandlung...

Praxisbeispiel: Legacy-Code modernisieren

So modernisieren Sie eine ältere Codebasis schrittweise:

> Modernisiere dieses Projekt mit folgenden Änderungen:
> 1. Ersetze var durch const/let
> 2. Konvertiere Callback-Funktionen zu async/await
> 3. Konvertiere require zu import
> 4. Überprüfe nach jeder Änderung, dass die Tests bestehen
> 5. Gehe Schritt für Schritt vor und berichte die Ergebnisse bei jeder Etappe

Fazit

Mit Claude Code kann Refactoring, das früher Tage dauerte, in Stunden erledigt werden. Die Schlüssel sind: spezifische Regeln vorgeben, schrittweise vorgehen und immer mit Tests validieren. Beginnen Sie mit einem kleinen Modul und überzeugen Sie sich selbst von den Ergebnissen.