Il metodo

Un modo di lavorare con l’AI, ancora in evoluzione

L’AI ha reso facilissimo fare molto. Il rischio è che renda sempre più difficile capire che cosa sto facendo.

Questa pagina raccoglie gli accorgimenti con cui provo a tenere insieme le due cose: la velocità dell’AI e la mia comprensione del lavoro. Vengono da progetti reali. Alcuni hanno retto alla prova, altri sono ancora scommesse. Quando lo so, lo dico.

Quello che cerco sono le condizioni che rendono il lavoro più leggibile, verificabile e governabile.

Quando il prompt non basta più

Per un compito piccolo e isolato basta una buona richiesta. Poi il lavoro si allunga: più file, più decisioni, più tentativi, magari più agenti. A quel punto ottenere una risposta utile non è più il problema.

Il problema è ricordare perché ho preso una decisione, capire che cosa sta per essere modificato, verificare che il risultato corrisponda a ciò che volevo davvero e impedire che la velocità mi porti fuori strada senza che me ne accorga.

Il metodo non serve a rallentare l’AI. Serve a non perdere intenzione, perimetro e senso mentre l’AI accelera.

La sequenza che sto usando

Nel LAB il lavoro segue oggi questa sequenza:

01 · INTENZIONEDire con chiarezza che cosa voglio.
02 · ASSESSMENTChiedere all’agente che cosa ha capito.
03 · PIANOTagliare il lavoro in task piccoli e delimitati.
04 · ESECUZIONEL’agente lavora sul perimetro concordato.
05 · VERIFICAConfrontare il risultato con ciò che avevo chiesto.
06 · MEMORIAConservare il minimo necessario per ripartire.

Sopra tutto, un principio: Human in Command. È la sequenza che oggi mi permette di vedere dove qualcosa comincia a divergere. Domani potrebbe essere diversa.

Rendere più chiaro quello che ho in mente

La cosa che sottovaluto più spesso è quanto della mia richiesta resti nella mia testa.

Io so perfettamente che cosa voglio ottenere, conosco il progetto, ricordo le decisioni già prese e do per scontati alcuni vincoli. L’AI non vede niente di tutto questo: vede solo quello che le passo in quel momento.

Molte risposte che sembrano “sbagliate” nascono qui. Il modello non è incapace: gli ho lasciato troppo spazio per interpretare ciò che non avevo detto.

CORDA nasce da questa osservazione. È un promemoria, non una formula per il prompt perfetto: cinque domande per capire se ho spiegato abbastanza bene.

C
Contesto
Che cosa deve sapere l’AI per capire il problema? Non tutto ciò che so del progetto serve: va scelto il contesto che cambia davvero il significato della richiesta.
O
Obiettivo
Che cosa voglio ottenere? Più l’obiettivo resta generico, più spazio lascio all’AI per interpretarlo.
R
Ruolo
Da quale punto di vista chiedo all’AI di ragionare? Un ruolo non migliora la risposta per magia: serve a chiarire che tipo di valutazione mi aspetto.
D
Dati e delimitazioni
Quali informazioni deve usare? Quali vincoli deve rispettare? Che cosa deve restare fuori? È spesso qui che si decide il vero perimetro della richiesta.
A
Aspetto dell’output
Come deve presentarsi il risultato? Codice, analisi, tabella, proposta o piano operativo: dire che forma deve avere evita interpretazioni inutili.

Un esempio

Una richiesta apparentemente semplice
“Aggiungi un filtro per data alla tabella dei report.”
Contesto
Web app in PHP e MySQL, la tabella dei report è già paginata.
Obiettivo
Filtro per intervallo di date.
Ruolo
Sviluppatore che segue lo stile del codice esistente.
Dati e delimitazioni
Si possono toccare solo report.php e report.js; nessuna nuova dipendenza; la paginazione non cambia.
Aspetto dell’output
Le modifiche come diff, con una riga di spiegazione per ciascuna.

Non servono sempre tutti e cinque gli elementi con lo stesso dettaglio, e un prompt non deve per forza essere lungo. Serve ridurre la distanza tra ciò che penso di aver chiesto e ciò che l’AI può davvero capire.

