KI-Prompt-Engineering: Unverzichtbare Befehle und Techniken für Entwickler

Prompt-Engineering ist zu einer der wichtigsten Fähigkeiten für Entwickler geworden, die KI-Tools verwenden. Ob Sie ChatGPT, Claude, GitHub Copilot oder Cursor nutzen – die Qualität des Prompts bestimmt direkt die Qualität der KI-Ausgabe. Ein gut gestalteter Prompt kann vage, nutzlose Antworten in präzisen, produktionsreifen Code verwandeln. Dieser umfassende Leitfaden deckt alles ab, von grundlegenden Prompt-Techniken über fortgeschrittene Strategien und toolspezifische Tipps bis hin zu gebrauchsfertigen Vorlagen, damit Sie aus jeder KI-Interaktion den maximalen Nutzen ziehen.

Was ist Prompt-Engineering?

Prompt-Engineering ist die Kunst und Wissenschaft, effektive Anweisungen für KI-Sprachmodelle zu formulieren, um die gewünschte Ausgabe zu erzielen. Im Kern geht es um Kommunikation – zu lernen, wie man sich in der Sprache ausdrückt, die KI-Modelle am besten verstehen. So wie ein erfahrener Entwickler einem Junior-Entwickler präzisere Anweisungen für bessere Ergebnisse gibt, lehrt Prompt-Engineering, wie Sie Ihre Absichten klar und präzise an KI-Systeme kommunizieren.

Für Entwickler ist Prompt-Engineering wichtig, weil KI-Programmierassistenten zu einem unverzichtbaren Bestandteil moderner Entwicklungsworkflows geworden sind. Diese Tools können Code generieren, Probleme debuggen, Tests schreiben, Architekturen umstrukturieren und komplexe Systeme erklären – aber nur, wenn Sie die richtigen Anweisungen geben. Ein schlecht geschriebener Prompt kann Code produzieren, der zwar kompiliert, aber nicht Ihrer Absicht entspricht, die falsche Framework-Version verwendet oder kritische Randfälle übersieht. Ein gut gestalteter Prompt hingegen kann Ausgaben liefern, die von Code eines erfahrenen Entwicklers kaum zu unterscheiden sind.

Kleine Änderungen in Prompts haben große Auswirkungen. Vergleichen Sie "Behebe den Bug" mit "Behebe die Nullreferenz-Ausnahme in der UserService.authenticate-Methode, wenn der email-Parameter undefined ist. Die Methode befindet sich in src/services/UserService.ts und verwendet bcrypt für den Passwortvergleich." Der erste Prompt gibt der KI kaum nützliche Informationen. Der zweite liefert eine klare Problembeschreibung, den Ort und Kontext – und ermöglicht der KI, beim ersten Versuch eine präzise, korrekte Lösung zu liefern.

Grundlegende Prompt-Techniken

Das Verständnis der zentralen Prompt-Techniken legt Ihr Fundament. Jede Technik hat spezifische Anwendungsfälle, in denen sie sich auszeichnet, und erfahrene Prompt-Ingenieure kombinieren oft mehrere Techniken in einem einzigen Prompt für optimale Ergebnisse.

Zero-Shot-Prompting

Zero-Shot-Prompting ist die einfachste Form des Promptens – Sie geben der KI eine Anweisung ohne Beispiele. Die KI verlässt sich vollständig auf ihre Trainingsdaten und die Informationen im Prompt, um eine Antwort zu generieren. Diese Technik eignet sich für einfache Aufgaben, bei denen das gewünschte Ausgabeformat offensichtlich ist, oder wenn die KI viele ähnliche Beispiele in ihrem Training gesehen hat.

Write a Python function that validates an email address using regex.
The function should return True for valid emails and False for invalid ones.

Zero-Shot-Prompting funktioniert gut für häufige, klar definierte Aufgaben. Wenn Sie jedoch ein bestimmtes Ausgabeformat, einen bestimmten Stil oder Ansatz benötigen, ist Few-Shot-Prompting zuverlässiger.

Few-Shot-Prompting

Few-Shot-Prompting beinhaltet das Bereitstellen eines oder mehrerer Beispiele des gewünschten Eingabe-Ausgabe-Musters vor der eigentlichen Aufgabe. Diese Technik ist äußerst wirkungsvoll, da sie genau zeigt, was Sie wollen, Mehrdeutigkeiten reduziert und die KI zum richtigen Format und Stil führt. Die KI lernt das Muster aus Ihren Beispielen und wendet es auf neue Eingaben an.

Convert these database column names to camelCase JavaScript variable names:

user_first_name -> userFirstName
created_at_timestamp -> createdAtTimestamp
is_email_verified -> isEmailVerified
total_order_count ->

Now convert: product_category_id

Few-Shot-Prompting ist besonders wertvoll, wenn Sie konsistente Formatierung, spezifische Codierungskonventionen benötigen oder wenn die KI sonst Annahmen treffen könnte, die nicht zu Ihrem Projektstil passen. Normalerweise reichen zwei bis drei Beispiele aus, um ein klares Muster zu etablieren.

Chain-of-Thought-Prompting

Chain-of-Thought-Prompting fordert die KI auf, ein Problem Schritt für Schritt zu durchdenken, bevor sie eine endgültige Antwort gibt. Diese Technik verbessert die Genauigkeit bei komplexen Aufgaben erheblich, da sie die KI zwingt, Zwischenschritte zu verarbeiten, anstatt zu möglicherweise falschen Schlussfolgerungen zu springen. Studien zeigen, dass das Hinzufügen von "think step by step" zu Prompts die Genauigkeit bei Reasoning-Aufgaben um 30-50 % verbessern kann.

