Kurzreferenz für Prompt-Vorlagen

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ü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

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

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