> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Kurzreferenz für Prompt-Vorlagen

> Sofort einsetzbare Prompt-Vorlagen für häufige Aufgaben

<Note>Verwenden Sie diese Vorlagen als Ausgangspunkt für Ihre Prompts. Passen Sie die Abschnitte in eckigen Klammern `[wie diesen]` an Ihre spezifischen Anforderungen an.</Note>

<div id="bug-fixes">
  ## Fehlerbehebungen
</div>

<div id="fix-a-specific-bug">
  ### Einen bestimmten Fehler beheben
</div>

```
Fix the Fehler where `[describe the bug behavior]`.

Steps to reproduce:
1. `[Step 1]`
2. `[Step 2]`
3. `[Step 3]`

Expected behavior: `[what should happen]`
Actual behavior: `[what actually happens]`

Please:
1. Investigate the root cause in `[relevant file/directory]`
2. Implement a fix that addresses the root cause
3. Add a regression test to prevent this issue from recurring
4. Run the existing test suite to ensure no regressions
```

<div id="investigate-production-issue">
  ### Produktionsproblem untersuchen
</div>

```
Nutzer melden `[describe the issue]` in der Produktionsumgebung.

Bitte:
1. Verwende das `[Sentry/DataDog/Log monitoring tool]` MCP, um aktuelle Fehler-Logs und Stack-Traces abzurufen
2. Identifiziere die Grundursache des Problems
3. Implementiere einen Fix
4. Füge eine geeignete Fehlerbehandlung hinzu, um ähnliche Probleme zu verhindern
5. Erstelle einen Regressionstest
6. Verlinke das Monitoring/den Alert in der PR-Beschreibung
```

<div id="feature-implementation">
  ## Feature-Implementierung
</div>

<div id="add-a-new-api-endpoint">
  ### Neuen API-Endpunkt hinzufügen
</div>

```
Erstelle einen neuen API-Endpunkt `[endpoint path]`, der `[describe what it does]`.

Anforderungen:
- Methode: `[GET/POST/PUT/DELETE]`
- Request-Body: `[describe request structure]`
- Antwortformat: `[describe response structure]`
- Authentifizierung: `[describe auth requirements]`

Bitte:
1. Verwende den vorhandenen `[similar endpoint file]` als Referenz für Muster
2. Implementiere den Endpunkt gemäß unseren bestehenden Konventionen
3. Füge Eingabevalidierung und Fehlerbehandlung hinzu
4. Schreibe Unit-Tests für den neuen Endpunkt
5. Aktualisiere die API-Dokumentation, falls zutreffend
6. Führe die Test-Suite aus, um sicherzustellen, dass alles erfolgreich durchläuft
```

<div id="add-a-new-ui-component">
  ### Eine neue UI-Komponente hinzufügen
</div>

```
Füge eine neue `[component type]`-Komponente zu `[file/location]` hinzu.

Anforderungen:
- Komponentenname: `[ComponentName]`
- Props: `[list props and their types]`
- Funktionalität: `[describe what it should do]`
- Styling: Verwende `[existing component/library]` als Referenz

Bitte:
1. Erstelle die Komponente gemäß unseren bestehenden Mustern
2. Implementiere die erforderliche Funktionalität
3. Füge korrekte TypeScript-Typen hinzu
4. Gestalte sie so, dass sie zu unserem Design-System passt
5. Füge Unit-Tests für die Komponente hinzu
6. Integriere sie in `[parent component/page]`
7. Teste sie manuell durch Starten des Dev-Servers
```

<div id="implement-a-feature-from-design">
  ### Ein Feature anhand eines Designs implementieren
</div>

```
Implementiere `[feature name]` aus dieser Design-Datei: `[Figma/link to design]`

Konzentriere dich auf den Frame `[specific frame/section]`.

Anforderungen:
- Verwende unsere vorhandenen Komponenten aus `[component library path]`
- Halte dich an das Styling in `[design system file]`
- Stelle responsives Design bei `[breakpoint 1]` und `[breakpoint 2]` sicher

Bitte:
1. Implementiere das Feature gemäß den Design-Spezifikationen
2. Verwende vorhandene Komponenten, wo immer möglich
3. Teste bei Desktop-Breite (1440px) und mobiler Breite (375px)
4. Erstelle Screenshots, um zu überprüfen, ob es dem Design entspricht
5. Öffne keinen PR, bis es visuell mit dem Design übereinstimmt
```

<div id="code-refactoring">
  ## Refactoring von Code
</div>

<div id="refactor-a-module">
  ### Ein Modul refaktorieren
</div>

