Capstone — retrospettiva: cosa ha funzionato, dove l’AI ha sbagliato, cosa rifare diversamente

Il capstone è finito (o almeno: in stato dimostrabile). Ultima fase: trasformare il viaggio in lezioni personali. Non per bocca del corso: per te. Quali pratiche tieni, quali butti, quali cambi. La retrospettiva è dove il corso diventa metodo, e il metodo diventa abitudine.

Perché questa lezione conta

Senza retrospettiva, ogni progetto futuro ricomincia da zero le stesse incertezze. Con retrospettiva esplicita, hai scritto cosa ha funzionato per te, cosa è stato spreco, cosa ti serve studiare ancora. Il corso ti dà un menu di pratiche; la retrospettiva sceglie cosa di quel menu va al tuo workflow personale.

Obiettivo operativo

Alla fine devi avere:

1. valutazione del processo: prompt, cicli, decisioni;
2. valutazione del prodotto: cosa funziona, cosa è fragile, cosa manca;
3. piano di crescita: cosa studiare, cosa rifare, cosa mantenere;
4. documento finale che racconta progetto + metodo + limiti.

Nucleo della lezione

1. Valutazione del processo

Domande da rispondere onestamente:

Prompt:

• quali prompt hanno prodotto risultati al primo colpo?
• quali hanno richiesto 3+ iterazioni?
• pattern che funzionano per te (struttura, livello di dettaglio, lingua)?
• pattern che non funzionano (vaghi, contraddittori, sovraccarichi)?

Cicli:

• quanto è durata la sessione media? Era sostenibile?
• quanti commit hai prodotto in totale? Erano leggibili?
• quante volte hai fatto reset/rollback?
• quanto tempo hai speso in bug debugging vs feature building?

Decisioni:

• quante decisioni significative hai documentato?
• ce ne sono che oggi rivedresti? Con cosa?
• decisioni delegate al modello senza tua riflessione esplicita?
• alternative che ora vedi che non avevi considerato?

Strumenti:

• chat vs IDE AI vs agente CLI: quale ha funzionato meglio per quali task?
• modello scelto: corretto per i task? Avresti potuto risparmiare con modello più piccolo?
• file di regole: utile? aggiornato spesso? hai trascinato regole stale?

2. Valutazione del prodotto

Cosa funziona:

• demo riuscita: quali flussi reggono?
• esperienza utente: utente reale ha provato, feedback?
• performance: misurato Lighthouse, latency reali?

Cosa è fragile:

• aree dove un piccolo cambiamento richiede modifiche multiple?
• test coverage bassa?
• dipendenze instabili?
• edge case ignorati?

Cosa manca per utenti reali:

• feature out-of-MVP che torneranno utili?
• accessibilità completa (WCAG AA)?
• internazionalizzazione?
• sync multi-device?

Rischi residui:

• sicurezza: cosa non hai testato?
• privacy: cosa potrebbe diventare problema con più utenti?
• scala: quanti utenti reggerebbe oggi?

Onestà su questi punti = base per piano di crescita realistico.

3. Piano di crescita

Tre orizzonti:

Oggi/questa settimana (tempo limitato):

• 2-3 fix immediati al capstone;
• aggiornamento documentazione (lessons learned);
• archiviazione progetto se intenzionale.

Prossimo mese (medio termine):

• 1-2 feature out-of-MVP da aggiungere;
• studio di concetto specifico emerso (es. “test E2E con Playwright”, “CSP avanzato”);
• iterazione del file di regole personali (“template-AGENTS.md”) per riusarlo.

Prossimo corso/progetto (lungo termine):

• competenze da approfondire (es. “voglio capire database meglio” → corso DB);
• pattern da adottare in nuovi progetti (es. “sempre architettura su carta prima del codice”);
• pattern da abbandonare (es. “smettere di usare modello frontier per task semplici”).

Il piano deve essere concreto e datato. “Voglio migliorare” non è piano. “Voglio fare corso DB entro fine giugno + applicare a piccolo progetto entro luglio” sì.

4. Documento finale

Sintetizza tutto in docs/retrospettiva.md. Suggerimento di struttura:

# Retrospettiva Capstone — [data]

## Il progetto in 3 righe
[cosa è, per chi, stato attuale]

## Metodo usato
- Prompt: pattern che ha funzionato
- Cicli: lunghezza media, numero commit, reset
- Strumenti: cosa ho usato per cosa
- Decisioni: numero documentate, qualità

## Cosa ha funzionato
- [3-5 pratiche concrete]

## Cosa NON ha funzionato
- [3-5 pratiche da abbandonare/cambiare]

## Errori dell'AI
- [3-5 pattern di errore che ho osservato ricorrenti]
- come li ho mitigati (regole, prompt, verifica)

## Prodotto
- Punti forti: [...]
- Fragilità: [...]
- Mancanze rispetto a utenti reali: [...]
- Rischi residui: [...]

## Lezioni personali
- 5 lezioni che applicherò sempre
- 3 da approfondire

## Piano di crescita
- Oggi/settimana: [...]
- Mese: [...]
- Prossimo corso/progetto: [...]

## Per chi viene dopo
[se condividi, cosa dovrebbe sapere chi prova lo stesso percorso]

Retrospettiva guidata

Una retrospettiva utile non è “è andata bene” o “l’AI mi ha aiutato”. Deve produrre decisioni per il prossimo progetto.

Formato consigliato:

## 1. Cosa ha funzionato
- Prompt con piano prima del codice: ridotte modifiche fuori scope.
- Commit piccoli: facile tornare indietro.
- Checklist manuale: trovato bug su input con virgola.

