Pair con l’agente: chi guida, chi verifica

Il pair programming con AI ha schema fisso: umano definisce, AI propone, umano decide. Invertirli (AI definisce, umano accetta) porta velocemente a delega cieca. Mantenere ruoli chiari non è formalità: è ciò che separa “uso AI come moltiplicatore” da “AI mi guida”.

Perché questa lezione conta

Senza ruoli espliciti, il rapporto scivola. Inizi con “AI mi aiuta” e finisci con “AI decide tutto”. Il momento esatto del passaggio è invisibile: non lo noti finché non vedi codice che non capisci più. Stabilire ritmo e ruoli al primo task previene il drift.

Obiettivo operativo

Alla fine devi saper:

1. distinguere ruoli (umano: definizione + decisione; AI: proposta + esecuzione);
2. condurre una sessione pair con ritmo strutturato;
3. fare domande che mantengono il controllo del lavoro.

Nucleo della lezione

1. Ruoli espliciti

Tre ruoli, due attori:

Umano: definisce obiettivo, criteri di accettazione, vincoli. Decide alla fine. Risponde di errori e successi.

AI: propone piano, esegue (genera codice, esegue comandi, scrive test), spiega scelte fatte.

Umano: legge proposta, prova, decide se accetta, modifica, rifiuta. Itera.

Note importanti:

• L’umano NON delega la decisione. Anche quando dice “OK accetta”, è una decisione presa.
• L’AI NON delega l’esecuzione. Anche quando l’umano dice “fai”, l’AI deve mostrare cosa farà.
• I ruoli non si invertono. Anche se l’AI propone alternative, è l’umano che sceglie.

2. Domande utili durante il pair

Cinque domande da farsi (e fare all’AI) regolarmente:

“Cosa hai cambiato?”: dopo ogni step, riassunto preciso delle modifiche. Non “ho aggiornato”, ma “ho aggiunto funzione X in file Y, modificato condizione Z, rimosso import W”.

“Perché?”: motivazione di ogni scelta tecnica. Se l’AI non sa rispondere bene, dubbio sul codice.

“Cosa NON hai verificato?”: il modello tende a presentare risultati come “fatto e testato”. Spesso non ha eseguito test. Forzalo a esplicitare cosa è stato verificato vs cosa è ipotizzato.

“Quali rischi restano?”: edge case non gestiti, sicurezza, performance, casi limite. Ogni implementazione ha rischi residui; chiedere li rende espliciti.

“Cosa faresti diversamente sapendo X?”: dopo aver dato info nuova (un dato del progetto, un vincolo emerso), chiedi se cambia la proposta. Spesso sì, e l’AI non lo dice da sola.

3. Ritmo pair

Sequenza ripetibile per ogni mini-task:

1. Piano breve (umano definisce, AI propone): “Il piano è questo, va bene?”. Umano OK o modifica.

2. Modifica (AI esegue): genera diff. Mostra solo il file/righe toccati.

3. Test (AI esegue, umano verifica): comando di verifica, output, screenshot se UI. Risposta del modello “il test è passato” non basta: vedi output.

4. Spiegazione del diff (AI risponde, umano valuta): cosa, perché, rischi residui.

5. Decisione (umano): accetta, modifica, rifiuta. Se accetta, commit. Se modifica, prompt mirato. Se rifiuta, reset e riformula.

6. Prossimo passo (umano sceglie): in base allo stato, qual è il successivo mini-task. Non lasciare che l’AI decida priorità.

Tempo per ciclo: 5-15 minuti. Cicli per task: 3-8. Pair di 1 ora = 5-15 cicli.

Procedura pratica

Setup di una sessione pair:

1. Scegli task dimensionato (un comportamento, max 100 righe diff).
2. Branch dedicato.
3. Prompt iniziale con ruoli espliciti: “Tu sei AI che propone ed esegue. Io decido. Procedi sempre con piano → modifica → test → spiega → aspetta OK”.
4. Esegui ciclo per ogni mini-task.
5. Pause periodiche: ogni 30-45 min, alza la testa. Stai dirigendo o ti stai facendo dirigere?
6. Fine sessione: rileggi diff completo del branch (git diff main). Tutto ciò che vedi è ciò che hai accettato.

Laboratorio guidato

Sessione pair su task piccolo: aggiungi un endpoint API.

Task: POST /api/feedback salva un messaggio nel DB, valida lunghezza max 500 caratteri.

Setup:

• branch feat/feedback-endpoint;
• prompt iniziale: ruoli espliciti, ritmo, scope.

Cicli:

Ciclo 1: piano. AI propone: 1) aggiungi route, 2) schema validazione, 3) handler con DB call, 4) test. OK con modifica: aggiungi rate limiting basico (max 5/min per IP).