```
Refaktoriere `[Modul-/Dateiname]`, um `[spezifischen Aspekt: Wartbarkeit/Performance/Lesbarkeit]` zu verbessern.

Aktuelle Probleme:
- `[Problem 1]`
- `[Problem 2]`
- `[Problem 3]`

Anforderungen:
- Alle bestehenden Funktionen unverändert beibehalten
- Den Mustern in `[Referenzdatei]` folgen
- `[spezifische Metrik: Code-Komplexität/Performance]` verbessern

Bitte:
1. Die aktuelle Implementierung analysieren
2. Nach Best Practices refaktorieren
3. Sicherstellen, dass alle bestehenden Tests weiterhin bestehen
4. Tests für neu eingeführte Funktionen hinzufügen
5. Die vollständige Test-Suite ausführen
6. Performance-Verbesserungen messen und dokumentieren, sofern zutreffend
```

<div id="convert-to-new-pattern">
  ### Auf neues Muster umstellen
</div>

```
Konvertiere `[file/directory]`, um `[new pattern/library/framework]` zu verwenden.

Referenz: `[link to documentation or example file]`

Anforderungen:
- Alle vorhandenen Funktionen beibehalten
- Den Konventionen in `[example file]` folgen
- Abhängigen Code aktualisieren

Bitte:
1. Dokumentation und Beispiele prüfen
2. Den Code Schritt für Schritt konvertieren
3. Importe und Abhängigkeiten aktualisieren
4. Sicherstellen, dass alle Tests bestehen
5. `[build command]` ausführen, um sicherzustellen, dass keine Fehler auftreten
6. Die Funktionalität manuell testen
```

<div id="testing">
  ## Tests
</div>

<div id="add-test-coverage">
  ### Testabdeckung erweitern
</div>

```
Add comprehensive test coverage for `[file/Modul/function]`.

Current coverage: `[current coverage %]`
Target coverage: `[target coverage %]`

Please:
1. Analyze the existing code to identify edge cases
2. Write unit tests for all public methods
3. Add integration tests if applicable
4. Reference `[existing test file]` for testing patterns
5. Run `npm test -- --coverage` and verify coverage meets target
6. Ensure all tests pass
```

<div id="debug-failing-tests">
  ### Debuggen fehlgeschlagener Tests
</div>

```
Fix the failing tests in `[test file or directory]`.

Test failures:
- `[Test name 1]`: `[error message]`
- `[Test name 2]`: `[error message]`

Please:
1. Investigate why these tests are failing
2. Determine if the tests or the implementation need fixing
3. Fix the root cause
4. Ensure all tests in the suite pass
5. Run the full test suite to check for regressions
```

<div id="documentation">
  ## Dokumentation
</div>

<div id="document-a-module">
  ### Ein Modul dokumentieren
</div>

```
Füge umfassende Dokumentation zu `[file/module]` hinzu.

Bitte:
1. JSDoc/TypeDoc-Kommentare zu allen öffentlichen Funktionen hinzufügen
2. Parameter, Rückgabewerte und Ausnahmen dokumentieren
3. Verwendungsbeispiele für komplexe Funktionen hinzufügen
4. Eine README erstellen, falls es sich um ein neues Modul handelt
5. Unseren Dokumentations-Styleguide in `[style guide link]` befolgen
6. Die Haupt-API-Dokumentation bei Bedarf aktualisieren
```

<div id="update-api-documentation">
  ### API-Dokumentation aktualisieren
</div>

```
Aktualisieren Sie die API-Dokumentation für `[Endpunkt/function]`.

Vorgenommene Änderungen:
- `[Change 1]`
- `[Change 2]`

Bitte:
1. Aktualisieren Sie die `[OpenAPI/Swagger]`-Spezifikation
2. Aktualisieren Sie alle Inline-Code-Kommentare
3. Fügen Sie Verwendungsbeispiele hinzu, wenn sich das Verhalten geändert hat
4. Aktualisieren Sie die `[documentation file]`
5. Überprüfen Sie, ob die Dokumentation erfolgreich erstellt wird
```

<div id="performance-optimization">
  ## Leistungsoptimierung
</div>

<div id="optimize-database-queries">
  ### Datenbankabfragen optimieren
</div>

```
Optimize the database queries in `[file/Modul]`.

Performance issues:
- `[Specific query]` is slow (takes `[time]`)
- `[Specific operation]` causes N+1 queries

Please:
1. Analyze the query execution plans
2. Add appropriate indexes to `[table/column]`
3. Refactor queries to use joins instead of N+1
4. Benchmark before and after performance
5. Ensure all tests still pass
6. Document the performance improvements
```

<div id="optimize-frontend-performance">
  ### Frontend-Leistung optimieren
</div>

```
Optimize the performance of `[component/page]`.

Performance issues:
- Slow initial load time
- Large bundle size
- Unnecessary re-renders

Please:
1. Analyze the bundle size using `[bundle analyzer]`
2. Implement code splitting for `[large module]`
3. Add memoization where appropriate
4. Optimize images and assets
5. Lazy load components below the fold
6. Measure performance improvements using Lighthouse
7. Ensure functionality remains intact
```

