Agentische KI-Codewerkzeuge

KI-Programmierassistenten haben sich von einfacher Autovervollständigung zu autonomen Agenten entwickelt, die planen, mehrere Dateien bearbeiten, Tests ausführen und Pull Requests erstellen können. Dieses Tutorial behandelt die drei wichtigsten Werkzeuge: Claude Code, Cursor und GitHub Copilot.

1) Was macht ein Werkzeug „agentisch“?

Herkömmliche KI-Codevervollständigung schlägt die nächsten Zeilen vor. Agentische Werkzeuge gehen weiter:

Fähigkeit	Autovervollständigung	Agentisch
Umfang	Aktuelle Zeile/Funktion	Gesamte Codebasis
Planung	Keine	Mehrstufiges Schlussfolgern
Ausführung	Nur Vorschläge	Kann Dateien bearbeiten und Befehle ausführen
Kontext	Aktuelle Datei	Verständnis des gesamten Repositorys
Workflow	Reaktiv	Autonome Aufgabenerledigung

Agentische Werkzeuge können deine gesamte Projektstruktur verstehen, Änderungen über mehrere Dateien hinweg planen, diese Änderungen ausführen, Tests starten und iterieren, bis die Aufgabe abgeschlossen ist.

2) Kurzer Vergleich: Claude Code vs. Cursor vs. Copilot

Funktion	Claude Code	Cursor	GitHub Copilot
Oberfläche	CLI, Web, IDE-Plugins	Vollständige IDE (VS-Code-Fork)	IDE-Erweiterungen
Kontextfenster	Groß (Opus mit langem Kontext)	Indexierung des gesamten Repositorys	Kleiner, wird verbessert
Bearbeitung mehrerer Dateien	Stark	Hervorragend	Wird verbessert
Planungsmodus	Ja	Ja	Ja (neuer)
Preismodell	Pro-/Max-Tarife	Credits + Abonnement	Abonnement
Am besten geeignet für	Architektur, große Refactorings	Interaktive Entwicklung	Programmieren direkt im Editor

3) Grundlagen von Claude Code

Claude Code läuft auf Opus 4.8 (dem derzeitigen Standardmodell) und bietet große Kontextfenster. So installierst und authentifizierst du es:

# Claude Code installieren (nativer Installer, empfohlen)
curl -fsSL https://claude.ai/install.sh | bash

# Oder über npm (erfordert Node 18+)
npm install -g @anthropic-ai/claude-code

# Authentifizieren: claude ausführen und der Aufforderung im Browser folgen
claude

# In deinem Projekt starten
cd your-project
claude

Grundlegende Befehle

# Fragen zu deiner Codebasis stellen
claude "Wie ist die Authentifizierung hier implementiert?"

# Code generieren
claude "Füge eine Rate-Limiter-Middleware hinzu"

# Refactoring über mehrere Dateien
claude "Benenne UserService in der gesamten Codebasis in AuthService um"

# Einen PR erstellen
claude "Erstelle einen PR, der allen API-Endpunkten eine Eingabevalidierung hinzufügt"

Projektkonfiguration

Lege den Projektkontext in einer CLAUDE.md-Datei im Stammverzeichnis deines Repositorys ab. Claude Code liest sie automatisch zu Beginn jeder Sitzung:

# Projekthinweise

- Sprache: TypeScript, mit Prettier formatiert
- Tests: Vitest, in tests/
- node_modules/ und dist/ nicht verändern

Maschinenlesbare Einstellungen (Werkzeugberechtigungen, Umgebungsvariablen, Hooks) gehören in .claude/settings.json. Um beispielsweise vor der Ausführung destruktiver Werkzeuge eine Genehmigung zu verlangen, konfigurierst du dort die Berechtigungen.

Gedächtnis und Kontext

Dauerhafter Projektkontext befindet sich in CLAUDE.md-Dateien, die Claude Code zu Beginn jeder Sitzung lädt, sowie in einem automatischen Gedächtnisspeicher, den Claude anhand deiner Korrekturen und Präferenzen selbst aktualisiert. Um dauerhaften Kontext bereitzustellen, bearbeitest du CLAUDE.md, statt eine einmalige „Merke dir:“-Anweisung zu übergeben:

# CLAUDE.md
Dies ist ein Monorepo. Gemeinsam genutzter Code befindet sich in packages/.

Verwende innerhalb einer Sitzung den Befehl /clear, um den Arbeitskontext zurückzusetzen.

4) Agentische Funktionen der Cursor-IDE

