Prontuario dei modelli di prompt

Fix the bug 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 causa principale in `[relevant file/directory]`
2. Implement a fix that addresses the causa principale
3. Add a regression test to prevent this issue from recurring
4. Run the existing suite di test to ensure no regressions

Users are reporting `[describe the issue]` in production.

Please:
1. Use the `[Sentry/DataDog/Log monitoring tool]` MCP to pull recent error logs and stack traces
2. Identify the causa principale of the issue
3. Implement a fix
4. Add appropriate error handling to prevent similar issues
5. Create a regression test
6. Link the monitoring/alert in the PR description

Crea un nuovo endpoint API `[percorso endpoint]` che `[descrivi cosa fa]`.

Requisiti:
- Metodo: `[GET/POST/PUT/DELETE]`
- Corpo della richiesta: `[descrivi la struttura della richiesta]`
- Formato della risposta: `[descrivi la struttura della risposta]`
- Autenticazione: `[descrivi i requisiti di autenticazione]`

Operazioni richieste:
1. Consulta il file `[file endpoint simile]` esistente per i patterns
2. Implementa l'endpoint seguendo le conventions esistenti
3. Aggiungi la validazione degli input e la gestione degli errori
4. Scrivi unit test per il nuovo endpoint
5. Aggiorna la documentazione delle API, se applicabile
6. Esegui la suite di test per verificare che tutto funzioni correttamente

Aggiungi un nuovo componente `[component type]` in `[file/location]`.

Requisiti:
- Nome del componente: `[ComponentName]`
- Props: `[list props and their types]`
- Funzionalità: `[describe what it should do]`
- Stile: usa `[existing component/library]` come riferimento

Esegui le seguenti operazioni:
1. Crea il componente seguendo i pattern esistenti
2. Implementa la funzionalità richiesta
3. Aggiungi i tipi TypeScript appropriati
4. Applica uno stile coerente con il design system
5. Aggiungi unit test per il componente
6. Integralo in `[parent component/page]`
7. Testalo manualmente avviando il server di sviluppo

Implementa la funzionalità `[feature name]` dal file di design: `[Figma/link to design]`

Concentrati sul frame `[specific frame/section]`.

Requisiti:
- Utilizza i componenti esistenti da `[component library path]`
- Segui lo stile definito in `[design system file]`
- Garantisci un design responsive a `[breakpoint 1]` e `[breakpoint 2]`

Operazioni richieste:
1. Implementa la funzionalità seguendo le specifiche di design
2. Riutilizza i componenti esistenti dove possibile
3. Testa alle larghezze desktop (1440px) e mobile (375px)
4. Fai degli screenshot per verificare la corrispondenza con il design
5. Non aprire una pull request (PR) finché il risultato non corrisponde visivamente al design

Esegui il refactoring di `[nome modulo/file]` per migliorare `[aspetto specifico: manutenibilità/prestazioni/leggibilità]`.

Problemi attuali:
- `[Issue 1]`
- `[Issue 2]`
- `[Issue 3]`

Requisiti:
- Mantenere intatta tutta la funzionalità esistente
- Seguire i pattern in `[file di riferimento]`
- Migliorare `[metrica specifica: complessità del codice/prestazioni]`

Operazioni richieste:
1. Analizzare l'implementazione attuale
2. Eseguire il refactoring seguendo le best practice
3. Verificare che tutti i test esistenti continuino a passare
4. Aggiungere test per eventuali nuove funzioni introdotte
5. Eseguire la suite di test completa
6. Misurare e riportare i miglioramenti delle prestazioni, se applicabile

Converti `[file/directory]` per utilizzare `[nuovo pattern/libreria/framework]`.

Riferimento: `[collegamento alla documentazione o al file di esempio]`

Requisiti:
- Mantenere tutte le funzionalità esistenti
- Seguire le convenzioni in `[file di esempio]`
- Aggiorna il codice dipendente

Operazioni da eseguire:
1. Esamina la documentazione e gli esempi
2. Converti il codice passaggio per passaggio
3. Aggiorna le importazioni e le dipendenze
4. Assicurati che tutti i test vengano superati
5. Esegui `[build command]` per verificare l'assenza di errori
6. Testa manualmente le funzionalità