<div id="security">
  ## Sicherheit
</div>

<div id="fix-security-vulnerability">
  ### Sicherheitslücke beheben
</div>

```
Fix the security vulnerability identified in `[file/Modul]`.

Vulnerability type: `[e.g., SQL injection, XSS, CSRF]`
Severity: `[High/Medium/Low]`

Please:
1. Review the security advisory: `[link to advisory]`
2. Implement the recommended fix
3. Add input validation and sanitization
4. Add a security test to prevent regression
5. Run the security audit: `[audit command]`
6. Ensure no other similar vulnerabilities exist
```

<div id="add-security-headers">
  ### Sicherheitsheader hinzufügen
</div>

```
Add security headers to the `[application/API]`.

Required headers:
- `[Header 1]`: `[value]`
- `[Header 2]`: `[value]`
- `[Header 3]`: `[value]`

Please:
1. Configure the headers in `[config file]`
2. Test that headers are set correctly using `[tool/method]`
3. Ensure existing functionality is not broken
4. Document the security improvements
```

<div id="migration-upgrades">
  ## Migrationen und Upgrades
</div>

<div id="upgrade-dependency">
  ### Abhängigkeit aktualisieren
</div>

```
Upgrade `[package/library]` from version `[old version]` to version `[new version]`.

Please:
1. Review the changelog for breaking changes: `[changelog link]`
2. Update the dependency in `[package.json/requirements.txt]`
3. Update any deprecated API usage
4. Run the migration script if applicable: `[migration command]`
5. Run all tests to ensure compatibility
6. Test the application manually
7. Update documentation if APIs changed
```

<div id="migrate-to-new-service">
  ### Zu einem neuen Dienst migrieren
</div>

```
Migriere von `[old service]` zu `[new service]`.

Referenzdokumentation: `[link to new service docs]`

Bitte:
1. Richte den neuen Dienst gemäß der Dokumentation ein
2. Migriere vorhandene Daten/Konfigurationen
3. Aktualisiere den gesamten Code, um den neuen Dienst zu verwenden
4. Verwende `[example file]` als Referenz für Implementierungsmuster
5. Führe Integrationstests zur Überprüfung der Funktionalität durch
6. Führe einen schrittweisen Rollout durch und überwache auf Probleme hin
7. Nimm den alten Dienst nach der Überprüfung außer Betrieb
```

<div id="code-review">
  ## Codeüberprüfung
</div>

<div id="review-a-pull-request">
  ### Einen Pull Request überprüfen
</div>

```
Überprüfe den Pull Request: `[PR link or number]`

Schwerpunkte:
- Codequalität und Wartbarkeit
- Auswirkungen auf die Performance
- Sicherheitsaspekte
- Testabdeckung
- Dokumentation

Bitte:
1. Jede geänderte Datei überprüfen
2. Konkrete, umsetzbare Kommentare hinterlassen
3. Sicherstellen, dass die Änderungen die PR-Beschreibung berücksichtigen
4. Auf Randfälle und Fehlerbehandlung prüfen
5. Sicherstellen, dass die Tests ausreichend sind
6. Änderungen genehmigen oder mit klarem Feedback zur Überarbeitung anfordern
```

<div id="general-purpose">
  ## Allgemeine Verwendung
</div>

<div id="research-and-implement">
  ### Recherche und Implementierung
</div>

```
Ich muss `[feature/functionality]` mit `[technology/library]` implementieren.

Bitte:
1. Recherchiere die Best Practices für `[technology/library]`
2. Suche und prüfe die Dokumentation: `[expected doc sources]`
3. Schaue dir Open-Source-Beispiele an, falls zutreffend
4. Schlage einen Ansatz vor, bevor du mit der Implementierung beginnst
5. Implementiere die Lösung gemäß den Best Practices
6. Füge Tests und Dokumentation hinzu
7. Überprüfe, ob alles wie erwartet funktioniert
```

<div id="debug-and-fix">
  ### Debuggen und Fehler beheben
</div>

```
Something is wrong with `[feature/component]`.

Symptoms:
- `[Symptom 1]`
- `[Symptom 2]`

Please:
1. Investigate the issue in `[relevant files]`
2. Add logging/debugging statements as needed
3. Identify the root cause
4. Implement a fix
5. Test the fix thoroughly
6. Remove any temporary debugging code
7. Ensure no regressions
```

<Tip>**Profi-Tipp**: Für wiederkehrende Aufgaben empfiehlt es sich, ein [Playbook](/de/product-guides/creating-playbooks) mit diesen Vorlagen zu erstellen, damit du sie leicht wiederverwenden kannst.</Tip>