La Vera Magia dei Prompt
GitHub Copilot non è telepatico.
Sembra ovvio, ma è il cuore di tutto. La qualità di quello che Copilot ti produce dipende direttamente da come gli parli. Non dal fatto che sia "intelligente" (lo è), ma dal fatto che esegue le istruzioni che gli dai.
Pensa a Copilot come a un assistente molto competente, ma che non conosce la tua mente. Se chiedi:
"Scrivi una funzione per validare un utente"
Copilot potrebbe generarti:
- Una funzione semplice che controlla solo se l'email è valida
- Una complessa con hashing di password
- Una con logica di rate limiting
- O ancora qualcos'altro
Perché? Perché hai chiesto male.
Se invece chiedi:
"Scrivi una funzione TypeScript che valida i dati di registrazione di un nuovo utente:
- Controlla che email sia valida e unica (non duplicata)
- Controlla che password abbia almeno 8 caratteri, 1 maiuscola, 1 numero
- Ritorna {valid: true} o {valid: false, errors: [...]}, non throw
- Integrable con Express.js
Allora Copilot genererà esattamente quello che vuoi.
La differenza tra i due prompt? Chiarezza. Contesto. Vincoli. Output atteso.
In questo articolo imparerai a scrivere prompt che rendono Copilot davvero utile. Non sarà teoria—saranno template pratici che puoi usare oggi nel tuo editor.
Il Problema dei Prompt "Deboli"
Scenario Reale: Il Prompt Generico
Sei seduto davanti a VSCode. Hai una task: validare i dati di un form. Apri Inline Chat (Cmd+I) e scrivi:
Scrivi una funzione per validare un utente
Cosa succede?
Copilot genera qualcosa di generico. Magari una funzione che controlla solo il formato dell'email. Magari una che fa validazione di password, ma senza considerare il tuo framework. Magari con nomi di variabili diversi dal tuo stile.
Risultato: Dovrai:
- Leggere il codice generato
- Capire cosa fa
- Modificarlo per adattarlo al tuo progetto
- Ripetere il processo
Tempo perso: 15-20 minuti.
Perché Succede
Quando dai un prompt vago, Copilot deve indovinare:
- Che linguaggio stai usando (Python? JavaScript? Go?)
- Che framework (Express? Django? Spring Boot?)
- Che layer dell'applicazione (API endpoint? Service layer? Utility?)
- Quali sono le tue convenzioni di codice
- Quali priorità hai (performance? Sicurezza? Semplicità?)
- Che livello di complessità cerchi
Copilot farà delle ipotesi ragionevoli basate su quello che ha visto nel training. Ma non sarà quello che tu vuoi.
La regola d'oro: Non pretendere che Copilot indovini. Digli esattamente cosa serve.
La Struttura di un Prompt Efficace
Un buon prompt per Copilot segue quasi sempre una struttura mentale semplice:
"Nel contesto X, voglio ottenere Y, rispettando Z, producendo W"
Espanso:
| Elemento | Cosa significa | Esempio |
|---|---|---|
| Contesto (X) | Dove siamo? Quale stack tecnologico? | "Sto in un progetto React TypeScript con Redux" |
| Obiettivo (Y) | Cosa vuoi fare esattamente? | "Voglio creare un componente form" |
| Vincoli (Z) | Che limitazioni/regole devo rispettare? | "Senza usare librerie UI di terze parti" |
| Output (W) | Cosa esattamente mi dai? | "Dammi il codice + spiegazione dei hook usati" |
Esempio di Prompt ben Strutturato
Contesto: Sto sviluppando un'API REST in Node.js con Express e MongoDB. Uso la struttura pattern Service-Controller-Repository. Obiettivo: Creare un middleware di autenticazione basato su JWT. Vincoli: - Non modificare la struttura di cartelle esistente - Usare solo jsonwebtoken e bcrypt (librerie già installate) - Il token deve scadere dopo 24 ore - Deve validare sia l'access token che il refresh token - Deve supportare la logica di "remember me" (7 giorni) Output: Dammi il codice del middleware, poi una breve lista dei passaggi che fa
Questo prompt è 50 volte migliore del "Crea un middleware di auth" perché Copilot sa esattamente cosa fare.
Elemento 1: Il Contesto è Fondamentale
Cos'è il Contesto?
Il contesto è informazioni su dove siamo: il linguaggio, il framework, lo stile del progetto, le decisioni architetturali.
Anche se il tuo file è già aperto in VSCode e Copilot può leggerlo, digli comunque. Perché?
- Copilot non legge l'intero progetto—legge solo il file attuale e quelli aperti, a meno che non glie lo chiedi esplicitamente
- Scriverlo esplicitamente migliora l'output—Copilot capisce che sai quello che stai facendo
- Previene assunzioni sbagliate—se non lo dici, Copilot potrebbe pensare stai usando un framework diverso
Cosa Includere nel Contesto
Linguaggio: Python 3.11 Framework: Django 4.2 Database: PostgreSQL Pattern di architettura: MVC (models in models.py, views in views.py) Librerie di terze parti già usate: Django REST Framework, Celery Stile di codice: Preferisco type hints, docstrings, e classi per i serializer
Esempi di Contesto per Linguaggi Diversi
JavaScript/Node.js:
Sto in un progetto Node.js con Express.js e TypeScript. Uso async/await ovunque. Il progetto ha una struttura di cartelle: routes/, controllers/, services/, models/ Uso Prisma per il database.
Python:
Progetto Python 3.10 con FastAPI. Database: SQLAlchemy con SQLite per development. Type hints ovunque. Preferisco pydantic per la validazione.
Java:
Progetto Spring Boot 3.0 con JPA e Hibernate. Database: PostgreSQL. Architettura: Controller → Service → Repository. Uso lombok per ridurre boilerplate.
Elemento 2: L'Obiettivo—Verbi Chiari Fanno la Differenza
Obiettivi Vaghi vs Obiettivi Chiari
Vago:
Sistemami questo codice
Chiaro:
Esegui il refactor di questo metodo per migliorarne la leggibilità usando il pattern Builder
La differenza? I verbi specifici.
Verbi che Copilot Capisce Bene
| Verbo | Cosa Fa | Esempio |
|---|---|---|
| Refactor | Riscrive il codice mantenendo la funzionalità | "Refactor per ridurre complessità ciclomatica" |
| Ottimizza | Rende il codice più veloce/efficiente | "Ottimizza questa query SQL" |
| Semplifica | Rende il codice più leggibile | "Semplifica questa logica if-else" |
| Valida | Controlla la correttezza | "Valida i dati di input" |
| Confronta | Mostra le differenze | "Confronta le due implementazioni" |
| Genera | Crea nuovo codice | "Genera test unitari" |
| Documenta | Aggiunge commenti/docstring | "Documenta questa API" |
| Migra | Cambia da una tecnologia a un'altra | "Migra da Mongoose a Prisma" |
| Integra | Connette due sistemi | "Integra Stripe payments" |
| Correggi | Risolve un bug | "Correggi il memory leak" |
Esempio: Dal Vago allo specifico
Vago:
Fai qualcosa con questo codice
Specifico:
Esegui il refactor di questo metodo per: 1. Ridurre la complessità ciclomatica (attualmente 8, target 5) 2. Estrarre la validazione in una funzione separata 3. Usare list comprehension invece di loop 4. Aggiungere type hints
Secondo prompt è 10 volte migliore.
Elemento 3: I Vincoli—Qui Fai Davvero la Differenza
Cosa Sono i Vincoli?
I vincoli sono limitazioni, regole, o preferenze che voglia che Copilot rispetti mentre genera il codice.
Sono l'elemento più importante di un prompt efficace perché riducono drasticamente l'ambiguità.
Tipi di Vincoli
Vincoli Tecnici:
- Non modificare la firma della funzione - Non aggiungere dipendenze esterne - Mantieni la retrocompatibilità con Python 3.8 - Usa solo librerie standard
Vincoli di Stile:
- Usa arrow functions per i componenti React - Preferisci const su let - Usa camelCase per le variabili - Aggiungi JSDoc comments
Vincoli di Performance:
- La soluzione deve essere O(n log n) o meglio - Thread-safe per ambienti concorrenti - Non usare ricorsione (memoria limitata)
Vincoli di Sicurezza:
- Sanitizzare input da utenti - Non usare eval() o string interpolation per SQL - Hash delle password con bcrypt, min 10 rounds - Rate limiting sul login
Esempio: Prompt con Vincoli
Senza vincoli:
Scrivi una funzione per processare file CSV
Con vincoli:
Scrivi una funzione TypeScript che processa file CSV: Vincoli: - Max file size: 10MB (throwa error se superato) - Validazione: le colonne richieste sono "email", "name", "age" - La funzione è generica, non hardcodare i nomi delle colonne - Output: array di oggetti TypeScript tipizzati - Error handling: cattura errori di parsing, non throw - Performance: streaming per file grandi (non caricare tutto in memoria)
Il secondo prompt genererà codice production-ready. Il primo? Un "hello world".
Elemento 4: L'Output Atteso—Dì Esattamente Cosa Vuoi
Il Problema
Copilot non sa se vuoi:
- Solo il codice
- Il codice + spiegazione
- Il codice + test
- Il codice + commenti dettagliati
- Una discussione sul design
Se non lo specifichi, Copilot farà una scelta arbitraria.
Specifica Sempre l'Output
| Output Desiderato | Come Chiederlo |
|---|---|
| Solo codice, niente prosa | "Dammi solo il codice, senza spiegazioni" |
| Codice + breve spiegazione | "Genera il codice, poi spiega in 2-3 righe cosa fa" |
| Codice + test | "Genera la funzione E gli unit test con Jest" |
| Codice + commenti | "Scrivi il codice con commenti inline che spiegano ogni step" |
| Codice + documentazione | "Genera il codice con JSDoc comments e un README" |
| Discussione + Codice | "Prima dammi il tuo approccio, poi il codice" |
Esempio: Output Specifico
Bene:
Genera una funzione che calcola lo sconto: - Se ordine > 100€, sconto 10% - Se ordine > 200€, sconto 15% - Se cliente è VIP, aggiungi extra 5% Output: dammi il codice TypeScript con type hints, più 2-3 esempi di uso della funzione
Copilot saprà esattamente cosa fare.
Tipo 1: Ask—Prompt Brevi e Mirati per Chat
Cosa Sono?
Ask è quando apri il chat di Copilot (Ctrl+Alt+I) e fai una domanda.
È la forma più semplice di interazione. Di solito è breve e mira a una risposta veloce.
Template Ask
"Spiegami [concetto] in termini semplici" "Come posso [risolvere problema]?" "Quali sono i pro e contro di [opzione A] vs [opzione B]?" "Come si usa [libreria] per [task]?"
Esempi Ask Reali
Buono:
Spiegami la differenza tra async/await e Promises in JavaScript
Migliore:
Spiegami la differenza tra async/await e Promises in JavaScript. Includi un esempio concreto di quando useresti uno vs l'altro, e quali sono i vantaggi di async/await in termini di error handling.
Tipo 2: Edit—Prompt per Inline Chat
Cosa Sono?
Edit è quando selezioni codice in VSCode, premi Cmd+I (Mac) o Ctrl+I (Windows/Linux), e chiedi a Copilot di modificarlo.
È la forma più comune e quella che usiamo più spesso.
Template Edit
"Refactor [descrizione di cosa vuoi cambiare]" "Aggiungi [feature] mantenendo [cosa deve rimanere uguale]" "Converti [da cosa] a [a cosa]" "Semplifica [cosa]"
Esempi Edit Reali
Scenario: Hai una funzione complessa e vuoi refactorizzarla
Selezioni il codice:
function processUserData(userData) {
if (userData && userData.email && userData.email.includes('@')) {
if (userData.age > 18) {
if (userData.country === 'IT') {
return { valid: true, user: userData };
} else {
return { valid: false, error: 'Invalid country' };
}
} else {
return { valid: false, error: 'Too young' };
}
} else {
return { valid: false, error: 'Invalid email' };
}
}
Apri Inline Chat e scrivi:
Vago:
Refactor questo
Specifico:
Refactor questo per ridurre l'annidamento dei if. Usa guard clauses o early returns. Aggiungi type hints TypeScript. Mantieni la stessa logica.
Copilot genererà:
function processUserData(userData: UserData): ValidationResult {
if (!userData?.email?.includes('@')) {
return { valid: false, error: 'Invalid email' };
}
if (userData.age < 18) {
return { valid: false, error: 'Too young' };
}
if (userData.country !== 'IT') {
return { valid: false, error: 'Invalid country' };
}
return { valid: true, user: userData };
}
Molto più leggibile.
Tipo 3: Agent—Prompt Strutturati per Task Complessi
Cosa Sono?
Agent è la modalità "autonoma" di Copilot. Quando abiliti Agent mode in Chat, Copilot non ti genera solo codice—esegue step autonomamente, come se fosse un developer che lavora per te.
Può:
- Leggere file
- Eseguire comandi nel terminale
- Creare/modificare file
- Eseguire test
Template Agent
"Analizza [cosa] e [azione]" "Implementa [feature] considerando [vincoli]" "Migra [da cosa] a [a cosa]" "Risolvi [problema] in [il tuo progetto]"
Esempi Agent Reali
Scenario: Vuoi migrare da Express a FastAPI
Apri Chat, seleziona Agent mode, e scrivi:
Analizza il mio progetto Node.js/Express e genera l'equivalente in Python/FastAPI. Considera: - Le route attuali (controlla express-routes.js) - Il database (attualmente Mongoose con MongoDB) - I middleware di autenticazione - La struttura di cartelle Output: crea i file Python corrispondenti nella cartella ./backend_python Esegui pip install per le dipendenze necessarie Fai un test delle nuove route
Agent farà:
- Leggere il tuo progetto Express
- Analizzare la struttura
- Generare l'equivalente FastAPI
- Creare i file
- Installare le dipendenze
- Testare
Tutto autonomamente.
Tipo 4: Plan—Prompt Strategici per Architettura
Cosa Sono?
Plan è quando usi Chat per discutere di decisioni architetturali e design prima di iniziare a codificare.
Non generi subito codice—fai planning.
Template Plan
"Quali sono le opzioni per [problema]?" "Proponi un'architettura per [sistema]" "Come dovrei strutturare [progetto]?" "Quali sono i pro/contro di [decisione]?"
Esempio Plan Reale
Apri Chat e chiedi:
Sto costruendo un SaaS multi-tenant in Node.js/PostgreSQL. Circa 1M utenti, crescita prevista 10% al mese. Come dovrei strutturare il progetto? Opzioni: 1. Un database per tenant 2. Un database con row-level security e column masking 3. Un database principale + shard per i dati dei tenant Quali sono i pro e contro di ognuno? Quale mi consigli per il nostro caso?
Copilot farà un'analisi approfondita, con:
- Pro/contro di ogni opzione
- Raccomandazione basata sul tuo caso
- Architettura suggerita
- Possibili problemi futuri
Questo evita decisioni costose sbagliate.
Prompt Iterativi: La Vera Magia
Non Serve un Prompt Perfetto al Primo Colpo
Uno dei maggiori fraintendimenti su Copilot è che devi scrivere il prompt perfetto la prima volta.
Non è vero. Copilot funziona meglio iterativamente.
Esempio Iterativo
Step 1: Request iniziale
Scrivi una funzione che calcola il prezzo totale di un ordine
Copilot genera qualcosa di base.
Step 2: Migliora il risultato
Ora aggiungi la logica degli sconti: - 10% su ordini > 100€ - 15% su ordini > 500€
Copilot aggiorna il codice.
Step 3: Aggiungi edge case
Aggiungi anche gestione delle spese di spedizione: - Gratis se ordine > 50€ - Altrimenti €3.99
Copilot integra la nuova logica.
Step 4: Richiedi test
Genera test unitari per tutti gli scenari
Copilot crea i test.
Step 5: Richiedi documentazione
Aggiungi JSDoc comments e un README con esempi di uso
Copilot completa tutto.
Questo approccio iterativo è come lavorare con un collega: cominci con un'idea, poi migliori passo per passo.
Errori Comuni da Evitare
Errore 1: Prompt Troppo Brevi
"Scrivi una API"
Copilot non sa:
- Che linguaggio
- Quali endpoint
- Quale database
- Quale autenticazione
Soluzione: Aggiungi contesto.
✅
"Scrivi un'API REST in Node.js/Express che:
- Ha endpoint GET /products (lista tutti) e POST /products (crea nuovo)
- Usa MongoDB con Mongoose
- Ha autenticazione JWT
- Torna errori in formato {error: string, code: number}"
Errore 2: Nessun Vincolo
"Crea una funzione di ordinamento"
Copilot potrebbe usare un algoritmo inefficiente, oppure non stabile, oppure con side effects.
Soluzione: Specifica i vincoli.
✅ "Crea una funzione di ordinamento in TypeScript che: - È O(n log n) o meglio - Ordina array di oggetti per proprietà 'priority' - È stabile (mantiene l'ordine relativo degli elementi uguali) - Non modifica l'array originale (immutable)"
Errore 3: Richieste Ambigue
"Migliora questo codice"
Che cosa significa "migliora"? Leggibilità? Performance? Sicurezza?
Soluzione: Sii specifico.
✅ "Migliora questo codice per ridurre la complessità ciclomatica da 12 a 6. Usa pattern come early returns o switch statements."
Errore 4: Chiedere Troppo in Una Volta
"Crea un sistema di e-commerce completo con checkout, pagamenti, email notifiche e analytics"
Troppo. Copilot potrebbe diventare confuso o generare codice mediocre.
Soluzione: Dividi in step.
✅ Step 1: "Crea il modello di Product e l'API CRUD" ✅ Step 2: "Aggiungi il carrello con persistenza" ✅ Step 3: "Integra Stripe per i pagamenti" ✅ Step 4: "Aggiungi email di conferma ordine"
Errore 5: Pensare che Copilot "Capisca da Solo"
"Fissa i bug nel progetto"
Copilot non è un mind-reader. Non sa che bug hai, dove sono, o come comportamenti sbagliati.
Soluzione: Spiega il problema.
✅ "Il login non funziona. L'errore è: 'Invalid token after refresh'. Il token refresh scade dopo 7 giorni, ma il backend usa un secret differente tra access e refresh token. Puoi identificare il problema e fixarlo?"
Template Master per Prompt Efficaci
Qui sotto una serie di template pronti all'uso che puoi adattare:
Template 1: Code Generation
Contesto: [linguaggio, framework, architettura] Voglio: Una funzione/classe che [cosa fa] Requisiti: - [Requisito 1] - [Requisito 2] - [Requisito 3] Vincoli: - [Vincolo tecnico] - [Vincolo di stile] Output: [cosa esattamente vuoi—codice, test, docs, ecc.]
Template 2: Refactoring
Seleziona il codice Richiesta: Refactor questo codice per [motivo—leggibilità, performance, sicurezza] Specificamente: - [Cosa dovrebbe cambiare 1] - [Cosa dovrebbe cambiare 2] Mantieni: [Cosa deve rimanere uguale] Output: Il codice refactorizzato con commenti che spiegano le modifiche
Template 3: Bug Fixing
Contesto: [dov'è il bug, che comportamento sbagliato] Il bug: [descrizione del comportamento errato] Stack trace o error: [errore che vedi] Vincoli: - Non modificare la firma della funzione - [Altro vincolo] Proponi: Una soluzione e il codice corretto
Template 4: Architecture Discussion
Contesto: [Tipo di sistema, scala prevista, vincoli] Domanda: [Che decisione devo prendere?] Opzioni che sto considerando: [Opzione A, Opzione B, ...] Analizza: - Pro e contro di ogni opzione - Quale mi consigli? - Quali problemi futuri potrei avere? Output: Una risposta strutturata con raccomandazione
Best Practices per Prompt Eccezionali
1. Usa Blank Lines per Struttura
Invece di:
Contesto: Node.js, Express Voglio una API Requisiti: GET /users, autenticazione JWT Vincoli: Usa TypeScript
Usa:
Contesto: Node.js, Express Voglio: Una API REST per la gestione utenti Requisiti: - GET /users (lista) - POST /users (crea) - Autenticazione JWT Vincoli: - TypeScript - Type hints ovunque
È molto più leggibile e Copilot lo capisce meglio.
2. Usa Bullet Points per Listicità
Aggiungi error handling: • Errori di validazione → 400 • Utente non trovato → 404 • Token scaduto → 401 • Errore interno → 500
3. Sii Sempre Specifico sui Numeri
Invece di "grande ordine", scrivi "ordine > €500". Invece di "molti elementi", scrivi "array con >10K elementi".
4. Menziona Decisioni che Hai Già Preso
Nota: Ho già deciso di usare Zustand per lo state management. Non suggerire Redux o Context API.
Questo impedisce a Copilot di proporre alternative non richieste.
5. Se è Tecnico, Dagli il Contesto Tecnico
Se stai lavorando con concetti avanzati (race conditions, eventual consistency, CAP theorem), dicielo esplicitamente.
Voglio: Una soluzione thread-safe per un cache distribuito che sia eventual consistent su 3 nodi.
Conclusione: Prompt è una Competenza
Scrivere buoni prompt non è una "cosa che fa Copilot"—è una competenza tecnica che acquisisci.
Come tutte le competenze:
- All'inizio è scomodo. Dovrai pensare a come strutturare il prompt.
- Dopo qualche settimana diventa naturale. Saprai istintivamente cosa includere.
- Dopo un mese scoprirai che i tuoi prompt sono sempre migliori.
Il Mindset Giusto
Pensa a Copilot non come "AI che programma" ma come "AI che esegue istruzioni molto dettagliate".
Se le istruzioni sono vague → esecuzione vague. Se le istruzioni sono chiare → esecuzione precisa.
Tu controlli la qualità del prompt. Tu controlli la qualità dell'output.
Takeaway Box
| Concetto | Memorizza |
|---|---|
| Contesto | Dì a Copilot dove siamo (linguaggio, framework, architettura) |
| Obiettivo | Usa verbi chiari (refactor, ottimizza, valida, genera) |
| Vincoli | Specifica limitazioni e regole che Copilot deve rispettare |
| Output | Dì esattamente cosa vuoi (codice, test, docs, ecc.) |
| Iterazione | I prompt non devono essere perfetti al primo colpo |
| Specifico > Generico | "Refactor per O(n log n)" > "Refactor" |
| Struttura | Usa blank lines e bullet points, è più leggibile |
Prossimi Passi
Prova domani:
- Apri VSCode
- Seleziona un pezzo di codice che non ti piace
- Scrivi un prompt seguendo i template di questo articolo
- Misura la qualità del risultato
- Itera se necessario
Vedrai la differenza istantaneamente.