Da qui è nato anche Prompt Builder: rendere visibili queste domande prima di inviare il prompt.

Prova Prompt Builder

Resta aperto un dubbio: quanto conviene strutturare una richiesta prima che la struttura stessa cominci a rallentare il lavoro?

Non significa fare tutto a mano

Quando ho iniziato a usare l’AI per sviluppare, temevo soprattutto il codice sbagliato. Con il tempo ho capito che il problema più interessante era un altro.

L’AI fa moltissime cose bene, e proprio per questo diventa facile lasciarle prendere anche decisioni che non avevo deciso di delegare. Può proporre una soluzione, individuare i file da modificare, scrivere il codice, preparare i test, correggere un errore, documentare quello che ha fatto. Tutto utilissimo.

Ma c’è una differenza tra eseguire una decisione e decidere che quella sia la decisione giusta.

Human in Command, per me, è questo. L’umano continua a stabilire dove si vuole arrivare, quali parti del progetto si possono toccare, quali compromessi sono accettabili e quando un risultato è davvero valido.

Non vuol dire controllare ogni riga prodotta dall’AI: se fosse necessario, si perderebbe gran parte del vantaggio. Vuol dire avere abbastanza visibilità da intervenire nei punti che contano.

Un esempio. Un coding agent scopre che, per chiudere un task, deve modificare due file che avevo lasciato fuori dal perimetro. Può essere giusto farlo. Ma voglio essere io a decidere che quella modifica è autorizzata. Lo stesso vale se introduce una nuova dipendenza o propone di cambiare una scelta architetturale: quella decisione deve tornare visibile prima di diventare semplicemente parte del codice.

Human in Command è il controllo sulle decisioni che cambiano davvero il progetto, più che la presenza umana su ogni passaggio.

Prima capire, poi modificare

Uno degli accorgimenti che hanno cambiato di più il mio lavoro con i coding agent è semplice: prima della modifica, chiedere all’agente che cosa pensa di aver capito.

Sembrano domande quasi banali. Servono a scoprire una divergenza quando correggerla costa ancora poco.

Se l’agente ha letto male il perimetro, voglio saperlo prima che abbia modificato dieci file.

Non serve sempre. Ma più il progetto cresce, più è utile avere un momento in cui l’interpretazione dell’agente diventa visibile prima dell’esecuzione.

Più piccolo, più visibile, più verificabile

La velocità dei coding agent rende facile chiedere modifiche enormi. Per questo ho cominciato a fare il contrario.

Task più piccoli. Perimetri più espliciti. Modifiche più facili da osservare.

Non voglio ridurre ciò che l’AI può fare. Voglio capire meglio ciò che ha fatto.

Definire un perimetro significa stabilire quali parti del progetto si possono toccare e quali, per quell’attività, restano fuori. Conta ancora di più quando più attività vanno avanti in parallelo.

Dipendenza e interferenza non sono la stessa cosa

DIPENDENZA

Un’attività aspetta l’altra

Un task ha bisogno del risultato prodotto da un altro prima di poter procedere.

INTERFERENZA

Due attività si sovrappongono

Possono procedere in modo indipendente, ma rischiano di toccare gli stessi file, moduli o decisioni.

La regola di oggi: mai due agenti che scrivono nello stesso punto del progetto allo stesso tempo. Se un giorno smetterà di servire, la cambio.

Un task piccolo non è solo più facile da eseguire. È più facile da capire, verificare e correggere.

Finito non significa accettato

Un agente può dichiarare di aver completato un’attività. Questo non vuol dire che il lavoro sia concluso.

La verifica è il momento in cui confronto ciò che è stato fatto con ciò che avevo davvero chiesto. Controllo:

Quello che voglio evitare è la verifica circolare: “hai finito?” — “sì”.

La verifica deve produrre qualcosa di osservabile. Non per forza complesso, ma abbastanza da distinguere un risultato plausibile da un risultato verificato.

Ricordare meno, ma meglio

Lavorare con l’AI produce una quantità enorme di memoria: chat, prompt, codice, assessment, decisioni, documenti, tentativi falliti.

Salvare tutto non significa ricordare meglio. Spesso succede il contrario.