Add comprehensive test coverage for `[file/module/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

Trova una soluzione per i test che falliscono in `[test file or directory]`.

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

Per favore:
1. Analizza il motivo per cui questi test stanno fallendo
2. Determina se è necessario correggere i test o l'implementazione
3. Risolvi la causa principale
4. Assicurati che tutti i test nella suite passino
5. Run la suite di test completa per verificare eventuali regressioni

Aggiungi documentazione completa a `[file/module]`.

Per favore:
1. Aggiungi commenti JSDoc/TypeDoc a tutte le funzioni pubbliche
2. Documenta parametri, valori restituiti ed eccezioni
3. Aggiungi esempi d'uso per le funzioni complesse
4. Crea un README se si tratta di un nuovo modulo
5. Segui la nostra guida di stile per la documentazione in `[style guide link]`
6. Aggiorna la documentazione principale delle API se applicabile

Aggiorna la documentazione API per `[endpoint/function]`.

Modifiche apportate:
- `[Change 1]`
- `[Change 2]`

Operazioni richieste:
1. Aggiorna la specifica `[OpenAPI/Swagger]`
2. Aggiorna eventuali commenti inline nel codice
3. Aggiungi esempi d'uso se il comportamento è cambiato
4. Aggiorna il `[documentation file]`
5. Verifica che la documentazione venga generata correttamente

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

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/modulo]`.

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

Aggiorna `[package/library]` dalla versione `[old version]` alla versione `[new version]`.

Operazioni richieste:
1. Esamina il changelog per verificare la presenza di modifiche incompatibili: `[changelog link]`
2. Aggiorna la dipendenza in `[package.json/requirements.txt]`
3. Aggiorna eventuali utilizzi di API deprecate
4. Esegui lo script di migrazione, se applicabile: `[migration command]`
5. Esegui tutti i test per verificare la compatibilità
6. Testa l'applicazione manualmente
7. Aggiorna la documentazione se le API sono cambiate

Esegui la migrazione da `[old service]` a `[new service]`.

Documentazione di riferimento: `[link to new service docs]`

Operazioni da eseguire:
1. Configura il nuovo servizio seguendo la documentazione
2. Esegui la migrazione dei dati/configurazioni esistenti
3. Aggiorna tutto il codice per utilizzare il nuovo servizio
4. Consulta `[example file]` per i pattern di implementazione
5. Esegui i test di integrazione per verificare la funzionalità
6. Esegui il rollout graduale e monitora eventuali issue
7. Dismetti il vecchio servizio dopo la verifica

Esamina la pull request: `[PR link or number]`

Aree di interesse:
- Qualità e manutenibilità del codice
- Implicazioni sulle prestazioni
- Considerazioni sulla sicurezza
- Copertura dei test
- Documentazione

Per favore:
1. Esamina ogni file modificato
2. Lascia commenti specifici e concreti
3. Verifica che le modifiche siano conformi alla descrizione della PR
4. Controlla i casi limite e la gestione degli errori
5. Assicurati che i test siano adeguati
6. Approva o richiedi modifiche con un feedback chiaro

Ho bisogno di implementare `[feature/functionality]` usando `[technology/library]`.

Per favore:
1. Studia le best practice per `[technology/library]`
2. Trova e consulta la documentazione: `[expected doc sources]`
3. Esamina esempi open-source, se applicabile
4. Proponi un approccio prima di implementare
5. Implementa la soluzione seguendo le best practice
6. Aggiungi test e documentazione
7. Verifica che funzioni come previsto

Qualcosa non funziona in `[feature/component]`.

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

Eseguire le seguenti operazioni:
1. Analizzare il problema in `[relevant files]`
2. Aggiungere istruzioni di logging/debugging se necessario
3. Identificare la causa principale
4. Implementare una soluzione
5. Testare la soluzione a fondo
6. Rimuovere il codice di debugging temporaneo
7. Verificare che non vi siano regressioni