Analyze this React component for performance issues. Think step by step:

1. First, identify all state variables and their update patterns
2. Then, check for unnecessary re-renders
3. Next, look for missing memoization opportunities
4. Finally, suggest specific optimizations with code examples

Here's the component:
[component code]

Chain-of-Thought-Prompting ist unverzichtbar für Debugging, Architekturentscheidungen und alle Aufgaben, die logisches Denken erfordern. Indem Sie die KI auffordern, ihren Denkprozess zu zeigen, erhalten Sie auch die Möglichkeit, ihre Argumentation zu validieren und Fehler in Zwischenschritten zu erkennen.

Role-Playing-Prompting

Role-Playing-Prompting weist der KI eine bestimmte Rolle oder ein Kompetenzniveau zu, was die Tiefe, den Stil und den Fokus ihrer Antworten beeinflusst. Wenn Sie der KI sagen "Spiele einen Senior DevOps Engineer", wechselt sie ihre Perspektive und gibt betriebsorientiertere, produktionsreifere Ratschläge statt generischer Code-Snippets. Diese Technik nutzt das Training der KI in domänenspezifischen Inhalten, um kompetentere Ausgaben zu erzeugen.

Act as a senior security engineer with 15 years of experience in web application security. Review this authentication implementation and identify any vulnerabilities, ranking them by severity. For each vulnerability, explain the attack vector and provide a secure code fix.

Der Schlüssel zu effektivem Role-Playing liegt in der Spezifität. "Spiele einen Python-Entwickler" ist zu vage. "Spiele einen Python-Entwickler, der sich auf den Bau von Hochleistungs-Datenpipelines mit Apache Airflow und pandas spezialisiert hat" gibt der KI einen viel klareren Referenzrahmen.

System-Prompts vs. Benutzer-Prompts

Die meisten KI-Tools unterscheiden zwischen System-Prompts und Benutzer-Prompts. System-Prompts legen persistente Anweisungen fest, die für die gesamte Konversation gelten, während Benutzer-Prompts einzelne Nachrichten sind. Das Verständnis dieses Unterschieds ist entscheidend für die Aufrechterhaltung der Konsistenz in langen Interaktionen.

CLAUDE.md-Datei als persistenter System-Prompt. In ChatGPT können Sie benutzerdefinierte Anweisungen als System-Prompts für alle Konversationen festlegen.

# System prompt example
You are a TypeScript expert working on a Next.js 14 project using:
- App Router (not Pages Router)
- Server Components by default
- Prisma for database access
- Tailwind CSS for styling
- Zod for validation

Always use strict TypeScript. Prefer server actions over API routes.
Never use 'any' type. Use 'unknown' and narrow with type guards.

# User prompt example
Add a user profile page that shows the current user's name, email,
avatar, and last 10 activity records. Include loading states and
error handling.

Unverzichtbare KI-Befehle für Entwickler

Bestimmte Befehlsmuster haben sich in allen wichtigen KI-Programmiertools als äußerst effektiv erwiesen. Dies sind keine wörtlichen Befehle, sondern Anweisungsphrasen, die durchweg qualitativ hochwertige Antworten auslösen. Betrachten Sie sie als Machtwörter, die bestimmte Fähigkeiten des KI-Modells aktivieren.

"Act as..." / "You are a..." — Rollenzuweisung

Die Rollenzuweisung ist einer der mächtigsten Befehle im Prompt-Engineering. Durch die Angabe einer Rolle aktivieren Sie domänenspezifisches Wissen und setzen Erwartungen an Tiefe und Stil der Antwort. Je spezifischer die Rolle, desto besser die Ausgabe.

You are a senior backend engineer at a fintech company who specializes
in building secure, high-throughput payment processing systems.
You have deep expertise in PostgreSQL, Redis, and distributed systems.
You always consider edge cases, race conditions, and failure modes.

Design a payment processing API that handles:
- Credit card payments via Stripe
- Bank transfers via Plaid
- Retry logic with exponential backoff
- Idempotency keys to prevent duplicate charges

"Step by step" — Chain of Thought

Das Hinzufügen von "step by step" oder "let's think step by step" zu Prompts löst aus, dass die KI ihren Denkprozess zerlegt. Dies ist besonders effektiv für Debugging, Algorithmendesign und Architekturentscheidungen. Der schrittweise Ansatz liefert nicht nur bessere Ergebnisse, sondern macht auch das Reasoning der KI transparent, sodass Sie logische Fehler erkennen können.

Debug this SQL query that's causing a timeout. Think step by step:

1. First, analyze the query structure and joins
2. Identify potential performance bottlenecks
3. Check for missing indexes
4. Suggest an optimized version with EXPLAIN analysis

SELECT u.name, COUNT(o.id), SUM(o.amount)
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
LEFT JOIN order_items oi ON o.id = oi.order_id
WHERE o.created_at > '2026-01-01'
GROUP BY u.name
HAVING COUNT(o.id) > 10
ORDER BY SUM(o.amount) DESC;

"Think aloud" — Transparentes Reasoning

"Think aloud" ähnelt "step by step", konzentriert sich aber stärker auf den Entscheidungsprozess der KI. Es fordert die KI auf, ihre Überlegungen zu erzählen, einschließlich der in Betracht gezogenen Alternativen und warum ein bestimmter Ansatz gewählt wurde. Dies ist äußerst wertvoll, wenn Sie die Abwägungen bei Designentscheidungen verstehen oder beurteilen möchten, ob das Reasoning der KI fundiert ist.