Cursor wurde rund um agentische Workflows entwickelt. Zu den wichtigsten Funktionen gehören:

Agentenmodus

Drücke Cmd+Shift+I (Mac) oder Ctrl+Shift+I (Windows/Linux), um Composer im Agentenmodus zu öffnen:

Workflow im Agentenmodus:
1. Beschreibe deine Aufgabe
2. Der Agent erstellt einen Plan
3. Du genehmigst oder änderst ihn
4. Der Agent führt die Änderungen aus
5. Überprüfen und iterieren

Planungsmodus

Verwende bei komplexen Aufgaben ausdrücklich den Planungsmodus:

@plan Füge eine Benutzerauthentifizierung mit folgenden Funktionen hinzu:
- JWT-Tokens
- Rotation von Refresh-Tokens
- Passwort-Hashing mit bcrypt
- Ratenbegrenzung für Anmeldeversuche

Der Agent wird:

1. Deinen bestehenden Code untersuchen
2. Einen detaillierten Implementierungsplan erstellen
3. Auf deine Genehmigung warten
4. Den Plan Schritt für Schritt ausführen

Kontext einfügen

Verwende @, um gezielten Kontext hinzuzufügen:

@file src/api/auth.ts
@folder src/middleware
@docs https://jwt.io/introduction

Implementiere eine Middleware zur JWT-Verifizierung nach diesen Mustern

Parallele Agenten

Führe mehrere Agenten gleichzeitig in verschiedenen Branches aus:

# In Cursor:
1. Befehlspalette öffnen
2. "Cursor: New Agent in Worktree"
3. Jeder Agent arbeitet isoliert
4. Ergebnisse nebeneinander vergleichen

Cursor 3 hat ein Agents Window eingeführt (öffne es mit Cmd+Shift+P und anschließend „Agents Window“), das mehrere Agenten parallel über lokale Checkouts, Git-Worktrees und Cloud-Umgebungen hinweg ausführt. Der Befehl /worktree startet jeden Agenten in einem eigenen isolierten Git-Worktree, während /best-of-n dieselbe Aufgabe mit mehreren Modellen ausführt, sodass du die Ergebnisse nebeneinander vergleichen kannst.

Regeln für Konsistenz

Erstelle .cursor/rules/project.mdc:

# Projektregeln

## Codestil
- TypeScript im Strict Mode verwenden
- Funktionale Komponenten bevorzugen
- Benannte Exporte statt Standardexporten verwenden

## Tests
- Jede Funktion benötigt Tests
- describe/it-Blöcke verwenden
- Externe Dienste mocken

## Sicherheit
- Niemals Geheimnisse committen
- Alle Benutzereingaben validieren
- Parametrisierte Abfragen verwenden

5) Agentische Funktionen von GitHub Copilot

Copilot hat sich über die Autovervollständigung hinaus weiterentwickelt:

Copilot Chat

Öffne den Chatbereich und verwende Slash-Befehle:

/explain - Ausgewählten Code erklären
/fix - Probleme in der Auswahl beheben
/tests - Tests generieren
/doc - Dokumentation hinzufügen

Coding-Agent (vom Issue zum Pull Request)

# Auf GitHub:
1. Ein GitHub-Issue öffnen
2. "Copilot" als Bearbeiter zuweisen
3. Der Coding-Agent arbeitet im Hintergrund:
   Er analysiert das Issue, bearbeitet Dateien und führt Tests aus
4. Er öffnet einen Pull Request zur Überprüfung

Dies unterscheidet sich vom Agentenmodus von Copilot innerhalb der IDE, der in VS Code oder JetBrains synchron an deiner Seite arbeitet.

Copilot teilt seine autonome Arbeit inzwischen in zwei Bereiche auf: Der Agentenmodus läuft synchron in deiner IDE (VS Code und JetBrains), entscheidet, welche Dateien bearbeitet werden müssen, führt Terminalbefehle aus und iteriert bei Fehlern. Der Coding-Agent läuft dagegen asynchron in der Cloud, übernimmt ein zugewiesenes Issue und liefert einen Pull Request, während du an etwas anderem arbeitest.

Inline-Vorschläge mit Kontext

Copilot liest deine Codebasis. Unterstütze es mit Kommentaren:

// Authentifizierungs-Middleware, die:
// - das JWT aus dem Authorization-Header extrahiert
// - die Token-Signatur validiert
// - den Benutzer an die Anfrage anhängt
// - bei einem ungültigen Token 401 zurückgibt
export function authMiddleware(req, res, next) {
  // Copilot generiert die Implementierung
}