Ciclo 2: route + schema. AI mostra diff piccolo (10 righe). Test typecheck passa. OK.

Ciclo 3: handler + DB. AI mostra diff (30 righe). Esegue test, mostra output. OK.

Ciclo 4: rate limiting. AI propone import di express-rate-limit. Domanda: “perché questa lib? alternative? è in package.json?”. AI conferma che non c’è, propone alternativa: implementazione minimale in-memory (bastante per single-server). OK con scelta.

Ciclo 5: test. AI scrive 4 test (caso ok, payload troppo lungo, missing field, rate limit). Tutti passano.

Fine: rileggi git diff main. ~80 righe, 3 file. Commit.

Pratica: replica il pattern su task tuo, contando cicli e tempo. Tipico: 5-8 cicli, 30-60 min.

Output atteso

Un protocollo personale di pair con AI, scritto:

• ritmo: piano → modifica → test → spiega → decidi;
• 5 domande chiave da fare regolarmente;
• segnali di drift (sto delegando troppo?);
• soglia di pausa (ogni 30-45 min);
• check finale: rileggi diff complessivo prima di concludere.

Studio passo passo

Studia questa lezione in tre passaggi, senza correre subito al prompt o al codice.

1. Prima lettura: chiarisci l’obiettivo: stabilire un rapporto di lavoro in cui l’umano mantiene direzione, giudizio e responsabilità finale. Se non riesci a riscriverlo in una frase tua, rileggi il nucleo della lezione.
2. Seconda lettura: trasforma i contenuti in domande operative:

• Ruoli: umano definisce obiettivo e criteri; AI propone, esegue, spiega; umano legge, prova, decide.
• Domande utili durante il pair: cosa hai cambiato, perché, cosa non hai verificato, quali rischi restano.
• Ritmo: piano breve, modifica, test, spiegazione del diff, decisione sul prossimo passo.

3. Applicazione: svolgi il laboratorio: condurre una sessione pair completa con l’AI su un task piccolo, annotando ogni decisione umana. L’output da ottenere è: un protocollo di collaborazione con l’agente per evitare delega cieca.

Prima di passare alla lezione successiva, controlla di avere un artefatto concreto: una tabella, un prompt, una checklist, un mini report, un diff commentato o una decisione scritta. Nel vibe coding la comprensione resta astratta finché non produce una traccia verificabile.

Checklist di verifica

• distinguo ruoli umano/AI durante una sessione;
• pongo le 5 domande regolarmente, non solo a fine task;
• non accetto modifiche senza vedere diff e output di test;
• alzo la testa periodicamente per verificare di stare dirigendo;
• a fine sessione rileggo diff complessivo del branch.

Errori comuni

Lasciare l’AI decidere priorità. “Cosa fai dopo?” è domanda umana, non AI. L’umano dirige.

Accettare modifiche senza vedere diff. Te lo dirà il modello? “Ho aggiornato X”. Vai al diff.

Niente test fra step. AI accumula 5 modifiche, alla fine “tutto rotto”, non sai dove. Test fra step.

Domande generiche. “Va tutto bene?” raccoglie “sì” anche quando no. Domande specifiche: “cosa non hai verificato? quali rischi?”.

Sessione troppo lunga. Dopo 2 ore di pair, attenzione cala. L’AI ne approfitta. Pausa.

Rileggere diff solo a commit, non per file. Diff complessivo a fine = troppe cose da seguire. Diff per file dopo modifica.

Prompt di lavoro

Prompt iniziale di sessione pair:

Iniziamo una sessione pair programming.

Ruoli:
- Io: definisco obiettivo, vincoli, criteri di accettazione. Decido. Responsabile finale.
- Tu: proponi piano, esegui modifiche e test, spieghi.

Ritmo per ogni mini-task:
1. Piano breve (max 5 punti). Aspetta mio OK.
2. Modifica (mostra diff dei file toccati).
3. Esegui test/verifica e mostra output reale.
4. Spiega cosa hai cambiato, perché, e cosa NON hai verificato.
5. Aspetta mia decisione (accetta / modifica / rifiuta).
6. Solo dopo procedi al prossimo mini-task.

Vincoli sessione:
- file ammessi: [...]
- max righe modificate per ciclo: 100
- niente refactor laterali
- niente nuove dipendenze senza chiedere

Task corrente: [descrizione]

Inizia con il piano. Aspetto il tuo primo messaggio.

Esercizio finale

Per la prossima sessione AI di 1 ora: registra (anche solo mentalmente) ogni decisione. Quante hai preso tu, quante l’AI? Tipicamente per chi non pratica ruoli espliciti il rapporto è 70/30 a favore dell’AI. Obiettivo: 80/20 a favore tuo. Le decisioni delegate inconsapevolmente sono lì che il drift accumula.