I need to choose between WebSocket and Server-Sent Events for a
real-time notification system. Think aloud about the trade-offs,
considering: browser support, bidirectional communication needs,
server resource usage, and scalability. Then recommend one with
justification.

"Explain like I'm 5" — Vereinfachte Erklärung

Beim Erlernen neuer Konzepte oder beim Versuch, komplexen Code zu verstehen, entfernt "explain like I'm 5" (ELI5) Fachjargon und liefert intuitive, analogiebasierte Erklärungen. Dies ist besonders nützlich beim Einstieg in neue Projekte, beim Verständnis unbekannter Codebasen oder bei der Erklärung technischer Konzepte für nicht-technische Stakeholder.

Explain like I'm 5: What is a monad in functional programming,
and why do Haskell developers keep talking about them?
Use a real-world analogy, not code.

"Review and critique" — Code-Review

Die Verwendung von "review and critique" signalisiert der KI, eine kritische Perspektive einzunehmen, anstatt Code einfach zu akzeptieren. Dies führt zu einer gründlicheren Analyse mit potenziellen Bugs, Sicherheitsproblemen, Leistungsproblemen und Stilverstößen. Es ist, als erhielten Sie auf Abruf ein Code-Review von einem Senior-Ingenieur.

Review and critique this Express.js middleware. Focus on:
- Security vulnerabilities
- Error handling gaps
- Performance concerns
- Best practice violations
- Suggest improvements with code examples

[paste your middleware code]

"Write tests for" — Testgenerierung

Die Testgenerierung ist eine der wertvollsten Anwendungen von KI-Programmiertools. Durch die Angabe von "write tests for" zusammen mit Ihrem Test-Framework und Ihren Abdeckungserwartungen können Sie schnell umfassende Test-Suiten generieren. Der Schlüssel liegt in der Spezifikation von Randfällen und Testprioritäten.

Write tests for the UserService.register method using Jest.
Cover these scenarios:
- Happy path with valid input
- Duplicate email registration
- Invalid email format
- Password too short
- Missing required fields
- Database connection failure
- Concurrent registration attempts

Use describe/it blocks. Include setup and teardown.
Mock the database layer.

"Refactor using..." — Musterbasiertes Refactoring

Die Angabe von Entwurfsmustern oder -prinzipien in Refactoring-Prompts gibt der KI eine klare Zielarchitektur. Anstatt vager "Refaktorisiere das"-Anfragen erzeugt die Benennung von Mustern fokussierte, konsistente Refactorings, die etablierten Software-Engineering-Prinzipien folgen.

Refactor this notification system using the Strategy pattern.
Currently, all notification types (email, SMS, push) are handled
in a single class with if-else chains. Create separate strategy
classes for each notification type, a context class that delegates
to the active strategy, and a factory for creating strategies.

[paste your current code]

"Find bugs in" — Debugging

Der Befehl "Find bugs in" aktiviert den Analysemodus der KI und veranlasst sie, nach Problemen zu suchen, anstatt Code zu generieren. Er funktioniert am besten, wenn Sie Code bereitstellen, das erwartete Verhalten beschreiben und beobachtete Symptome erwähnen.

Find bugs in this async Node.js function. It's supposed to process
a batch of orders and update their status, but sometimes orders
get processed twice and the status updates are inconsistent under
high load.

[paste your function code]

"Add error handling" — Robustheitsverbesserung

Viele KI-generierte Code-Snippets funktionieren auf dem normalen Pfad, aber es fehlt eine angemessene Fehlerbehandlung. Der Befehl "Add error handling" zielt speziell auf diese Lücke ab und fordert die KI auf, Fehlermodi, Randfälle und Wiederherstellungsstrategien zu berücksichtigen.

Add error handling to this file upload function. Consider:
- File size limits
- Invalid file types
- Network interruptions during upload
- Disk space errors
- Concurrent upload conflicts
- Partial upload cleanup

Use try-catch with specific error types. Add retry logic for
transient failures. Return meaningful error messages to the client.

Prompt-Muster für die Codegenerierung

Über einzelne Befehle hinaus haben sich bestimmte Prompt-Muster für bestimmte Arten von Codegenerierungsaufgaben als besonders effektiv erwiesen. Diese Muster kombinieren Techniken wie Rollenzuweisung, Kontextbereitstellung und Ausgabespezifikation zu strukturierten Prompts, die durchweg hochwertige Ergebnisse liefern.

Funktionsimplementierungs-Prompt

Bei der Implementierung neuer Funktionen folgen die effektivsten Prompts einer spezifikationsähnlichen Struktur: Beschreiben Sie die Funktion, geben Sie den Tech-Stack an, definieren Sie Akzeptanzkriterien und erwähnen Sie etwaige Einschränkungen. Dies gibt der KI ein vollständiges Bild davon, was gebaut werden soll.

Implement a user avatar upload feature for a Next.js 14 application.

Tech stack: Next.js App Router, TypeScript, Prisma, PostgreSQL, AWS S3

Requirements:
- Accept JPEG, PNG, WebP (max 5MB)
- Resize to 200x200 and 400x400 thumbnails using Sharp
- Upload originals to S3 with unique keys
- Store S3 URLs in the User model
- Delete old avatar when uploading a new one
- Return presigned URLs for frontend display

Acceptance criteria:
- Invalid file types return 400 with error message
- Files over 5MB return 413
- Successful upload returns 200 with avatar URLs
- Old avatars are cleaned up from S3

Create: API route, service layer, Prisma schema update, and types.

API-Design-Prompt

