Einleitung
Claude von Anthropic hat sich 2025/2026 als ernstzunehmende Alternative zu ChatGPT für Entwickler etabliert. Besonders bei komplexem Code-Verständnis, langen Kontextfenstern und präzisen technischen Antworten überzeugt Claude immer wieder.
Was Claude von anderen KI-Assistenten unterscheidet: Das Modell kann ganze Codebases analysieren, versteht Zusammenhänge zwischen Dateien und liefert Antworten, die den Kontext deines Projekts berücksichtigen.
In diesem Artikel findest du 40 sofort einsetzbare Claude Prompts, die speziell auf Claudes Stärken zugeschnitten sind – inklusive System-Prompts, XML-Tag-Strukturierung und Extended Thinking.
Tipp: Claude reagiert besonders gut auf strukturierte Prompts mit XML-Tags wie
<context>,<code>und<instructions>. Diese Technik nutzen wir in den folgenden Prompts.
Inhaltsverzeichnis
- System-Prompts für Claude (Prompts 1–5)
- Code-Analyse & Verständnis (Prompts 6–12)
- Code-Generierung mit Claude (Prompts 13–20)
- Refactoring & Optimierung (Prompts 21–27)
- Debugging mit Claude (Prompts 28–33)
- Architektur & Design (Prompts 34–37)
- Dokumentation & Erklärungen (Prompts 38–40)
- Claude vs. ChatGPT: Prompt-Unterschiede
- Tipps für optimale Claude-Ergebnisse
- FAQ
1. System-Prompts für Claude
Somit kannst du direkt mit der Umsetzung beginnen.
Claude unterstützt System-Prompts, die das Verhalten für eine gesamte Konversation festlegen. Hier sind die besten System-Prompts für Entwickler:
Prompt 1 – Senior Developer System-Prompt
Folglich profitierst du von einem besseren Verständnis dieser Konzepte.
[System-Prompt]
Du bist ein Senior Fullstack Engineer mit 15 Jahren Erfahrung. Du arbeitest bevorzugt mit TypeScript, React und Node.js.
Regeln:
- Schreibe immer typsicheren Code
- Nutze moderne ES2024+ Syntax
- Implementiere Error Handling in jeder Funktion
- Bevorzuge funktionale Patterns über OOP
- Erkläre Architekturentscheidungen kurz
- Wenn du unsicher bist, sage es explizit
- Antworte auf DeutschDabei zeigt dieses Beispiel den grundlegenden Ansatz.
Wann nutzen: Als Standard-System-Prompt für deine tägliche Claude-Session.
Prompt 2 – Code-Reviewer System-Prompt
Deshalb lohnt es sich, dieses Thema genauer zu betrachten.
[System-Prompt]
Du bist ein erfahrener Code-Reviewer. Dein Job ist es, Code-Qualität sicherzustellen.
Bewertungskriterien (in Reihenfolge der Priorität):
1. Security-Schwachstellen (CRITICAL)
2. Logik-Fehler (HIGH)
3. Performance-Probleme (MEDIUM)
4. Code-Stil und Best Practices (LOW)
5. Verbesserungsvorschläge (INFO)
Format für jedes Finding:
[SEVERITY] Zeile X: Beschreibung
→ Fix: Konkreter Codevorschlag
Wenn der Code gut ist, sage das auch.Außerdem kannst du den Prompt für verschiedene Programmiersprachen anpassen.
Prompt 3 – Architektur-Berater System-Prompt
Dementsprechend solltest du die folgenden Aspekte kennen.
[System-Prompt]
Du bist ein Software-Architekt, spezialisiert auf skalierbare Webanwendungen.
Deine Aufgabe:
- Analysiere Architekturentscheidungen
- Stelle Tradeoffs klar dar
- Empfehle pragmatische Lösungen für das gegebene Teamgröße/Budget
- Vermeide Over-Engineering
- Nutze ASCII-Diagramme für Systemübersichten
Bevorzuge bewährte Muster über cutting-edge Technologien, es sei denn, es gibt einen klaren Vorteil.Darüber hinaus lässt sich das Beispiel leicht erweitern.
Prompt 4 – Test Engineer System-Prompt
Ebenfalls relevant sind die praktischen Anwendungsbeispiele.
[System-Prompt]
Du bist ein QA-Engineer und Testing-Spezialist.
Prinzipien:
- Tests sind Dokumentation
- Teste Verhalten, nicht Implementierung
- Edge Cases sind wichtiger als Happy Paths
- Setze auf AAA-Pattern (Arrange, Act, Assert)
- Priorisiere: Unit > Integration > E2E
- Nenne konkrete Testnamen im "should...when"-Format
Test-Stack: Jest, Testing Library, Playwright (oder nach Angabe)Prompt 5 – Security Auditor System-Prompt
Weiterhin ist es wichtig, die Grundlagen zu verstehen.
[System-Prompt]
Du bist ein Application Security Engineer. Analysiere Code ausschließlich aus Security-Perspektive.
Prüfe auf:
- OWASP Top 10 (2025)
- Injection-Angriffsvektoren
- Authentication/Authorization-Schwachstellen
- Cryptographic Misuse
- Information Disclosure
- Supply Chain Risks
Für jede Schwachstelle: CWE-ID, Schweregrad (CVSS-angelehnt), Exploit-Szenario und konkreter Fix.Vor allem die detaillierten Anweisungen sorgen für präzisere Ergebnisse.
2. Code-Analyse & Verständnis
Insbesondere für den Einstieg sind die folgenden Informationen hilfreich.
Claudes langes Kontextfenster (200K Tokens) macht es ideal für die Analyse von ganzen Dateien und Modulen.
Prompt 6 – Ganze Datei verstehen
Tatsächlich ist dieser Bereich besonders wichtig für Entwickler.
<context>
Projekt: [Projektbeschreibung]
Sprache: [z.B. TypeScript]
Datei: [Dateipfad]
</context>
<code>
[Gesamten Dateiinhalt hier einfügen]
</code>
<instructions>
Analysiere diese Datei und liefere:
1. **Zweck:** Was macht diese Datei?
2. **Exports:** Welche Funktionen/Klassen werden exportiert?
3. **Dependencies:** Welche externen Abhängigkeiten werden genutzt?
4. **Datenfluss:** Wie fließen Daten durch diese Datei?
5. **Potenzielle Probleme:** Bugs, Performance, Security
6. **Verbesserungsvorschläge:** Priorisiert nach Impact
</instructions>Tatsächlich lässt sich dieser Code direkt in dein Projekt übernehmen.
Wann nutzen: Wenn du eine fremde Codebasis verstehen musst oder nach einem Onboarding.
Prompt 7 – Mehrere Dateien analysieren
Darüber hinaus bietet dieser Abschnitt konkrete Beispiele und Tipps.
<project-context>
Projekt: [Name und Beschreibung]
Architektur: [z.B. MVC, Clean Architecture]
</project-context>
<file path="src/controller/UserController.ts">
[Code hier]
</file>
<file path="src/service/UserService.ts">
[Code hier]
</file>
<file path="src/repository/UserRepository.ts">
[Code hier]
</file>
<instructions>
Analysiere die Zusammenhänge zwischen diesen Dateien:
1. Wie ist der Datenfluss von Controller → Service → Repository?
2. Werden Abstraktionsschichten korrekt eingehalten?
3. Gibt es zirkuläre Abhängigkeiten?
4. Fehlerbehandlung: Wird sie durch alle Schichten propagiert?
5. Verbesserungsvorschläge für die Gesamtstruktur
</instructions>Insbesondere die Struktur des Prompts ist dabei entscheidend für gute Ergebnisse.
Wann nutzen: Claude kann dank 200K Token-Kontext ganze Module analysieren – nutze das!
Prompt 8 – Dependency-Analyse
Dabei spielen mehrere Faktoren eine wichtige Rolle.
<file path="package.json">
[package.json Inhalt einfügen]
</file>
<instructions>
Analysiere die Dependencies:
1. Welche Packages sind veraltet?
2. Gibt es bekannte Security-Vulnerabilities?
3. Welche Dependencies überlappen sich (z.B. lodash + ramda)?
4. Welche devDependencies sind in dependencies und umgekehrt?
5. Geschätzte Bundle-Größe der wichtigsten Deps
6. Empfehlungen: Ersetzen, Upgraden oder Entfernen?
</instructions>Prompt 9 – Algorithmus Schritt für Schritt tracen
Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.
<code>
[Algorithmus/Funktion hier einfügen]
</code>
<input>
[Konkreten Input angeben, z.B. [3, 1, 4, 1, 5, 9]]
</input>
<instructions>
Trace den Algorithmus Schritt für Schritt mit dem gegebenen Input:
- Zeige den Zustand aller Variablen nach jedem Schritt
- Nutze eine tabellarische Darstellung
- Markiere den aktuellen Ausführungspunkt
- Erkläre die Logik an Schlüsselstellen
- Zeige das Endergebnis
</instructions>Im Grunde funktioniert dieser Ansatz mit allen gängigen AI-Tools.
Prompt 10 – Git Diff analysieren
Natürlich gibt es dabei verschiedene Herangehensweisen.
<diff>
[Git Diff hier einfügen]
</diff>
<instructions>
Analysiere diesen Git Diff:
1. **Zusammenfassung:** Was wurde geändert? (1-2 Sätze)
2. **Breaking Changes:** Gibt es potenzielle Regressionen?
3. **Review-Findings:** Code-Qualität der Änderungen
4. **Fehlende Tests:** Welche Tests sollten hinzugefügt werden?
5. **Commit Message:** Schlage eine Conventional Commit Message vor
</instructions>Dementsprechend ist eine manuelle Überprüfung empfehlenswert.
Prompt 11 – Config-Dateien vergleichen
Im Folgenden findest du alle wichtigen Details dazu.
<file path="config/production.env">
[Prod Config]
</file>
<file path="config/staging.env">
[Staging Config]
</file>
<instructions>
Vergleiche diese Konfigurationen:
1. Welche Werte unterscheiden sich?
2. Fehlen in Staging Variablen, die in Production existieren?
3. Gibt es hardcodierte Secrets?
4. Sind die Werte sinnvoll für die jeweilige Umgebung?
</instructions>Grundsätzlich kannst du diesen Prompt an deine Bedürfnisse anpassen.
Prompt 12 – Performance-Profil analysieren
Dennoch solltest du einige Besonderheiten beachten.
<profile-data>
[Profiling-Output, z.B. flame graph data, performance.now() Messungen, EXPLAIN ANALYZE]
</profile-data>
<code>
[Relevanter Code]
</code>
<instructions>
Analysiere die Performance-Daten:
1. Wo sind die Bottlenecks?
2. Welche Funktionen/Queries brauchen am meisten Zeit?
3. Konkrete Optimierungsvorschläge mit geschätztem Impact
4. Quick Wins vs. langfristige Optimierungen
</instructions>3. Code-Generierung mit Claude
Prompt 13 – Feature mit Kontext generieren
Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.
<project>
Stack: [z.B. Next.js 15, TypeScript, Prisma, PostgreSQL]
Architektur: [z.B. App Router, Server Components]
Bestehende Patterns:
- Error Handling: [z.B. Result-Type Pattern]
- Validierung: [z.B. Zod Schemas]
- DB-Zugriff: [z.B. Repository Pattern]
</project>
<existing-code>
[Relevante bestehende Dateien einfügen, damit Claude den Stil übernimmt]
</existing-code>
<requirements>
Feature: [Beschreibung]
Akzeptanzkriterien:
- [Kriterium 1]
- [Kriterium 2]
- [Kriterium 3]
</requirements>
<instructions>
Implementiere das Feature im Stil des bestehenden Codes. Liefere alle neuen und geänderten Dateien.
</instructions>Deshalb empfiehlt es sich, den Prompt schrittweise zu verfeinern.
Wann nutzen: Claude übernimmt den Stil deines Projekts, wenn du Beispielcode mitlieferst.
Prompt 14 – API-Route mit Validierung & Types
Allerdings gibt es einige wichtige Unterschiede zu beachten.
<specs>
Route: [z.B. POST /api/v1/projects]
Auth: [z.B. Bearer Token, Role: admin|editor]
Request Body:
{
"name": "string, required, 3-100 chars",
"description": "string, optional, max 500 chars",
"teamId": "uuid, required"
}
Response 201:
{
"id": "uuid",
"name": "string",
"createdAt": "ISO 8601"
}
Business Rules:
- Name muss innerhalb des Teams unique sein
- Maximales Projektlimit pro Team: 50
</specs>
<instructions>
Generiere:
1. Zod/Valibot Schema für Validierung
2. TypeScript Types (Request/Response)
3. Route Handler mit Error Handling
4. Service-Logic mit Business Rules
5. Unit Tests für Handler und Service
</instructions>Ebenfalls sinnvoll ist es, verschiedene Varianten auszuprobieren.
Prompt 15 – React Komponente nach Figma/Spec
Vor allem für den praktischen Einsatz sind diese Informationen wertvoll.
<design-spec>
Komponente: [Name, z.B. DataTable]
Beschreibung: [Was zeigt/tut sie?]
Props:
- data: Array von Objekten
- columns: Spaltendefinitionen
- sortable: boolean (default true)
- onRowClick: Callback
Layout: [Beschreibung des Layouts]
States: Leer, Loading, Fehler, Daten
</design-spec>
<tech-constraints>
- React 19 mit Server Components Awareness
- Styling: Tailwind CSS
- Keine externen UI-Libraries
- Barrierefreiheit Level AA
</tech-constraints>
<instructions>
Implementiere die Komponente mit allen Props, States und Accessibility.
Liefere zusätzlich Storybook-Stories für alle Zustände.
</instructions>Natürlich solltest du den generierten Code vor dem Einsatz testen.
Prompt 16 – Datenbank-Migrationen generieren
Ebenso wichtig ist es, die Best Practices zu kennen.
<current-schema>
[Aktuelles DB-Schema oder Prisma Schema einfügen]
</current-schema>
<requirements>
Neue Features:
- [z.B. Multi-Tenancy Support hinzufügen]
- [z.B. Soft Deletes für alle Entities]
- [z.B. Audit Log Tabelle]
</requirements>
<instructions>
Generiere:
1. Migrations-SQL (reversible, UP + DOWN)
2. Datenvalidierung vor der Migration
3. Backfill-Script für bestehende Daten
4. Rollback-Plan
5. Geschätzter Downtime-Impact
</instructions>Prompt 17 – CLI Tool generieren
Grundsätzlich gibt es dabei einige Punkte zu beachten.
<spec>
Tool: [Name und Zweck]
Sprache: [z.B. Go / Rust / Python / Node.js]
Commands:
init: [Beschreibung]
generate [type]: [Beschreibung]
validate [file]: [Beschreibung]
Global Flags:
--verbose: Ausführliche Ausgabe
--config [path]: Konfigurationsdatei
--format [json|table|yaml]: Ausgabeformat
</spec>
<instructions>
Implementiere das CLI-Tool mit:
- Argument-Parsing (Commander/Cobra/Click)
- Farbige Ausgabe
- Interaktive Prompts wo sinnvoll
- Config-Datei Support (.toolrc)
- Manpage / --help Generator
- Release Build-Script
</instructions>Somit sparst du Zeit und erhältst qualitativ hochwertigeren Output.
Prompt 18 – Type-Safe API Client generieren
Zusammenfassend lässt sich sagen, dass dies ein zentraler Aspekt ist.
<api-spec>
[OpenAPI YAML oder JSON einfügen, oder API-Endpunkte beschreiben]
</api-spec>
<instructions>
Generiere einen type-safe API-Client in TypeScript:
1. Request/Response Types für jeden Endpoint
2. Fetch-Wrapper mit Error Handling
3. Retry-Logik mit Exponential Backoff
4. Request/Response Interceptors
5. Token-Refresh Automatik
6. React Query Hooks (optional)
Keine externen HTTP-Libraries (nutze native fetch).
</instructions>Weiterhin ist es ratsam, die Ergebnisse immer kritisch zu prüfen.
Prompt 19 – Middleware / Plugin schreiben
Dementsprechend solltest du die folgenden Aspekte kennen.
<framework>
[z.B. Express, Fastify, Hono, Django, Rails]
</framework>
<requirements>
Middleware für: [z.B. Rate Limiting, Request Logging, Auth Verification]
Konfigurierbar über: [z.B. Optionen-Objekt, Env Vars]
Verhalten:
- [Regel 1]
- [Regel 2]
- [Edge Case: ...]
</requirements>
<instructions>
Implementiere die Middleware mit:
- TypeScript Types
- Unit Tests
- README mit Konfigurationsbeispielen
- Benchmark (optional)
</instructions>Folglich erhältst du mit diesem Ansatz deutlich bessere Resultate.
Prompt 20 – Webhook Handler generieren
Tatsächlich ist dieser Bereich besonders wichtig für Entwickler.
<webhook-spec>
Provider: [z.B. Stripe, GitHub, Shopify]
Events die verarbeitet werden:
- [event.type1]: [Beschreibung, Aktion]
- [event.type2]: [Beschreibung, Aktion]
- [event.type3]: [Beschreibung, Aktion]
Security:
- Signature Verification: [Methode, z.B. HMAC SHA-256]
- Replay Protection: [z.B. Timestamp-Check]
</webhook-spec>
<instructions>
Generiere einen robusten Webhook Handler:
1. Signature Verification
2. Event Routing (Switch/Map)
3. Idempotenz (Doppelte Events erkennen)
4. Async Processing (Queue oder Background Job)
5. Error Recovery + Monitoring
6. Tests mit Beispiel-Payloads
</instructions>4. Refactoring & Optimierung
Prompt 21 – Extended Thinking für komplexes Refactoring
Weiterhin ist es wichtig, die Grundlagen zu verstehen.
<code>
[Großen, komplexen Code-Block einfügen]
</code>
<instructions>
Nutze Extended Thinking, um diesen Code systematisch zu refactoren.
Denke zuerst:
- Was sind die größten Code Smells?
- Welche Abstraktionen fehlen?
- Welche Design Patterns würden hier helfen?
- Was ist die optimale Reihenfolge der Refactoring-Schritte?
Dann liefere:
1. Refactoring-Plan (nummerierte Schritte)
2. Refactored Code (alle Dateien)
3. Tests die sicherstellen, dass nichts kaputt geht
4. Migrationspfad vom alten zum neuen Code
</instructions>Natürlich solltest du den generierten Code vor dem Einsatz testen.
Wann nutzen: Bei komplexem Legacy-Code, wo ein „Thinking“-Schritt bessere Ergebnisse liefert.
Prompt 22 – Schrittweises Refactoring mit Kontext
Im Folgenden findest du alle wichtigen Details dazu.
<context>
Das ist Schritt [X] von [Y] in unserem Refactoring-Prozess.
Bisherige Schritte:
- Schritt 1: [Was wurde gemacht]
- Schritt 2: [Was wurde gemacht]
Nächster Fokus: [z.B. Error Handling konsolidieren]
</context>
<code>
[Aktueller Stand des Codes]
</code>
<instructions>
Führe den nächsten Refactoring-Schritt durch.
Ändere nur das, was für diesen Schritt relevant ist.
Liefere einen Diff und erkläre jede Änderung.
</instructions>Deshalb empfiehlt es sich, den Prompt schrittweise zu verfeinern.
Prompt 23 – Performance optimieren mit Profiling-Daten
Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.
<performance-data>
Aktuelle Metriken:
- Durchschnittliche Response Time: [z.B. 850ms]
- P95 Response Time: [z.B. 2.3s]
- Memory Usage: [z.B. 512MB, steigend]
- CPU: [z.B. 45% im Durchschnitt]
Slow Queries:
[Top 5 langsamste Queries mit Laufzeit]
Hot Paths:
[Top 5 meistaufgerufene Funktionen]
</performance-data>
<code>
[Relevanter Code]
</code>
<instructions>
Optimiere den Code basierend auf den Profiling-Daten:
1. Quick Wins (sofort umsetzbar, hoher Impact)
2. Mittelfristige Optimierungen
3. Architekturelle Änderungen (falls nötig)
Für jede Optimierung: geschätzte Verbesserung in % oder ms
</instructions>Im Grunde funktioniert dieser Ansatz mit allen gängigen AI-Tools.
Prompt 24 – TypeScript strict Mode Migration
Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.
<tsconfig>
[Aktuelle tsconfig.json]
</tsconfig>
<code>
[Code-Dateien mit TypeScript-Fehlern]
</code>
<instructions>
Migriere den Code zu strict TypeScript:
1. Eliminiere alle `any` Typen
2. Füge fehlende Null-Checks hinzu
3. Nutze Discriminated Unions statt Type Assertions
4. Ersetze @ts-ignore durch saubere Typen
5. Nutze satisfies Operator wo passend
Liefere die Dateien in der empfohlenen Reihenfolge der Migration.
</instructions>Prompt 25 – Code zu funktionalem Stil konvertieren
Ebenfalls relevant sind die praktischen Anwendungsbeispiele.
<code>
[Imperativen/OOP Code einfügen]
</code>
<instructions>
Konvertiere den Code zu funktionalem Stil:
- Ersetze Mutationen durch immutable Transforms
- Nutze map/filter/reduce statt for-Loops
- Ersetze Klassen durch Funktionen + Closures
- Nutze Pipe-Operator oder compose Pattern
- Behalte die gleiche Funktionalität
Erkläre, welche Teile NICHT funktional umgeschrieben werden sollten und warum.
</instructions>Dementsprechend ist eine manuelle Überprüfung empfehlenswert.
Prompt 26 – Bundle-Größe reduzieren
Ebenso wichtig ist es, die Best Practices zu kennen.
<bundle-analysis>
[Output von webpack-bundle-analyzer, source-map-explorer, etc.]
Aktuelle Bundle-Größe: [z.B. 450KB gzipped]
Target: [z.B. unter 200KB]
</bundle-analysis>
<dependencies>
[package.json oder relevante Imports]
</dependencies>
<instructions>
Erstelle einen Plan zur Bundle-Größen-Reduktion:
1. Welche Dependencies sind die größten?
2. Welche können durch leichtere Alternativen ersetzt werden?
3. Welche Imports können tree-shaken werden?
4. Dynamic Imports / Code Splitting Strategie
5. Geschätzte Einsparung pro Maßnahme
</instructions>Dabei zeigt dieses Beispiel den grundlegenden Ansatz.
Prompt 27 – Accessibility Audit & Fix
Darüber hinaus bietet dieser Abschnitt konkrete Beispiele und Tipps.
<html>
[JSX/HTML einer Komponente oder Seite einfügen]
</html>
<instructions>
Führe ein Accessibility Audit (WCAG 2.2 Level AA) durch:
1. Fehlende ARIA-Attribute
2. Keyboard-Navigation
3. Farbkontraste (falls CSS vorhanden)
4. Screen Reader Kompatibilität
5. Focus Management
6. Formulare: Labels, Fehlermeldungen, Pflichtfelder
Für jedes Finding: Schweregrad, betroffene User-Gruppe und konkreter Fix.
</instructions>Somit sparst du Zeit und erhältst qualitativ hochwertigeren Output.
5. Debugging mit Claude
Prompt 28 – Bug mit vollem Kontext melden
Allerdings gibt es einige wichtige Unterschiede zu beachten.
<bug-report>
Erwartetes Verhalten: [Was sollte passieren?]
Tatsächliches Verhalten: [Was passiert stattdessen?]
Reproduktionsschritte:
1. [Schritt 1]
2. [Schritt 2]
3. [Schritt 3]
Frequenz: [Immer / Manchmal / Nur unter bestimmten Bedingungen]
</bug-report>
<error-log>
[Fehlermeldungen, Stack Traces]
</error-log>
<code>
[Relevanter Code]
</code>
<environment>
- Node.js: [Version]
- OS: [z.B. Ubuntu 22.04]
- Browser: [falls relevant]
</environment>
<instructions>
Finde die Ursache dieses Bugs. Denke systematisch:
1. Was sagt der Stack Trace?
2. Welche Code-Pfade sind betroffen?
3. Was ist die Root Cause?
4. Liefere einen Fix mit Tests
</instructions>Prompt 29 – Intermittierender Bug
Dabei spielen mehrere Faktoren eine wichtige Rolle.
<symptoms>
Bug tritt auf: [z.B. unter Last, nach X Stunden, bei bestimmten Daten]
Frequenz: [z.B. 5% aller Requests]
Betroffene Endpunkte: [Liste]
Logs zeigen: [Auszug aus den Logs bei Auftreten]
</symptoms>
<code>
[Relevanter Code – alle beteiligten Dateien]
</code>
<instructions>
Analysiere diesen intermittierenden Bug:
1. Welche Arten von Bugs verursachen nicht-deterministisches Verhalten?
(Race Conditions, Memory Leaks, Connection Pools, Timeouts)
2. Welche dieser Muster passen zu den Symptomen?
3. Wie kann ich den Bug reproduzierbar machen?
4. Konkreter Fix oder Diagnostik-Plan
</instructions>Vor allem die detaillierten Anweisungen sorgen für präzisere Ergebnisse.
Prompt 30 – TypeScript Compiler-Fehler lösen
Natürlich gibt es dabei verschiedene Herangehensweisen.
<error>
[Vollständiger TypeScript-Fehler]
</error>
<code>
[Betroffener Code mit Umgebungscontext]
</code>
<types>
[Relevante Type-Definitionen]
</types>
<instructions>
Löse diesen TypeScript-Fehler:
1. Erkläre: Was sagt der Fehler in einfachen Worten?
2. Warum tritt er auf? (Type-System Perspektive)
3. Zeige den Fix
4. Erkläre, wie man ähnliche Fehler in Zukunft vermeidet
Nutze KEINE Type Assertions (as) oder @ts-ignore als Fix.
</instructions>Folglich erhältst du mit diesem Ansatz deutlich bessere Resultate.
Prompt 31 – Production Incident analysieren
Grundsätzlich gibt es dabei einige Punkte zu beachten.
<incident>
Zeitpunkt: [Wann aufgetreten?]
Impact: [z.B. 500er für 30% der User, 15 Minuten Downtime]
Timeline:
- [Timestamp]: [Event]
- [Timestamp]: [Event]
</incident>
<data>
Logs: [Relevante Log-Einträge]
Metriken: [CPU, Memory, Error Rate, Latency]
Letzte Deployments: [Wann, was geändert]
</data>
<instructions>
Erstelle eine Root Cause Analysis (RCA):
1. Timeline der Events
2. Root Cause Identifikation
3. Contributing Factors
4. Immediate Fix (was wurde getan)
5. Long-term Fix (was muss geändert werden)
6. Action Items mit Verantwortlichkeiten
7. Wie hätte das Problem früher erkannt werden können?
</instructions>Tatsächlich lässt sich dieser Code direkt in dein Projekt übernehmen.
Prompt 32 – Datenbankproblem diagnostizieren
Somit kannst du direkt mit der Umsetzung beginnen.
<problem>
[Beschreibung: z.B. Queries werden langsam, Deadlocks, Connection Pool erschöpft]
</problem>
<queries>
[Problematische Queries mit EXPLAIN ANALYZE Output]
</queries>
<schema>
[Relevante Tabellen mit Indexen]
</schema>
<stats>
Tabellengröße: [Zeilen]
Connection Pool: [Max, Active, Idle]
Query-Frequenz: [Queries/Sekunde]
</stats>
<instructions>
Diagnostiziere das Problem und liefere:
1. Root Cause Analyse
2. Optimierte Queries
3. Fehlende oder überflüssige Indexe
4. Connection Pool Konfiguration
5. Monitoring-Queries zur Früherkennung
</instructions>Prompt 33 – CORS / Auth Fehler debuggen
Deshalb lohnt es sich, dieses Thema genauer zu betrachten.
<error>
[Browser-Console Fehler, z.B. CORS, 401, 403]
</error>
<frontend-code>
[Fetch/Axios Call]
</frontend-code>
<backend-code>
[CORS Config, Auth Middleware, Route Handler]
</backend-code>
<network-tab>
Request Headers: [...]
Response Headers: [...]
Preflight (OPTIONS): [Falls vorhanden]
</network-tab>
<instructions>
Debugge dieses CORS/Auth Problem:
1. Was genau geht schief? (Preflight? Credentials? Header?)
2. Wo ist die Fehlkonfiguration?
3. Konkreter Fix für Frontend UND Backend
4. Checkliste für CORS-Konfiguration
</instructions>Ebenfalls sinnvoll ist es, verschiedene Varianten auszuprobieren.
6. Architektur & Design
Prompt 34 – Architektur-Review mit Claude
Folglich profitierst du von einem besseren Verständnis dieser Konzepte.
<architecture>
[ASCII-Diagramm oder Beschreibung der aktuellen Architektur]
</architecture>
<context>
Team: [Größe, Erfahrung]
Traffic: [DAU, Peak RPS]
Budget: [z.B. 500€/Monat Cloud-Kosten]
Pain Points: [z.B. Slow Deployments, Coupling, Scalability]
</context>
<instructions>
Führe ein Architektur-Review durch:
1. Stärken der aktuellen Architektur
2. Schwachstellen und Risiken
3. Skalierungsgrenzen
4. Empfehlungen (priorisiert, pragmatisch)
5. Evolutionärer Migrationspfad
Berücksichtige die Teamgröße – keine Over-Engineering-Vorschläge.
</instructions>Darüber hinaus lässt sich das Beispiel leicht erweitern.
Prompt 35 – API Design Review
Zusammenfassend lässt sich sagen, dass dies ein zentraler Aspekt ist.
<api>
[OpenAPI Spec oder Liste der Endpunkte mit HTTP-Methoden, Pfaden, Request/Response Bodies]
</api>
<instructions>
Reviewe das API Design:
1. RESTfulness: Werden HTTP-Methoden korrekt verwendet?
2. Namenskonventionen: Konsistente URL-Muster?
3. Pagination: Standardisiert?
4. Error Responses: Konsistentes Format?
5. Versionierung: Sinnvolle Strategie?
6. Security: Auth-Endpunkte, Rate Limiting
7. Breaking Changes: Welche Änderungen wären breaking?
Liefere eine überarbeitete API-Spec mit Erklärungen.
</instructions>Weiterhin ist es ratsam, die Ergebnisse immer kritisch zu prüfen.
Prompt 36 – Datenmodell designen
Vor allem für den praktischen Einsatz sind diese Informationen wertvoll.
<requirements>
Domäne: [z.B. Projektmanagement Tool]
Entities:
- [Entity 1]: [Beschreibung, Attribute]
- [Entity 2]: [Beschreibung, Attribute]
Beziehungen:
- [Entity 1] → [Entity 2]: [Art, z.B. 1:N, N:M]
Besondere Anforderungen:
- [z.B. Soft Deletes, Audit Trail, Multi-Tenancy]
</requirements>
<instructions>
Entwirf das Datenmodell:
1. ER-Diagramm (ASCII)
2. CREATE TABLE Statements (PostgreSQL)
3. Indexstrategie
4. Migrations-Reihenfolge
5. Seed-Daten für Development
6. Bekannte Tradeoffs und Alternativen
</instructions>Prompt 37 – Skalierungsstrategie entwickeln
Dennoch solltest du einige Besonderheiten beachten.
<current-state>
Architektur: [Monolith/Microservices]
Hosting: [z.B. Single Server, Kubernetes]
Traffic: [Aktuell und Wachstumsprognose]
Datenbank: [Typ, Größe, Read/Write Ratio]
Bottleneck: [Was limitiert aktuell?]
</current-state>
<target>
10x Traffic in 12 Monaten
99.9% Availability
P95 Latency < 200ms
</target>
<instructions>
Erstelle einen Skalierungsplan:
1. Horizontale vs. vertikale Skalierung
2. Caching-Strategie (CDN, Application, DB)
3. Datenbank-Skalierung (Read Replicas, Sharding)
4. Load Balancing Konfiguration
5. Queue/Worker-Architektur für async Tasks
6. Kosten-Schätzung pro Phase
7. Monitoring-Setup für Kapazitätsplanung
</instructions>Grundsätzlich kannst du diesen Prompt an deine Bedürfnisse anpassen.
7. Dokumentation & Erklärungen
Prompt 38 – Technische Dokumentation generieren
Insbesondere für den Einstieg sind die folgenden Informationen hilfreich.
<code>
[Gesamte Library/Modul einfügen]
</code>
<instructions>
Generiere eine vollständige technische Dokumentation:
1. **Übersicht:** Was macht diese Library?
2. **Installation:** Setup-Schritte
3. **Quick Start:** Minimales Beispiel
4. **API Reference:** Alle exportierten Funktionen/Klassen
- Signatur
- Parameter (mit Typen und Defaults)
- Rückgabewert
- Beispiel
- Throws/Errors
5. **Konfiguration:** Alle Optionen
6. **Recipes:** 3-5 häufige Use Cases
7. **Troubleshooting:** Häufige Fehler und Lösungen
Format: Markdown, geeignet für ein docs/ Verzeichnis.
</instructions>Insbesondere die Struktur des Prompts ist dabei entscheidend für gute Ergebnisse.
Prompt 39 – ADR schreiben
Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.
<decision>
Frage: [z.B. "State Management Library für React"]
Kontext: [Projektkontext, bisherige Erfahrungen]
Optionen:
- [Option A]: [z.B. Zustand]
- [Option B]: [z.B. Jotai]
- [Option C]: [z.B. Redux Toolkit]
Entscheidung: [Gewählte Option]
</decision>
<instructions>
Erstelle ein Architecture Decision Record (ADR):
- Title
- Status: [Proposed/Accepted/Deprecated]
- Context
- Decision
- Consequences (positiv + negativ)
- Alternatives Considered
- Compliance (wie wird die Entscheidung durchgesetzt?)
Format: ADR-Template nach Michael Nygard
</instructions>Außerdem kannst du den Prompt für verschiedene Programmiersprachen anpassen.
Prompt 40 – Onboarding-Dokument generieren
Allerdings gibt es einige wichtige Unterschiede zu beachten.
<project>
[Projekt-Übersicht: Name, Zweck, Tech Stack]
</project>
<codebase>
[Ordnerstruktur als Tree]
</codebase>
<instructions>
Erstelle ein Onboarding-Dokument für neue Entwickler:
1. **Architektur-Übersicht** (mit Diagramm)
2. **Setup-Guide** (Schritt für Schritt)
3. **Wichtige Dateien** (wo findet man was?)
4. **Coding-Konventionen** (Naming, Patterns, Do's und Don'ts)
5. **Typischer Workflow** (Feature Branch → PR → Deploy)
6. **Debugging-Tipps** (wo schauen, wenn etwas nicht geht)
7. **Kontakte** (wer ist für was zuständig)
8. **Häufige Fragen** von neuen Teammitgliedern
</instructions>Claude vs. ChatGPT: Prompt-Unterschiede
Dabei spielen mehrere Faktoren eine wichtige Rolle.
Nicht jeder Prompt funktioniert gleich gut bei beiden Modellen. Hier die wichtigsten Unterschiede:
Strukturierung
Ebenso wichtig ist es, die Best Practices zu kennen.
- Claude: Bevorzugt XML-Tags (
<context>,<code>,<instructions>) – bessere Trennung von Kontext und Aufgabe - ChatGPT: Arbeitet gut mit Markdown-Formatierung (###, „`, —)
Kontext-Handling
Weiterhin ist es wichtig, die Grundlagen zu verstehen.
- Claude: 200K Token Kontext – ideal für ganze Module und mehrere Dateien gleichzeitig
- ChatGPT: 128K Token (GPT-4o) – ausreichend für die meisten einzelnen Dateien
Stärken
Insbesondere für den Einstieg sind die folgenden Informationen hilfreich.
- Claude: Code-Analyse, lange Dokumente, nuancierte Antworten, Refactoring großer Codebases
- ChatGPT: Kreative Lösungen, Code-Generierung von Scratch, breites Plugin-Ökosystem
→ Detaillierter Vergleich: Claude vs ChatGPT für Entwickler
Tipps für optimale Claude-Ergebnisse
1. XML-Tags nutzen
Ebenfalls relevant sind die praktischen Anwendungsbeispiele.
Claude versteht XML-Tags als semantische Trennung. Nutze sie konsequent:
<context>für Hintergrundinformationen- Zudem
<code>für Quellcode <instructions>für die eigentliche Aufgabe<constraints>für Einschränkungen<output-format>für das gewünschte Format
2. Extended Thinking aktivieren
Grundsätzlich gibt es dabei einige Punkte zu beachten.
Für komplexe Probleme: Schreibe „Denke Schritt für Schritt und zeige deine Überlegungen“ oder nutze die Extended Thinking Funktion in der API. Claude analysiert dann sichtbar, bevor es antwortet.
3. Artifacts nutzen
Dennoch solltest du einige Besonderheiten beachten.
Bitte Claude, Code als Artifacts zu erstellen. Diese sind editierbar, versioniert und können als Dateien heruntergeladen werden.
4. Ganzen Kontext mitgeben
Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.
Nutze Claudes großes Kontextfenster voll aus. Statt nur eine Funktion zu schicken, schicke das gesamte Modul – Claude versteht die Zusammenhänge besser.
5. Projekte nutzen
Deshalb lohnt es sich, dieses Thema genauer zu betrachten.
Lade in Claude Projects deine gesamte Codebase hoch. Claude hat dann permanenten Zugriff und kann kontextbezogen antworten.
FAQ
Welches Claude-Modell ist am besten für Coding?
Vor allem für den praktischen Einsatz sind diese Informationen wertvoll.
Claude Opus 4 ist das leistungsfähigste Modell für komplexe Coding-Aufgaben. Claude Sonnet 4 bietet ein hervorragendes Preis-Leistungs-Verhältnis für die meisten Entwickleraufgaben. Claude Haiku eignet sich für einfache Aufgaben wie Formatierung oder Erklärungen.
Wie unterscheidet sich Claude von GitHub Copilot?
Im Folgenden findest du alle wichtigen Details dazu.
Claude ist ein Konversationsmodell für komplexe Analyse- und Planungsaufgaben. GitHub Copilot (der inzwischen auch Claude nutzt) ist direkt in den Editor integriert für Inline-Completions. Optimal: Copilot für Zeile-für-Zeile-Coding, Claude für Architektur, Debugging und Reviews.
Ist Claude sicher für Firmencode?
Dementsprechend solltest du die folgenden Aspekte kennen.
Anthropic speichert keine Daten der API für Training. Claude Enterprise bietet zusätzliche Datenschutz-Garantien. Für hochsensiblen Code: Nutze die API mit eigener Infrastruktur oder evaluiere Amazon Bedrock mit Claude.
Wie viel Code kann Claude auf einmal verarbeiten?
Folglich profitierst du von einem besseren Verständnis dieser Konzepte.
Mit 200.000 Tokens kann Claude ca. 150.000 Wörter oder 500+ typische Quelltextdateien verarbeiten. In der Praxis reicht das für ganze Module oder sogar kleinere Projekte.
Kann ich die Prompts aus diesem Artikel mit ChatGPT nutzen?
Zusammenfassend lässt sich sagen, dass dies ein zentraler Aspekt ist.
Ja, die meisten Prompts funktionieren auch mit ChatGPT. Ersetze XML-Tags durch Markdown-Überschriften und reduziere den Kontext auf die ChatGPT-Token-Limits.
Zuletzt aktualisiert: März 2026