6) Best Practices für alle Werkzeuge

Klare Prompts schreiben

❌ Schlecht: "Behebe den Fehler"

✅ Gut: "Behebe die Nullzeiger-Ausnahme in UserService.getById,
wenn der Benutzer nicht existiert. Gib null zurück, statt eine Ausnahme auszulösen."

❌ Schlecht: "Füge Tests hinzu"

✅ Gut: "Füge Unit-Tests für CartService hinzu, die Folgendes abdecken:
- Artikel zu einem leeren Warenkorb hinzufügen
- Artikel entfernen
- Summen mit Rabatten berechnen
- Grenzfall: negative Mengen"

Bei komplexen Aufgaben den Planungsmodus verwenden

Bei jeder Aufgabe, die mindestens 3 Dateien betrifft:

1. Zuerst nach einem Plan fragen
2. Den Plan überprüfen
3. Genehmigen oder ändern
4. Den Agenten die Aufgabe ausführen lassen
5. Änderungen vor dem Committen überprüfen

Architekturkontext bereitstellen

Informiere den Agenten vor größeren Arbeiten:

"Dies ist eine Microservices-Architektur:
- api-gateway: Leitet Anfragen weiter
- auth-service: JWT, Sitzungen
- user-service: Benutzer-CRUD
- notification-service: E-Mail, Push-Benachrichtigungen

Die Dienste kommunizieren über Redis Pub/Sub.
Die Datenbank ist PostgreSQL mit Prisma ORM."

Testgetriebene Entwicklung mit Agenten

1. Zuerst einen fehlschlagenden Test schreiben:
   "Schreibe einen Test für die Benutzerregistrierung, der eine E-Mail-Validierung erwartet"

2. Dem Agenten den fehlschlagenden Test zeigen:
   "Implementiere die Registrierung so, dass dieser Test erfolgreich ist"

3. Iterieren, bis alle Tests erfolgreich sind:
   "Behebe die verbleibenden Testfehler"

7) Sicherheitsaspekte

Agentische Werkzeuge haben echte Befugnisse. Setze Grenzen:

Genehmigungsschranken

// .claude/config.json
{
  "safety": {
    "requireApproval": [
      "rm",
      "git push",
      "npm publish",
      "database migrations",
      "env file changes"
    ]
  }
}

Sandboxing

# Agenten in isolierten Umgebungen ausführen
docker run -v $(pwd):/workspace -it claude-sandbox

# Oder Git-Worktrees zur Isolation verwenden
git worktree add ../feature-branch feature-branch

Vertrauliche Dateien

# .cursorignore / .claudeignore
.env
.env.*
secrets/
credentials/
*.pem
*.key

Alle Änderungen überprüfen

# Vor dem Akzeptieren von Änderungen des Agenten:
git diff --stat
git diff

# Interaktives Staging verwenden
git add -p

# Niemals ohne Überprüfung automatisch mergen

8) Bewährte Workflow-Muster

Muster 1: Erkunden, planen, ausführen

Sitzung 1: "Wie funktioniert das Zahlungssystem?"
           → Der Agent erkundet es, du lernst es kennen

Sitzung 2: "Was wäre erforderlich, um Stripe hinzuzufügen?"
           → Der Agent erstellt einen Plan

Sitzung 3: "Implementiere die Stripe-Integration"
           → Der Agent führt den Plan aus

Muster 2: Parallele Erkundung

# In Cursor mit parallelen Agenten:

Agent 1: "Implementiere Caching mit Redis"
Agent 2: "Implementiere Caching mit Memcached"
Agent 3: "Implementiere Caching mit einem In-Memory-LRU-Cache"

→ Implementierungen vergleichen und den besten Ansatz auswählen

Muster 3: Schrittweise Migration

Schritt 1: "Ermittle alle Verwendungen der veralteten API"
Schritt 2: "Erstelle einen Adapter für die neue API"
Schritt 3: "Migriere Modul A zur Verwendung des Adapters"
Schritt 4: "Migriere Modul B ..."
...
Schritt N: "Entferne den Adapter und verwende die neue API direkt"

Muster 4: Testorientierte Funktionsentwicklung

1. "Schreibe Akzeptanztests für die Bearbeitung von Benutzerprofilen"
2. "Schreibe Unit-Tests für die Profilvalidierung"
3. "Implementiere die Funktion so, dass die Tests erfolgreich sind"
4. "Füge Integrationstests hinzu"
5. "Führe ein Refactoring für bessere Verständlichkeit durch"