API-Design-Prompts profitieren von der vorherigen Angabe des Architekturstils, der Authentifizierungsmethode, der Versionierungsstrategie und des Antwortformats. Dies stellt sicher, dass die generierte API konsistent ist und den Konventionen Ihres Projekts folgt.

Design a RESTful API for a project management application.

Architecture: Express.js with TypeScript, following clean architecture
Auth: JWT with refresh token rotation
Versioning: URL-based (/api/v1/)
Response format: { success: boolean, data?: T, error?: { code, message } }

Endpoints needed:
- Projects CRUD with team membership
- Tasks CRUD with assignee, priority, status
- Comments on tasks with mentions
- Activity feed (recent actions across projects)

Include:
- Request/response TypeScript interfaces
- Zod validation schemas
- Error handling middleware
- Pagination for list endpoints (cursor-based)

Datenbank-Schema-Prompt

Datenbank-Schema-Prompts sollten das ORM, die Namenskonventionen, die Indexierungsstrategie und die Beziehungen angeben. Die KI kann vollständige Schemata mit angemessenen Constraints, Indizes und Migrationsdateien generieren.

Design a Prisma schema for an e-commerce platform with these entities:

- Users (authentication, profile, addresses)
- Products (variants, categories, inventory)
- Orders (line items, status history, payments)
- Reviews (ratings, images, helpful votes)
- Cart (items, applied coupons)

Requirements:
- Use PostgreSQL with UUID primary keys
- Soft deletes with deletedAt timestamps
- Proper indexes for common query patterns
- Enums for order status, payment status
- Decimal fields for prices (not float)
- Full-text search on product name and description
- Include a migration file

UI-Komponenten-Prompt

Bei UI-Komponenten führt die Angabe von Framework, Styling-Ansatz, Barrierefreiheitsanforderungen und Interaktionszuständen zu besseren Ergebnissen als generische "Erstelle eine Komponente"-Prompts.

Create a reusable DataTable component in React with TypeScript.

Styling: Tailwind CSS + shadcn/ui conventions
Features:
- Column definitions with sort, filter, and custom renderers
- Server-side pagination with page size selector
- Row selection (single and multi) with checkboxes
- Loading skeleton state
- Empty state with custom message
- Responsive: card layout on mobile, table on desktop

Accessibility:
- Keyboard navigation (arrow keys, Enter, Escape)
- Screen reader announcements for sort and filter changes
- ARIA labels on all interactive elements

Props interface:
- data, columns, isLoading, pagination, onSort, onFilter, onSelect

Include a usage example with a user list table.

Konfigurations- & DevOps-Prompt

DevOps- und Konfigurations-Prompts sollten die Zielumgebung, Sicherheitsanforderungen und organisatorische Standards angeben. Dies verhindert, dass die KI generische Konfigurationen generiert, die nicht zu Ihrer Infrastruktur passen.

Create a Docker Compose setup for a development environment with:
- Next.js app (hot reload enabled)
- PostgreSQL 16 with persistent volume
- Redis for session storage
- MinIO (S3-compatible) for local file storage

Requirements:
- All services on a shared network
- Environment variables from .env file
- Health checks for all services
- Volumes for node_modules (avoid bind mount issues)
- PostgreSQL initialized with seed data
- Non-root containers where possible

Also create:
- Dockerfile for the Next.js app (multi-stage build)
- .env.example with all required variables
- Makefile with common commands (up, down, logs, reset-db)

Fortgeschrittene Prompt-Strategien

Sobald Sie die grundlegenden Techniken und Befehle beherrschen, helfen Ihnen diese fortgeschrittenen Strategien bei komplexen, mehrstufigen Entwicklungsaufgaben, die über die Fähigkeiten eines einzelnen Prompts hinausgehen.

Prompt-Verkettung

Prompt-Verkettung zerlegt komplexe Aufgaben in eine Reihe kleinerer, fokussierterer Prompts, wobei jeder auf der Ausgabe des vorherigen aufbaut. Diese Strategie liefert bessere Ergebnisse als der Versuch, alles in einem einzigen riesigen Prompt zu erledigen, da jeder Schritt die volle Aufmerksamkeit und den vollen Kontext der KI erhält.

# Step 1: Design the architecture
"Design the architecture for a real-time chat application.
List the components, their responsibilities, and how they
communicate. Use a diagram-like text format."

# Step 2: Define the data model
"Based on the architecture above, design the database schema
for the chat application. Include users, conversations,
messages, and read receipts. Use Prisma schema format."

# Step 3: Implement the API
"Implement the REST API for the chat application based on
the architecture and schema we designed. Start with the
message endpoints: send, list, delete."

# Step 4: Add WebSocket support
"Now add WebSocket support for real-time message delivery.
Use Socket.io. Integrate with the existing message API."

# Step 5: Write tests
"Write integration tests for the chat API and WebSocket
events using Jest and Supertest."

Der Schlüssel zu effektiver Prompt-Verkettung liegt darin, sicherzustellen, dass jeder Schritt eine vollständige, nutzbare Ausgabe produziert, bevor Sie zum nächsten übergehen. Überprüfen Sie jede Ausgabe, korrigieren Sie bei Bedarf und geben Sie dann das verfeinerte Ergebnis in den nächsten Prompt ein.

Kontextanreicherung