## 2. Dove l'AI ha sbagliato
- Ha proposto libreria grafici prima di avere dati stabili.
- Ha nascosto errore storage con fallback `[]`.
- Ha creato microcopy in inglese.

## 3. Cosa rifarei uguale
- Architettura su carta prima del primo prompt.
- Repository isolato dallo storage reale.

## 4. Cosa cambierei
- Scriverei test sul dominio dal primo commit.
- Definirei prima formati data/importo.

## 5. Prossime competenze
- IndexedDB più solido.
- Test automatici UI.
- Accessibilità form.

La domanda finale è: quale regola personale aggiungi al tuo metodo? Esempio: “nessuna libreria UI finché non esiste flusso dati testato”. Questa è crescita trasferibile.

Procedura pratica

90 minuti:

1. Rilettura artefatti (15 min): brief, AGENTS.md, decisions.md, README.
2. Valutazione processo (20 min): risposte oneste alle domande.
3. Valutazione prodotto (20 min): cosa funziona, cosa no, mancanze, rischi.
4. Piano di crescita (20 min): 3 orizzonti, voci concrete e datate.
5. Documento finale (15 min): scrivi retrospettiva.md.

Laboratorio guidato

Per il tuo capstone reale, esegui retrospettiva. Esempio (compresso):

Il progetto: tracker abitudini local-first. Ho lo strumento ora; mi è utile.

Cosa ha funzionato: Brief tecnico fatto bene. Decision log mantenuto vivo. Commit piccoli (in media 60 righe). Test prima del deploy.

Cosa NON ha funzionato: Sessioni troppo lunghe (oltre 2h, attenzione cala). 3 volte ho fatto reset perché il modello aveva fatto refactor non chiesto.

Errori AI: 1) inventato libreria che non esiste (corretto verifica). 2) condizioni complesse hardcoded invece di estrarre. 3) manca CSP nei meta tag iniziali.

Prodotto: funziona, ma manca calendario completo + statistiche. Sicurezza: solo statico, basso rischio. Manca sync multi-device.

Piano:

• settimana: aggiungo statistiche base + Lighthouse passa 95+.
• mese: studio service worker per offline più solido.
• prossimo: progetto con backend per imparare auth e DB pattern. Probabilmente “gestione note collegate” capstone più complesso.

Onesto, breve, azionabile. Non cerimonia, strumento.

Output atteso

docs/retrospettiva.md salvato. Letto entro un mese per verificare quante lezioni hai effettivamente applicato. Ad un anno, riletto = misura del tuo apprendimento.

Studio passo passo

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

1. Prima lettura: chiarisci l’obiettivo: chiudere il corso trasformando l’esperienza in metodo personale trasferibile ad altri progetti. Se non riesci a riscriverlo in una frase tua, rileggi il nucleo della lezione.
2. Seconda lettura: trasforma i contenuti in domande operative:

• Valutazione del processo: prompt efficaci, loop inutili, scelte architetturali buone, errori evitabili.
• Valutazione del prodotto: cosa funziona, cosa è fragile, cosa manca per utenti reali, quali rischi restano.
• Piano di crescita: quali competenze studiare dopo, quale parte riscrivere, quali automatismi mantenere.

3. Applicazione: svolgi il laboratorio: scrivere una retrospettiva tecnica e una roadmap di miglioramento in tre orizzonti: oggi, prossimo mese, prossimo corso. L’output da ottenere è: un documento finale che racconta il progetto, il metodo usato, i limiti e le prossime decisioni.

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

• ho retrospettiva scritta;
• ho almeno 3 lezioni concrete per processo + 3 per prodotto;
• piano di crescita ha date concrete;
• ho identificato pattern di errore AI ricorrenti per me;
• so quale prossimo corso/progetto inizierò.

Errori comuni

Retrospettiva celebrativa. “È stato fantastico”. Non utile. Onestà sui problemi.

Solo positivo o solo negativo. Equilibrio. Cose vanno bene anche quando ne migliori altre.

Niente piano concreto. “Voglio fare meglio” non è piano. Voci con date.

Saltare per “non ho tempo”. Senza retrospettiva, ripeti gli stessi errori. Tempo speso = investimento.

Niente condivisione. Anche scrivere blog post / talk breve sul capstone ti forza a sintesi e ti aiuta. Opzionale ma molto formativo.

Lezioni “in testa” senza scriverle. Memoria fade. Scritto persiste.

Prompt di lavoro

Sto facendo retrospettiva del mio capstone.

Brief: [link]
Stato attuale: [riassunto]
Tempo totale speso: [...]
Numero sessioni AI: [...]

Aiutami con domande mirate per le 4 aree:

1. Processo: prompt, cicli, decisioni, strumenti.
2. Prodotto: punti forti, fragilità, mancanze, rischi.
3. Errori AI: pattern ricorrenti che ho osservato.
4. Piano di crescita: 3 orizzonti (settimana/mese/prossimo).

Per ogni area, fammi 5-7 domande mirate, una alla volta, NO multi-domanda.
Aspetta mia risposta prima di procedere.

Al termine, sintetizza in retrospettiva.md di 1 pagina.
NON essere generoso/celebrativo. Voglio onestà operativa.

Esercizio finale

A 1 mese di distanza, rileggi la retrospettiva. Quante lezioni hai effettivamente applicato? Quante decisioni di “piano di crescita” hai eseguito? Tipicamente 30-50% (umano). Quel gap è informazione: stai puntando troppo in alto, o non stai dando priorità. Aggiusta il prossimo piano di conseguenza.

A 6 mesi, riapri di nuovo. La distanza permette di vedere cosa è stato davvero formativo. Spesso non quello che pensavi.

Buon vibe coding.