THE TRACE è un piccolo progetto che avevo fatto nel 2016, quando lavoravo come consulente per un’azienda che sperimentava con il **browser fingerprinting**. Era una prova personale, un modo per capire se si potesse riconoscere un dispositivo senza cookie, e come si potesse sfruttare quella cosa.
Poi il tema è passato in azienda, è diventato serio, e il mio codice è rimasto dov’era: su un server FTP, insieme a tanti altri progetti iniziati e mai finiti. Ogni tanto li rivedo. Sono come dei fossili di idee: alcuni inutili, altri ancora belli, ma troppo complessi per rimetterci mano da soli.
Dieci anni dopo, ho riaperto THE TRACE. Non per nostalgia, ma perché ora è possibile rimettere mano a questi progetti con l’aiuto dell’IA. Cose che prima abbandonavi per complessità o pigrizia, oggi le puoi rifare in un pomeriggio. E il problema, paradossalmente, diventa l’opposto: *non farle diventare troppo grandi.*
Controllo e non controllo
Lavorare con l’IA nel coding è una di quelle esperienze che ti insegnano cosa vuol dire avere il controllo… e perderlo dopo cinque minuti. Funziona benissimo quando il piano è chiaro, i file ci sono, e le istruzioni sono scritte. Ma appena qualcosa cambia — e qualcosa cambia sempre — il castello comincia a muoversi.
Hai la sensazione di guidare, ma in realtà stai solo tenendo il volante mentre la macchina decide come sterzare. Metti paletti per darle una direzione, ma se sono troppo stretti si blocca; se sono troppo larghi, va dove non serve.
La frustrazione nasce lì. Hai il potere, ma non il controllo. E ti rendi conto che tutto dipende da *come* decidi di lavorarci insieme.
Prompt-way e Context-way
Col tempo ho capito che, nel coding con l’IA, esistono due grandi approcci. Io li chiamo così, per comodità:
Prompt-way
È quando spieghi tutto nel prompt. Dici esattamente cosa deve fare, passo per passo:
> “Crea il modulo di login, scrivilo così, fai riferimento qua….”
> “Scrivi il test per l’endpoint, considera che…, controlla che…”
> “Aggiungi la validazione, ci sono questi casi particolari, etc.”
Funziona, ma è faticoso. Ogni avanzamento richiede un prompt lungo, con dentro tutto il contesto, perché il modello non “ricorda” come un umano. E ogni modifica ti costringe a riscrivere metà delle istruzioni.
È il modo più sicuro (boh, forse non saprei), ma anche il più pesante. Se ti piace pianificare ogni dettaglio, è perfetto. Se sei come me — curioso, ma pigro e caotico — dopo due prompt del genere ti passa la voglia.
Context-way
L’altro modo è quello che uso di più. Preparo una serie di **file “guardrail”**, che definiscono il progetto ma non dicono *come* implementarlo. Tipo:
– `architecture.md` → le logiche generali, non il codice
– `plan.md` → gli sprint pianificati
– `agents.md` → le regole di comportamento
– `changelog.md` → cosa è stato fatto e quando
Questi file servono da **cornice mentale**. Poi basta un prompt minimale:
> “Procedi con lo sprint 1.”
E l’IA lavora da sola, rispettando i limiti del contesto che ha letto. È più libera, più autonoma, più naturale. Quando funziona, è bellissimo: tu osservi, lei costruisce. Ma non dura per sempre.
Quando il contesto si rompe
All’inizio fila tutto liscio. Poi capita una di queste situazioni:
> “Ah già, servirebbe anche una login.”
> “Aggiungiamo una dashboard utente.”
> “Cambiamo un pezzo di logica nel database.”
Piccole cose. All’apparenza innocue. Solo che — se gliele chiedi *fuori contesto* — stacchi un filo importante.
L’IA fa il lavoro, ma non aggiorna i file di progetto. Non modifica `plan.md`, non riscrive `architecture.md`, e la prossima volta che le chiedi “procedi con lo sprint 5”, lei riparte da una versione mentale vecchia del progetto. È come se, nel frattempo, vi foste dimenticati di parlarvi.
A quel punto hai due strade:
– rifare l’allineamento (aggiornare tutti i file e ripartire),
– oppure lasciare correre e sperare che regga.
Io ho provato entrambe. La prima è noiosa, ma sicura. La seconda è un disastro quasi certo.
Il caos non è sparito, si è solo spostato
Prima, il caos era nel codice. Oggi è nel metodo. Non passo più ore a sistemare funzioni, ma a capire *perché* certe cose non tornano tra un prompt e l’altro.
Se lavori “a prompt”, rischi di perdere il quadro generale. Se lavori “a contesto”, rischi che il quadro si deformi da solo.
Il trucco, almeno per ora, sta nel **colpire con equilibrio**: scrivere giusto quei due prompt o aggiornare quei due file che rimettono la rotta, senza bloccare il flusso. Non lo so fare bene, ma ci sto provando.
L’ibrido (e la verità)
Io non sono un esempio virtuoso. Non ho un metodo elegante o scientifico. Delego all’IA la scrittura dei file, dei prompt e del codice. Io penso, guardo, e cerco di non far saltare tutto.
Mi piace lavorare così perché **mi colma dove io sono carente** — nella struttura, nella coerenza, nella costanza. Mi lascia spazio per essere curioso, disordinato, ma comunque produttivo. E anche se sembra che abbia semplificato la vita, in realtà ho solo spostato il caos da un posto all’altro.
Il caos adesso è più interessante, però. Perché riguarda la comunicazione, non il codice.
Postfazione: Non è una lezione
Di tutte le cose che scrivo qui, ne faccio forse la metà. I miei prompt sono semplici, i piani li aggiorno quando mi ricordo, e a volte devo rifare da capo perché il contesto è andato. Però funziona abbastanza per far nascere progetti veri. THE TRACE, ad esempio, l’ho rifatto in meno di un giorno. E dieci anni fa mi sarebbero servite settimane.
Non scrivo queste righe per insegnare niente. Le scrivo perché, se anche tu lavori così — con un misto di fiducia, disordine e testardaggine — sappi che è normale. Non c’è un modo giusto, solo modi che ogni tanto funzionano.
E se leggendo pensi:
> “Ah, anche questo tizio fa pasticci ma gli vengono fuori cose decenti,”
allora va già bene così.