Kontextanreicherung beinhaltet das Bereitstellen aller relevanten Code-, Dokumentations- und Kontextinformationen an die KI vor der Fragestellung. Obwohl dies offensichtlich erscheint, überspringen viele Entwickler diesen Schritt und wundern sich dann, warum die KI falsche Annahmen trifft. Je mehr relevanten Kontext Sie bereitstellen, desto genauer und spezifischer wird die Antwort der KI sein.

 {
    await this.db.query('UPDATE users SET email = $1 WHERE id = $2', [email, id]);
    await this.cache.del(`user:${id}`);
  }
}
```

Here is the User type:
```typescript
interface User {
  id: string;
  email: string;
  name: string;
  role: 'admin' | 'user';
  createdAt: Date;
}
```

Now, add an updateProfile method that allows updating name and email,
with validation that the email is not already taken by another user.

Beachten Sie, wie die Bereitstellung von bestehendem Code und Typen es der KI ermöglicht, Methoden zu generieren, die perfekt mit bestehenden Mustern übereinstimmen, dieselbe Caching-Strategie verwenden und den vorhandenen Typdefinitionen folgen.

Einschränkungsspezifikation

Das Setzen expliziter Einschränkungen verhindert, dass die KI unerwünschte Annahmen trifft. Einschränkungen definieren, was die KI nicht tun soll, was oft genauso wichtig ist wie das, was sie tun soll. Häufige Einschränkungen umfassen Technologieversionen, Leistungsanforderungen, Sicherheitsregeln und Codierungsstandards.

Build a URL shortener API with these constraints:

MUST:
- Use Node.js 20+ with native fetch (no axios)
- Use PostgreSQL via pg driver (no ORM)
- Generate short codes of exactly 7 characters
- Support custom aliases (max 20 chars)
- Return 301 for existing short URLs
- Rate limit to 100 creates per hour per IP

MUST NOT:
- Use any ORM or query builder
- Store full URLs without normalization
- Allow short codes that conflict with existing routes
- Return database errors to the client

PERFORMANCE:
- Handle 10,000 requests per second
- Cache hot URLs in Redis with 5-minute TTL
- P99 latency under 50ms for redirects

Ausgabeformatkontrolle

Die Angabe des gewünschten Ausgabeformats stellt sicher, dass die Antwort der KI ohne Neuformatierung sofort verwendbar ist. Dies ist besonders wichtig, wenn die Ausgabe von anderen Tools geparst, in Dokumentation eingefügt oder als Konfigurationsdatei verwendet werden soll.

Analyze this codebase and provide the output in this exact format:

## Architecture Overview
[2-3 paragraph summary]

## Component Diagram
```mermaid
graph TD
    [components and relationships]