Con VIBE APP sto esplorando una domanda: che cosa vale davvero la pena conservare? Per ora gli elementi che sembrano più utili sono quattro:

STATO

Dove siamo

Dove si trova oggi il progetto.

DECISIONI

Che cosa abbiamo scelto

Le scelte che sarebbe costoso perdere.

REGOLE

Che cosa ricorre

Vincoli o accorgimenti che tornano nel lavoro.

APPRENDIMENTI

Che cosa è cambiato

Errori o verifiche che hanno modificato il modo di procedere.

L’obiettivo è il minimo contesto utile per riprendere il lavoro senza ricostruire ogni volta tutto da zero.

Non solo errori dell’AI

È facile dare la colpa all’AI. Ma molti degli errori più utili che ho incontrato non erano errori del modello. Erano una richiesta troppo ampia, un perimetro lasciato implicito, un contesto insufficiente, un task troppo grande, una regola che aveva senso un mese fa e oggi no, oppure una decisione rimasta soltanto nella mia testa.

Da completare con un episodio reale

Qui inserirò un caso concreto: che cosa avevo chiesto, che cosa è successo, di chi era davvero la causa e quale regola o abitudine è cambiata dopo.

Per questo tratto l’errore come materiale dell’esperimento: qualcosa da correggere, ma anche qualcosa che deve lasciare una traccia nel tentativo successivo.

Una regola vale finché risolve un problema reale. Quando smette, deve poter cambiare.

Lo stesso problema, osservato da lati diversi

Alcuni strumenti nati nel LAB cominciano a collegarsi fra loro. Non sono ancora una suite: sono esperimenti che guardano lo stesso problema da punti diversi.

PRIMA DELL’ESECUZIONE

Prompt Builder

La domanda è: come rendo più esplicita la mia intenzione prima di consegnarla all’AI? CORDA nasce qui.

Apri Prompt Builder →
DURANTE IL LAVORO

VIBE APP

La domanda è: come evito di perdere contesto, perimetro, decisioni e verifiche mentre il progetto cresce?

Apri l’esperimento →

AI locale

Un modello AI locale è un’idea affascinante: lo installo sul mio computer e gli affido alcune attività, invece di interrogare sempre un servizio cloud. Ma conoscere il linguaggio non vuol dire conoscere il mio progetto. Il modello non sa com’è fatta l’architettura, quali decisioni abbiamo già preso, quali regole sono nate dopo un errore, quali parti considero stabili.

Quindi la domanda non è se giri sul PC, ma quanto lavoro serve per renderlo utile dentro quel progetto. A volte può bastare dargli ogni volta il contesto giusto. Altre volte potrebbe servire specializzarlo, fino al fine-tuning, che non è gratuito: servono dati, preparazione e un motivo concreto.

Per questo, nel mockup di VIBE APP, l’AI locale è una domanda aperta e non una funzione pronta.

Vale la pena insegnare a un modello più piccolo a conoscere molto bene una parte del progetto, invece di affidare sempre tutto a un modello generalista più potente?

Per ora non ho una risposta. È il tipo di domanda per cui esiste il LAB.

Il metodo è ancora una domanda

La parte più interessante di questa pagina non è ciò che prova a fissare, ma ciò che continua a mettere in discussione.

Quanto deve essere strutturata una richiesta?
Quando la struttura aiuta e quando diventa burocrazia?
Quanto piccolo deve essere un task per restare verificabile senza perdere la visione d’insieme?
Quanta memoria serve davvero?
Quando ha senso usare più agenti contemporaneamente?
Quando l’AI locale offre un vantaggio reale?
Quando vale la pena specializzare un modello, o fare fine-tuning?
Quanto posso automatizzare la verifica senza trasformarla in un’altra forma di fiducia cieca?
Quando smettiamo di fare Vibe Coding e iniziamo davvero a fare Vibe Engineering?

Questa pagina cambierà se gli esperimenti dimostreranno che alcune delle idee raccolte qui non funzionano. È quello che mi aspetto da un metodo ancora vivo.

Questa pagina ti è stata utile per capire l'approccio?

Hai un'esperienza diversa da raccontare, un errore, un'obiezione o un'idea da aggiungere?

Invia un contributo →