9) Wann welches Werkzeug verwenden?

Situation	Empfohlenes Werkzeug
Programmieren in Echtzeit, Inline-Unterstützung	GitHub Copilot
Große Refactorings, Architektur	Claude Code
Vollständige Entwicklungssitzung	Cursor
Kurze Fragen zum Code	Beliebige Chatoberfläche
PRs aus Issues erstellen	Copilot Workspace
Komplexe Änderungen über mehrere Dateien	Cursor Agent
API-Design, Dokumentation	Claude Code
Eine neue Codebasis kennenlernen	Cursor oder Claude Code

10) Effektivität messen

Verfolge diese Kennzahlen, um agentische Werkzeuge zu bewerten:

const metrics = {
  // Produktivität
  suggestionsAccepted: 'Prozentsatz der Vorschläge, die du übernommen hast',
  timeToFeature: 'Stunden vom Beginn bis zum gemergten PR',
  linesPerHour: 'Codegeschwindigkeit (mit Bedacht verwenden)',
  
  // Qualität
  bugsIntroduced: 'Fehler, die auf KI-generierten Code zurückzuführen sind',
  testCoverage: 'Testabdeckung des KI-generierten Codes',
  reviewChanges: 'Umfang deiner Änderungen an KI-Vorschlägen',
  
  // Kosten
  apiCosts: 'monatliche Ausgaben für KI-Werkzeuge',
  creditsUsed: 'verbrauchte Cursor-Credits',
  
  // Lernen
  newPatternsLearned: 'Techniken, die du von der KI gelernt hast',
  codebaseUnderstanding: 'wie gut dir die KI beim Verständnis der Codebasis geholfen hat',
}

11) Häufige Fallstricke

Dem Agenten zu sehr vertrauen

❌ Große Änderungen ohne Überprüfung akzeptieren
❌ Agenten destruktive Befehle ausführen lassen
❌ Code veröffentlichen, ohne ihn zu verstehen

✅ Jede Änderung überprüfen
✅ Verstehen, was du veröffentlichst
✅ Agenten als Mitwirkende und nicht als Ersatz verwenden

Kontextverschmutzung

❌ Riesige Prompts mit irrelevantem Kontext
❌ Kontext zwischen unabhängigen Aufgaben nicht löschen
❌ Generierte Dateien in den Kontext aufnehmen

✅ Prompts fokussiert halten
✅ Gezielte @file-Verweise verwenden
✅ Build-Artefakte ausschließen

Mehrdeutige Prompts

❌ "Mach es besser"
❌ "Behebe die Probleme"
❌ "Füge einige Tests hinzu"

✅ "Reduziere die Zeitkomplexität von O(n²) auf O(n log n)"
✅ "Behandle den null-Fall in Zeile 45 durch eine vorzeitige Rückgabe"
✅ "Füge Tests für Grenzfälle hinzu: leere Eingabe, maximale Länge, Unicode"

12) Checkliste für den Einstieg

## Einrichtungscheckliste

### Claude Code
- [ ] CLI installieren: `npm install -g @anthropic/claude-code`
- [ ] Authentifizieren: `claude login`
- [ ] `.claude/config.json` erstellen
- [ ] `.claudeignore` für vertrauliche Dateien hinzufügen

### Cursor
- [ ] Von cursor.com herunterladen
- [ ] VS-Code-Einstellungen importieren
- [ ] `.cursor/rules/` konfigurieren
- [ ] `Cmd+Shift+I` für den Agentenmodus lernen

### GitHub Copilot
- [ ] Erweiterung in deiner IDE installieren
- [ ] Copilot Chat aktivieren
- [ ] Copilot Workspace für Issues ausprobieren
- [ ] `.github/copilot-instructions.md` konfigurieren

### Alle Werkzeuge
- [ ] Genehmigungsschranken für destruktive Aktionen einrichten
- [ ] Ignore-Dateien für Geheimnisse erstellen
- [ ] Überprüfungsworkflow festlegen
- [ ] Kennzahlen vom ersten Tag an erfassen

Verwandte Themen

• Ein Webspiel veröffentlichen, das schnell lädt
• Web Workers für Spiellogik
• Game Jams & Hackathons — KI-Codewerkzeuge verändern, was in einem 48-stündigen Jam möglich ist
• Webspiel-Engines im Vergleich — eine Engine auswählen, die gut zu KI-gestützten Workflows passt