```

## API Endpoints
| Method | Path | Description | Auth |
|--------|------|-------------|------|

## Database Tables
| Table | Columns | Indexes | Relations |
|-------|---------|---------|-----------|

## Recommendations
1. [Priority] [Description] - [Estimated effort]
2. ...

## Technical Debt
- [ ] [Description] - [Impact: High/Medium/Low]

Iterative Verfeinerung

Iterative Verfeinerung ist die Praxis, die KI-Ausgabe durch nachfolgende Prompts schrittweise zu verbessern. Die erste Antwort ist selten perfekt, bietet aber einen Ausgangspunkt, der verfeinert werden kann. Jede Iteration bringt Sie dem gewünschten Ergebnis näher, und zwar effizienter als der Versuch, mit einem einzigen Prompt Perfektion zu erreichen.

# Iteration 1: Get a starting point
"Write a rate limiter middleware for Express.js"

# Iteration 2: Add specificity
"Good start. Now modify it to use Redis for distributed
rate limiting across multiple server instances. Use sliding
window instead of fixed window."

# Iteration 3: Add edge cases
"Add handling for: Redis connection failures (fall back to
in-memory), custom rate limits per route, burst allowance
for legitimate traffic spikes, and proper headers
(X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset)."

# Iteration 4: Add tests
"Write comprehensive tests for all the scenarios we've
covered, including Redis failures and burst handling."

Dieser iterative Ansatz ist effektiver als das Schreiben eines einzelnen riesigen Prompts, da jede Iteration es Ihnen ermöglicht, basierend auf der vorherigen Ausgabe der KI Kurskorrekturen vorzunehmen und Details hinzuzufügen. Es spiegelt die Art und Weise wider, wie Sie mit einem menschlichen Entwickler zusammenarbeiten: Beginnen Sie mit einer groben Implementierung und verfeinern Sie dann.

Toolspezifische Prompt-Tipps

Obwohl die oben genannten Techniken auf alle KI-Tools anwendbar sind, hat jede Plattform einzigartige Stärken und Eigenheiten. Die Anpassung Ihres Prompt-Stils an die Eigenschaften jedes Tools kann die Ergebnisse erheblich verbessern.

ChatGPT / GPT-4

ChatGPT und GPT-4 zeichnen sich durch konversationelle Interaktion aus und profitieren von strukturierten, gut organisierten Prompts. Sie verarbeiten lange Kontexte gut und sind besonders stark darin, Konzepte zu erklären und Dokumentation zu generieren.

• Benutzerdefinierte Anweisungen verwenden: Legen Sie Ihren Tech-Stack und Ihre Präferenzen in den benutzerdefinierten Anweisungen von ChatGPT fest, damit Sie sie nicht in jeder Konversation wiederholen müssen.
• Code Interpreter nutzen: Bitten Sie ChatGPT bei Datenanalyseaufgaben, den Code Interpreter zu verwenden, um Python-Code auszuführen und Visualisierungen zu generieren.
• Markdown-Formatierung in Prompts verwenden: GPT-4 reagiert gut auf strukturierte Prompts mit Überschriften, Aufzählungszeichen und Codeblöcken.
• Antwortlänge angeben: GPT-4 neigt zur Ausführlichkeit. Fügen Sie "be concise" oder "in under 200 words" hinzu, wenn Sie Kürze benötigen.
• Systemnachrichten verwenden: Verwenden Sie in der API Systemnachrichten, um persistente Anweisungen wie Codierungsstandards und Projektkontext festzulegen.

# Effective GPT-4 prompt structure
**Role:** Senior TypeScript developer
**Task:** Implement a JWT authentication middleware
**Context:** Express.js API, PostgreSQL, existing User model
**Constraints:** No external auth libraries, use crypto module
**Output:** Complete, production-ready code with types
**Format:** Single file with inline comments for complex logic

Claude / Claude Code

Claude und Claude Code sind besonders stark darin, große Codebasen zu verstehen, komplexen Anweisungen zu folgen und gut strukturierte Ausgaben zu produzieren. Die Agentenfähigkeiten von Claude Code machen es ideal für mehrstufige Aufgaben.

• CLAUDE.md verwenden: Dies ist das Einflussreichste, was Sie tun können. Platzieren Sie Ihren Projektkontext, Ihre Konventionen und Präferenzen in CLAUDE.md.
• Dateipositionen explizit angeben: Claude Code funktioniert am besten, wenn Sie angeben, welche Dateien gelesen und geändert werden sollen.
• Befehle ausführen lassen: Claude Code kann Test- und Build-Befehle ausführen. Bitten Sie es, seine Arbeit durch die Ausführung von Tests zu validieren.
• /compact in langen Sitzungen verwenden: Wenn der Kontext lang wird, verwenden Sie /compact, um die Konversation zu komprimieren und dabei die wichtigsten Informationen zu bewahren.
• XML-Tags nutzen: Claude reagiert gut auf XML-markierte Abschnitte in Prompts, um verschiedene Teile der Anfrage klar abzugrenzen.

# Effective Claude Code prompt
Read the following files to understand the current architecture:
- src/routes/userRoutes.ts
- src/middleware/authMiddleware.ts
- src/models/User.ts

Then refactor the authentication flow to support:
1. JWT access tokens (15 min expiry) + refresh tokens (7 day expiry)
2. Token rotation on refresh (invalidate old refresh token)
3. Rate limiting on the refresh endpoint (5 per minute per user)

Update all related files and run the test suite when done.

GitHub Copilot

GitHub Copilot funktioniert anders als chatbasierte Tools – es liefert Inline-Vorschläge, während Sie tippen. Die effektive Nutzung von Copilot hängt davon ab, Code zu schreiben, der die Absicht durch Kommentare, Typsignaturen und umgebenden Kontext klar kommuniziert.

• Deskriptive Kommentare schreiben: Fügen Sie vor Funktionen Kommentare wie // Validate email format and check for duplicates hinzu, um Copilot eine klare Absicht zu geben.
• TypeScript-Typen verwenden: Gut definierte Typen und Schnittstellen führen Copilot zur richtigen Implementierung.
• Beispiele in Kommentaren bereitstellen: Zeigen Sie erwartete Ein-/Ausgaben in Kommentaren, um Copilot zu helfen, Ihr gewünschtes Format zu treffen.
• Teilvorschläge akzeptieren: Manchmal hat Copilot die richtige Struktur, aber falsche Details. Akzeptieren Sie den Vorschlag und bearbeiten Sie dann die Details.
• Copilot Chat für komplexe Aufgaben verwenden: Verwenden Sie für Multi-Datei-Änderungen oder Architekturentscheidungen Copilot Chat statt Inline-Vorschlägen.

> {
  // Copilot will generate the implementation based on these types

Cursor

Cursor kombiniert IDE-Integration mit KI-Chat-Funktionen und bietet Inline-Vervollständigungen sowie eine Chat-Oberfläche, die Ihre Codebasis kennt. Seine Stärke liegt in der tiefen Projektwahrnehmung und der Fähigkeit, auf bestimmte Dateien und Symbole zu verweisen.

• @file-Referenzen verwenden: Referenzieren Sie bestimmte Dateien mit @filename, um Cursor präzisen Kontext zu geben.
• @codebase für breiten Kontext verwenden: Verwenden Sie @codebase, wenn Cursor das gesamte Projekt durchsuchen soll.
• @docs für Bibliotheksdokumentation verwenden: Cursor kann mit @docs auf Dokumentation von Drittanbieter-Bibliotheken verweisen.
• Cmd+K für Inline-Bearbeitung nutzen: Wählen Sie Code aus und verwenden Sie Cmd+K, um Änderungen in natürlicher Sprache zu beschreiben.
• Projektregeln einrichten: Verwenden Sie eine .cursorrules-Datei (ähnlich wie CLAUDE.md), um persistente Projektanweisungen festzulegen.

# Effective Cursor prompt
@src/services/paymentService.ts @src/types/payment.ts

Refactor the processPayment function to use the Strategy pattern.
Create separate strategy classes for each payment provider
(Stripe, PayPal, BankTransfer). The function should accept a
payment method and delegate to the appropriate strategy.

Keep the same public API so existing callers don't break.

Codex CLI

Codex CLI ist der terminalbasierte Programmieragent von OpenAI, konzeptionell ähnlich wie Claude Code. Es zeichnet sich durch die Ausführung mehrstufiger Entwicklungsaufgaben von der Kommandozeile aus.

• Klare Ziele vorgeben: Codex CLI funktioniert am besten mit klaren, übergeordneten Zielen statt schrittweisen Anweisungen.
• Arbeitsverzeichnis angeben: Stellen Sie sicher, dass Sie Codex CLI aus dem richtigen Projektstammverzeichnis ausführen.
• Zuerst den Vorschlagsmodus verwenden: Überprüfen Sie den Plan von Codex im Vorschlagsmodus, bevor Sie Änderungen vornehmen lassen.
• Sandbox-Berechtigungen sorgfältig einrichten: Kontrollieren Sie durch die Konfiguration der Sandbox-Berechtigungen, was Codex ausführen darf.
• Ausgabe iterieren: Wie bei anderen Tools muss der erste Versuch möglicherweise durch nachfolgende Prompts verfeinert werden.

Häufige Fehler und wie man sie vermeidet

Selbst erfahrene Entwickler machen diese häufigen Prompt-Fehler. Sie zu erkennen und zu vermeiden, wird Ihre KI-Interaktionen sofort verbessern.

Vage Anweisungen

Der häufigste Fehler ist, vage, unzureichend spezifische Anweisungen zu geben. Prompts wie "Repariere das", "Mach es besser" oder "Füge Funktionen hinzu" geben der KI kaum nützliche Informationen. Die KI trifft Annahmen, die oft nicht Ihrer Absicht entsprechen.

# Bad
"Fix the login bug"

# Good
"Fix the bug where users with uppercase emails cannot log in.
The issue is in src/auth/login.ts - the email comparison is
case-sensitive but emails are stored in lowercase in the database.
The fix should normalize the email to lowercase before comparison."

Fehlender Kontext

KI-Modelle kennen Ihr Projekt nicht, es sei denn, Sie teilen es ihnen mit. Das Versäumnis, relevanten Kontext bereitzustellen – Ihren Tech-Stack, Framework-Versionen, bestehende Code-Muster oder Projektstruktur – zwingt die KI zum Raten, und sie rät oft falsch. Geben Sie immer den Kontext an, den ein neues Teammitglied benötigen würde, um Ihre Anfrage zu verstehen.

# Bad
"Write a function to send emails"

# Good
"Write an email sending function for our NestJS application.
We use:
- @nestjs/mailer with Handlebars templates
- SMTP via AWS SES
- Templates stored in src/templates/emails/
- Existing MailService class in src/mail/mail.service.ts

The function should accept a template name, recipient, and
template variables. Include error handling for SES throttling
and bounce notifications."

Prompt-Überladung

Der Versuch, zu viele unzusammenhängende Aufgaben in einem einzigen Prompt zu erledigen, führt zu mittelmäßigen Ergebnissen in allen Bereichen. Die Aufmerksamkeit der KI wird zerstreut, und sie überspringt möglicherweise wichtige Details bei einigen Aufgaben, während sie sich übermäßig auf andere konzentriert. Zerlegen Sie komplexe Anfragen in fokussierte, sequenzielle Prompts.

# Bad - Too many tasks in one prompt
"Build a complete user management system with authentication,
profile management, email verification, password reset,
role-based access control, and an admin dashboard"

# Good - Break it into focused prompts
Prompt 1: "Design the database schema for a user management system..."
Prompt 2: "Implement the authentication endpoints..."
Prompt 3: "Add email verification flow..."
Prompt 4: "Implement role-based access control middleware..."

Ausgabeformat ignorieren

Wenn Sie eine Ausgabe in einem bestimmten Format benötigen – JSON, Markdown, eine bestimmte Dateistruktur – führt die Nichtangabe zu unvorhersehbaren Formaten. Die KI könnte Prosa zurückgeben, wenn Sie JSON benötigen, oder eine einzelne Datei, wenn Sie mehrere benötigen. Geben Sie immer explizit das gewünschte Ausgabeformat an.

# Bad
"List all the API endpoints"

# Good
"List all API endpoints in a markdown table with these columns:
| Method | Path | Description | Auth Required | Request Body | Response |"

Keine Iteration

Die erste Antwort der KI ohne Verfeinerung zu akzeptieren, ist eine verpasste Chance. Die erste Antwort bietet eine Grundlage, die Sie durch nachfolgende Prompts verbessern können. Iteration ist der Ort, an dem die wahre Stärke der KI-unterstützten Entwicklung liegt – jeder Zyklus produziert bessere, verfeinerte Ausgaben.

# Instead of accepting the first response, iterate:
"Good start. Now add input validation using Zod schemas."
"Now add proper error handling with custom error classes."
"Now add logging for all operations."
"Now write tests for all the edge cases we've discussed."

Prompt-Vorlagenbibliothek

Im Folgenden finden Sie gebrauchsfertige Prompt-Vorlagen für häufige Entwickleraufgaben. Kopieren Sie diese Vorlagen, füllen Sie die Platzhalter aus und passen Sie sie an Ihre spezifischen Bedürfnisse an. Jede Vorlage kombiniert mehrere Prompt-Techniken für maximale Effektivität.

Vorlage 1: Funktionsimplementierung

You are a senior {language} developer specializing in {framework}.

Implement {feature_description} for our {project_type} application.

Tech stack:
- {language} {version} with {framework} {version}
- {database} for data storage
- {orm} for database access
- {testing_framework} for tests

Requirements:
- {requirement_1}
- {requirement_2}
- {requirement_3}

Constraints:
- Must follow existing patterns in the codebase
- Must include input validation
- Must handle errors gracefully
- Must be backward compatible

Output:
1. Implementation code with inline comments for complex logic
2. Unit tests covering happy path and edge cases
3. Brief explanation of design decisions

Vorlage 2: Bug-Untersuchung

You are a debugging specialist with expertise in {language}/{framework}.

Investigate and fix this bug:

**Symptom:** {describe_the_observed_behavior}
**Expected:** {describe_the_expected_behavior}
**Frequency:** {always/sometimes/under_specific_conditions}
**Environment:** {production/staging/development}

Relevant code:
```
{paste_relevant_code}
```

Error output / stack trace:
```
{paste_error_output}
```

Think step by step:
1. Identify the root cause
2. Explain why this bug occurs
3. Provide the fix with code
4. Suggest how to prevent similar bugs
5. Write a regression test

Vorlage 3: Code-Review

You are a senior code reviewer at a {company_type} company.

Review this {language} code for:

1. **Correctness:** Logic errors, off-by-one errors, null handling
2. **Security:** Injection, XSS, auth bypasses, data exposure
3. **Performance:** N+1 queries, unnecessary allocations, missing caches
4. **Maintainability:** Code smells, naming, complexity
5. **Testing:** Missing test cases, brittle tests

Code to review:
```
{paste_code}
```

For each issue found, provide:
- Severity: 🔴 Critical / 🟡 Warning / 🔵 Info
- Category: Which of the 5 areas above
- Description: What's wrong and why
- Suggestion: How to fix it, with code example

End with an overall assessment and top 3 priorities.

Vorlage 4: API-Endpunkt-Design

Design a {http_method} {endpoint_path} endpoint for {resource_description}.

Framework: {framework}
Auth: {auth_method}
Database: {database}

The endpoint should:
- {functionality_1}
- {functionality_2}
- {functionality_3}

Provide:
1. Route definition with middleware chain
2. Request validation schema ({validation_library})
3. Controller/handler function
4. Service layer function
5. Database query/function
6. Response types (success and error)
7. Example curl request and response

Vorlage 5: Datenbankmigration

Create a database migration for {change_description}.

Current schema:
```
{current_schema}
```

Desired changes:
- {change_1}
- {change_2}

ORM: {orm_name}
Database: {database_type}

Requirements:
- Migration must be reversible (include down migration)
- Preserve existing data (write data migration SQL if needed)
- Add appropriate indexes for new columns
- Consider performance impact on large tables
- Include rollback safety checks

Vorlage 6: Test-Suite-Generierung

Write a comprehensive test suite for {function_or_class_name}.

Testing framework: {framework}
Mocking library: {library}

Code under test:
```
{paste_code}
```

Test categories to cover:
- ✅ Happy path: All valid inputs produce correct outputs
- 🔄 Edge cases: Empty inputs, boundary values, null/undefined
- ❌ Error cases: Invalid inputs, permission denied, network failures
- 🏎️ Performance: Response time expectations for critical paths
- 🔒 Security: Auth checks, input sanitization

For each test:
- Use descriptive test names that read like documentation
- Follow Arrange-Act-Assert pattern
- Include setup/teardown for shared state
- Mock external dependencies

Vorlage 7: Refactoring-Plan

You are a software architect specializing in {language} refactoring.

Current code:
```
{paste_current_code}
```

Problems with current code:
- {problem_1}
- {problem_2}

Refactor using {pattern_or_principle}.

Provide:
1. **Analysis:** What's wrong and why the current approach doesn't scale
2. **Target Architecture:** How the refactored code should be structured
3. **Step-by-step Plan:** Ordered refactoring steps (safe, incremental)
4. **Refactored Code:** Complete implementation
5. **Migration Guide:** How to transition from old to new without breaking changes
6. **Risk Assessment:** What could go wrong and how to mitigate

Vorlage 8: Dokumentationsgenerierung

Generate documentation for this {language} code:

```
{paste_code}
```

Documentation type: {JSDoc/TSDoc/Python docstrings/README section}

Requirements:
- Document all public functions/classes/methods
- Include parameter descriptions with types
- Include return type descriptions
- Add usage examples for non-obvious APIs
- Note any side effects or important caveats
- Use {style_guide} conventions

For README documentation, include:
- Overview (1-2 paragraphs)
- Installation instructions
- Quick start example
- API reference table
- Configuration options

Vorlage 9: Leistungsoptimierung

You are a performance engineering specialist.

Analyze and optimize this code for performance:

```
{paste_code}
```

Current performance:
- {metric}: {current_value}
- Target: {target_value}
- Bottleneck suspected at: {location}

Optimization constraints:
- Must not change the public API
- Must maintain all existing test passes
- Must not sacrifice readability for micro-optimizations
- {additional_constraint}

Provide:
1. **Profiling Analysis:** Where time/memory is being spent
2. **Optimization Strategies:** Ranked by expected impact
3. **Optimized Code:** With comments explaining each change
4. **Benchmark Comparison:** Before vs after expected metrics
5. **Trade-offs:** Any readability or complexity costs

Vorlage 10: Sicherheitsaudit

You are a security engineer specializing in {language}/{framework} security.

Perform a security audit on this code:

```
{paste_code}
```

Check for:
- Injection attacks (SQL, NoSQL, command, LDAP)
- Authentication and authorization bypasses
- Cross-site scripting (XSS) vulnerabilities
- Cross-site request forgery (CSRF) exposure
- Insecure direct object references (IDOR)
- Sensitive data exposure (logging, error messages)
- Insecure cryptography or key management
- Race conditions in concurrent operations
- Denial of service vulnerabilities

For each finding:
- Severity: Critical / High / Medium / Low
- OWASP Category: Which Top 10 category
- Description: Clear explanation of the vulnerability
- Attack Scenario: How an attacker would exploit it
- Remediation: Specific code fix
- Verification: How to confirm the fix works