Claude Prompts für Programmierer

13. März 2026 MetinC Künstliche Intelligenz 0

40 praxiserprobte Claude Prompts für Programmierer: Code generieren, Bugs analysieren, Architektur planen und komplexe Refactorings mit Anthropics KI meistern.

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

  1. System-Prompts für Claude (Prompts 1–5)
  2. Code-Analyse & Verständnis (Prompts 6–12)
  3. Code-Generierung mit Claude (Prompts 13–20)
  4. Refactoring & Optimierung (Prompts 21–27)
  5. Debugging mit Claude (Prompts 28–33)
  6. Architektur & Design (Prompts 34–37)
  7. Dokumentation & Erklärungen (Prompts 38–40)
  8. Claude vs. ChatGPT: Prompt-Unterschiede
  9. Tipps für optimale Claude-Ergebnisse
  10. FAQ

1. System-Prompts für Claude

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

[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 Deutsch

Wann nutzen: Als Standard-System-Prompt für deine tägliche Claude-Session.

Prompt 2 – Code-Reviewer System-Prompt

[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.

Prompt 3 – Architektur-Berater System-Prompt

[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.

Prompt 4 – Test Engineer System-Prompt

[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

[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.

2. Code-Analyse & Verständnis

Claudes langes Kontextfenster (200K Tokens) macht es ideal für die Analyse von ganzen Dateien und Modulen.

Prompt 6 – Ganze Datei verstehen

<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>

Wann nutzen: Wenn du eine fremde Codebasis verstehen musst oder nach einem Onboarding.

Prompt 7 – Mehrere Dateien analysieren

<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>

Wann nutzen: Claude kann dank 200K Token-Kontext ganze Module analysieren – nutze das!

Prompt 8 – Dependency-Analyse

<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

<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>

Prompt 10 – Git Diff analysieren

<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>

Prompt 11 – Config-Dateien vergleichen

<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>

Prompt 12 – Performance-Profil analysieren

<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

<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>

Wann nutzen: Claude übernimmt den Stil deines Projekts, wenn du Beispielcode mitlieferst.

Prompt 14 – API-Route mit Validierung & Types

<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>

Prompt 15 – React Komponente nach Figma/Spec

<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>

Prompt 16 – Datenbank-Migrationen generieren

<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

<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>

Prompt 18 – Type-Safe API Client generieren

<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>

Prompt 19 – Middleware / Plugin schreiben

<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>

Prompt 20 – Webhook Handler generieren

<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

<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>

Wann nutzen: Bei komplexem Legacy-Code, wo ein „Thinking“-Schritt bessere Ergebnisse liefert.

Prompt 22 – Schrittweises Refactoring mit Kontext

<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>

Prompt 23 – Performance optimieren mit Profiling-Daten

<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>

Prompt 24 – TypeScript strict Mode Migration

<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

<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>

Prompt 26 – Bundle-Größe reduzieren

<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>

Prompt 27 – Accessibility Audit & Fix

<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>

5. Debugging mit Claude

Prompt 28 – Bug mit vollem Kontext melden

<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

<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>

Prompt 30 – TypeScript Compiler-Fehler lösen

<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>

Prompt 31 – Production Incident analysieren

<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>

Prompt 32 – Datenbankproblem diagnostizieren

<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

<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>

6. Architektur & Design

Prompt 34 – Architektur-Review mit Claude

<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>

Prompt 35 – API Design Review

<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>

Prompt 36 – Datenmodell designen

<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

<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>

7. Dokumentation & Erklärungen

Prompt 38 – Technische Dokumentation generieren

<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>

Prompt 39 – ADR schreiben

<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>

Prompt 40 – Onboarding-Dokument generieren

<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

Nicht jeder Prompt funktioniert gleich gut bei beiden Modellen. Hier die wichtigsten Unterschiede:

Strukturierung

  • Claude: Bevorzugt XML-Tags (<context>, <code>, <instructions>) – bessere Trennung von Kontext und Aufgabe
  • ChatGPT: Arbeitet gut mit Markdown-Formatierung (###, „`, —)

Kontext-Handling

  • 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

  • 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

Claude versteht XML-Tags als semantische Trennung. Nutze sie konsequent:

  • <context> für Hintergrundinformationen
  • <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

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

Bitte Claude, Code als Artifacts zu erstellen. Diese sind editierbar, versioniert und können als Dateien heruntergeladen werden.

4. Ganzen Kontext mitgeben

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

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?

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?

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?

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?

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?

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