Nel primo articolo di questa serie abbiamo spiegato come preparare un computer per fare vibe coding. Abbiamo installato Linux, configurato Codex e Antigravity, collegato GitHub e pubblicato la nostra prima applicazione con Railway.
Siamo riusciti a sviluppare una piccola applicazione con l'intelligenza artificiale senza scrivere personalmente il codice.
Ma era una prova. Abbiamo chiesto a Codex di programmare, verificato che funzionasse e poi usato Antigravity per controllare il risultato. Per cominciare va bene, ma se vogliamo lavorare su progetti veri ci serve qualcosa di più organizzato.
Che cosa succede quando abbiamo diverse funzionalità in sospeso? Come impediamo all'IA di modificare file che non dovrebbe toccare? Chi verifica che una soluzione sia progettata bene prima di programmarla? E come sappiamo che ciò che pubblichiamo corrisponde esattamente a ciò che abbiamo controllato?
Per rispondere a queste domande ho costruito gradualmente il mio metodo di lavoro. Non ho inventato niente di rivoluzionario: ho adattato le pratiche abituali dello sviluppo professionale a un contesto in cui buona parte del lavoro è svolta da agenti di intelligenza artificiale.
Ti spiego come organizzarlo e usarlo passo dopo passo. Magari ti aiuterà a replicarlo.
Come organizzo il lavoro con gli agenti IA
L'idea è semplice: un'intelligenza artificiale sviluppa e un'altra ne verifica il lavoro, mentre noi manteniamo il controllo delle decisioni importanti.
Nel mio caso uso cinque strumenti principali:
| Strumento | Funzione |
| Codex | Analizza, pianifica, programma, testa e documenta. |
| Antigravity | Verifica in modo indipendente il piano e il codice. |
| GitHub | Conserva il codice, le versioni e le Pull Request. |
| Linear | Organizza attività, test, verifiche e stati. |
| Notion | Conserva requisiti, decisioni e cronologia del progetto. |
A questi ne aggiungo un paio: Local WP per gli sviluppi in WordPress e Convex o Supabase se si tratta di un'applicazione web che richiede un database.
Notion è facoltativo, anche se lo consiglio per progetti di medie dimensioni. Vedremo più avanti perché.
Non siamo nemmeno obbligati a utilizzare proprio queste applicazioni. Possiamo sostituire Codex con Claude Code, per esempio, oppure impiegare un altro agente come revisore. L'importante è mantenere separate le responsabilità.
La procedura completa è questa:
- Requisiti.
- Piano tecnico.
- Prima verifica.
- Sviluppo e test.
- Seconda verifica.
- GitHub.
- Distribuzione.
- Verifica finale.
I passi 2 (Codex) e 3 (Antigravity) possono essere ripetuti più volte: se Antigravity trova un problema, Codex lo corregge e ripetiamo la revisione. L'idea è procedere per cicli di lavoro e verifica, senza passare alla fase successiva finché ci sono problemi importanti irrisolti.
Nel mio metodo ci sono due verifiche obbligatorie, anche se la loro profondità dipende dalla complessità dello sviluppo. La prima esamina ciò che intendiamo fare; la seconda controlla ciò che abbiamo effettivamente realizzato.
E c'è una cosa importante: un GO del revisore non equivale all'autorizzazione a pubblicare. Quella decisione resta nostra.
Passo 1. Preparare l'ambiente di lavoro con Codex
Partiamo dal computer configurato nel primo tutorial. Codex, Antigravity e GitHub sono già operativi, quindi non ripeteremo le installazioni.
Apriamo un terminale nella cartella del progetto e avviamo Codex:
cd ~/Proyectos/mi-proyecto
codex
Ora arriva una delle cose che preferisco del lavoro con gli agenti: non dobbiamo configurare manualmente l'intera struttura del progetto. Possiamo chiedere a Codex di farlo.
Prompt 1. Configurare l'ambiente di lavoro
Voglio preparare questo progetto per lavorare con una procedura di sviluppo supervisionato tramite IA.
Tu agirai come analista e sviluppatore. Antigravity sarà il revisore indipendente. Useremo GitHub per il codice, Linear per le attività e, facoltativamente, Notion per la documentazione.
Esamina il progetto e verifica le connessioni disponibili. Proponi le istruzioni permanenti, la documentazione minima, le regole per i permessi e una procedura con due verifiche obbligatorie: del piano tecnico e del codice.
Le implementazioni, le operazioni Git importanti e le distribuzioni richiedono autorizzazione umana. Le attività si chiudono solo dopo aver verificato la produzione.
Presenta prima un piano di configurazione. Non creare file né modificare servizi finché non ricevi autorizzazione.
Codex dovrebbe analizzare ciò che abbiamo a disposizione e dirci cosa manca.
Di norma ci saranno alcune operazioni che dovremo svolgere personalmente:
- Accedere a Linear o Notion.
- Autorizzare un'integrazione.
- Accettare permessi o creare una connessione che richieda l'autenticazione dal browser.
MOLTO IMPORTANTE: non dobbiamo comunicare password o token incollandoli direttamente nella chat.
Useremo i meccanismi di autenticazione di ogni servizio (Github e Claudflare ne dispongono) e concederemo soltanto i permessi necessari.
Una volta approvata la configurazione, Codex potrà preparare i file e organizzare gli strumenti.
Naturalmente controlleremo che l'abbia fatto davvero, quindi gli chiederemo di verificarlo. Un agente non può creare una connessione con Linear se il suo ambiente non dispone di un'integrazione compatibile.
Passo 2. Organizzare la documentazione senza riempire il repository di file
Per lavorare con gli agenti abbiamo bisogno di qualcosa che le conversazioni da sole non offrono: una memoria operativa del progetto.
Immagina di sviluppare da diverse settimane e di iniziare una nuova sessione di Codex. Non vogliamo spiegare di nuovo tutta l'architettura, quali strumenti utilizziamo, quali file può modificare e come funziona la distribuzione.
Per evitarlo, useremo due documenti di base nel repository:
- AGENTS.md: istruzioni permanenti per Codex, limiti di intervento e regole di sviluppo.
- PROJECT.md: descrizione del progetto, architettura di base, ambienti e collegamenti alla documentazione.
Codex può crearli a partire dai nostri requisiti.
E a cosa ci serve Notion?
Nei progetti piccoli, i file Markdown possono bastare a documentare modifiche e decisioni. Ma quando iniziamo ad accumulare funzionalità, decisioni, requisiti e cambiamenti architetturali, ci ritroviamo con troppi documenti nel repository.
Per questo consiglio Notion per i progetti di medie dimensioni.
Lì conserveremo soprattutto i PRD (Product Requirements Document), le decisioni tecniche e la cronologia del progetto. Linear raccoglierà le attività, i loro stati, le verifiche e i test. GitHub conserverà il codice.
La cosa interessante è che Notion e Linear saranno utilizzati soprattutto dagli agenti stessi. Codex scriverà e aggiornerà la documentazione, consulterà i requisiti prima di programmare e registrerà i risultati. Antigravity dovrà leggere queste informazioni per effettuare le verifiche.
Non dovremo scrivere manualmente pagine e pagine di documentazione. La nostra responsabilità sarà verificare che i requisiti e le decisioni importanti rispecchino ciò che vogliamo.
Passo 3. Definire che cosa vogliamo sviluppare
Useremo come esempio uno sviluppo reale che ho realizzato per questo sito.
Nella mia rivista, le pagine dei tag mostravano gli articoli in ordine cronologico. Volevo migliorarle affinché mettessero in evidenza i contenuti più interessanti senza perdere l'elenco abituale.
È il tipo di esigenza che possiamo spiegare a Codex con il linguaggio naturale, sapendo che una richiesta simile lascia parecchie domande aperte.
- Quanti articoli mettiamo in evidenza?
- Come decidiamo quali sono rilevanti?
- Che cosa succede agli altri?
- Deve funzionare su tutte le pagine?
- Quali elementi non vogliamo modificare?
Prima di analizzare qualsiasi cosa, conviene risolvere questi dubbi.
Prompt 2. Preparare requisiti e piano tecnico
Voglio sviluppare questa funzionalità: [DESCRIZIONE].
Leggi le istruzioni e la documentazione del progetto. Trasforma l'esigenza in requisiti verificabili e criteri di accettazione. Prepara o aggiorna il PRD e organizza le attività necessarie in Linear.
Esamina il codice esistente e proponi la soluzione più semplice che soddisfi i requisiti, indicando i file interessati, i rischi, le alternative e i test.
Non programmare ancora. Chiedimi le decisioni funzionali che non puoi prendere con le informazioni disponibili e prepara il piano per una verifica indipendente.
Questa è una delle differenze più importanti rispetto a chiedere semplicemente a un'IA di programmare qualcosa.
Codex può aiutarci a trasformare un'idea in una specifica. Siamo noi a decidere se quella specifica risponde alla nostra esigenza.
Nel caso dei tag, per esempio, il criterio di accettazione non poteva limitarsi alla comparsa degli articoli in evidenza. Dovevamo anche mantenere la navigazione, evitare duplicazioni indesiderate e garantire il corretto funzionamento nelle diverse pagine.
Una volta approvato l'approccio, Codex lo registra e prepara il piano tecnico.
Non abbiamo ancora scritto una riga di codice.
Progettazione del frontend
In questo caso avevo le idee molto chiare sul design che volevo, quindi non ho chiesto proposte visive. Tuttavia, in altre occasioni le chiederei proprio a questo punto, affinché venissero considerate prima di propormi la soluzione tecnica.
Ovviamente, se sai già cosa vuoi, glielo spieghi e basta. Oppure, se ti serve una funzionalità che riguarda il backend e non il frontend, non avrai bisogno di mockup.
Passo 4. Prima verifica: controllare il piano con Antigravity
Ora entra in gioco il nostro secondo agente.
Apriamo un altro terminale nella stessa cartella del progetto ed eseguiamo:
agy
Nella mia procedura attuale, Antigravity funziona manualmente. Non lasciamo che Codex lo richiami automaticamente e prosegua senza aver esaminato il risultato.
Vogliamo che agisca come un revisore indipendente, non come un altro programmatore che inizia a modificare i file.
Prompt 3. Verificare il piano tecnico
Agisci esclusivamente come revisore tecnico indipendente.
Esamina le istruzioni del progetto, i requisiti e il piano proposto da Codex. Valuta se la soluzione è fattibile, sufficientemente semplice, sicura e compatibile con il funzionamento esistente.
Verifica i rischi, le possibili regressioni e l'adeguatezza dei test previsti.
Esprimi un giudizio motivato: GO, GO condizionato o NO-GO. Se non hai prove sufficienti, dichiaralo esplicitamente.
Individua i problemi concreti e le correzioni necessarie. Non modificare alcun file.
Perché effettuare una verifica prima di sviluppare?
Perché una soluzione può essere programmata perfettamente e, nonostante ciò, essere una cattiva soluzione.
Forse introduce una dipendenza inutile, duplica informazioni già esistenti, esegue troppe query o complica la manutenzione futura.
Con i tag, per esempio, non bastava realizzare un sistema di contenuti in evidenza. Bisognava anche valutare come calcolarne l'ordine senza eseguire operazioni lente ogni volta che qualcuno visitava una pagina.
Se il revisore individua problemi, trasmettiamo il suo rapporto a Codex. Quest'ultimo rivede il piano e lo sottoponiamo nuovamente a verifica, quando necessario.
Non si inizia a programmare finché non abbiamo un piano accettato e un'autorizzazione umana a implementarlo.
Passo 5. Codex sviluppa ed esegue i test
Con il piano approvato comincia l'implementazione.
Codex lavorerà su un branch del repository. Se hai letto la prima parte, conosci già Git e GitHub, quindi non serve ripetere come si usano.
La novità è che non programmiamo direttamente sulla versione stabile del progetto. Prepariamo le modifiche separatamente, per poterle esaminare prima di integrarle.
Prompt 4. Implementare la funzionalità
Autorizzo lo sviluppo del piano approvato e verificato relativo a [ATTIVITÀ LINEAR].
Lavora su un branch dedicato e limita le modifiche all'ambito autorizzato.
Implementa la soluzione, esegui i test pertinenti e verifica le possibili regressioni. Documenta i risultati in Linear.
Prepara il diff completo, identifica i file modificati e fornisci le prove necessarie per la seconda verifica.
Non effettuare merge né distribuzioni. Fermati quando lo sviluppo è pronto per la revisione.
Codex può modificare file, eseguire test e correggere errori entro l'ambito che abbiamo approvato.
Ma c'è una cosa da tenere d'occhio: il fatto che l'IA affermi che una funzionalità funzioni non significa che sia stata verificata.
Ci servono prove. A seconda del progetto, possono essere test automatizzati, risultati di esecuzione, verifiche funzionali oppure una combinazione di tutto questo.
Dobbiamo anche distinguere tra ciò che Codex ha testato e ciò che non può ancora verificare.
Tornando al nostro esempio, non basta verificare che compaiano tre articoli in evidenza. Dobbiamo controllare cosa succede quando gli articoli disponibili sono meno, quando si cambia pagina o quando un contenuto non possiede i dati attesi, come un articolo non tradotto in una delle lingue.
L'agente deve documentare queste verifiche e qualsiasi limitazione.
Passo 6. Seconda verifica: controllare il codice effettivo
Abbiamo sviluppato la funzionalità, ma non la pubblichiamo ancora.
Torniamo ad Antigravity e gli chiediamo di esaminare il codice modificato, non semplicemente il rapporto preparato da Codex.
Prompt 5. Verificare l'implementazione
Agisci come revisore tecnico indipendente per [ATTIVITÀ LINEAR].
Esamina il diff completo, il piano approvato, i requisiti e le prove dei test.
Cerca difetti funzionali, problemi di sicurezza, regressioni, complessità non necessarie e modifiche fuori dall'ambito autorizzato.
Emetti un giudizio motivato e indica, quando possibile, i problemi con il file e la posizione corrispondenti.
Registra l'impronta SHA-256 del diff verificato per identificare esattamente la versione esaminata.
Non modificare file né autorizzare commit, merge o distribuzioni.
Ci sono due dettagli importanti.
Il primo è che Antigravity deve poter consultare le stesse regole e gli stessi requisiti utilizzati da Codex. Altrimenti rischia di verificare una soluzione tecnicamente corretta, ma che non rispetta ciò che avevamo chiesto.
Il secondo è conservare la documentazione dell'insieme di modifiche sottoposto a verifica. Così possiamo identificare la versione esatta che ha ricevuto il GO e rilevare se il codice è stato modificato successivamente. L'impronta deve essere calcolata in modo riproducibile sullo stesso contenuto.
Nel mio caso conservo l'intero resoconto in Linear, collegato all'attività corrispondente.
Se Antigravity trova errori, torniamo a Codex, chiediamo le correzioni e ripetiamo la verifica.
Due agenti possono sbagliare, anche quando concordano nella valutazione. Per questo le verifiche sono controlli aggiuntivi, non garanzie assolute. E per questo, facoltativamente, possiamo aggiungerne una terza.
Passo 7. Integrare le modifiche in GitHub
Quando abbiamo ottenuto un GO, possiamo preparare l'integrazione. La procedura abituale è:
Branch > Commit > Push > Pull Request > Merge.
Non dobbiamo eseguire manualmente questi comandi. Può occuparsene Codex, ma dobbiamo capire che cosa stiamo autorizzando.
La Pull Request ci permette di esaminare quali modifiche vogliamo incorporare nel branch principale, con quali test e con quali raccomandazioni del revisore.
Conviene inoltre controllare che la versione che stiamo per integrare sia ancora quella verificata. Se modifichiamo il codice dopo aver ricevuto un GO, quella valutazione potrebbe non essere più valida.
Preferisco mantenere autorizzazioni esplicite per le operazioni importanti. Possiamo raggrupparne alcune quando l'ambito è molto chiaro, ma non concedere libertà illimitata di integrare e pubblicare.
Una cosa è che il revisore giudichi corretto uno sviluppo, un'altra è che noi decidiamo di incorporarlo.
È qui che potrebbe entrare in gioco la terza IA: possiamo aggiungere un secondo revisore specializzato, come CodeRabbit.
A differenza di Antigravity, che usiamo per esaminare localmente il piano e il codice, CodeRabbit può analizzare automaticamente le Pull Request di GitHub prima che vengano unite.
È un'ulteriore revisione interessante per i progetti importanti, anche se non è indispensabile e ha un costo, per quanto modesto rispetto a ciò che offre. Per ora preferisco mantenere le due verifiche manuali e valutare questa terza quando il progetto sarà più grande.
Passo 8. Distribuire e verificare il funzionamento in produzione
Questo passaggio dipende molto da dove ospitiamo il progetto.
Nella prima parte abbiamo usato Railway. Potremmo anche pubblicare tramite GitHub Actions, gli strumenti del nostro hosting o qualsiasi altro sistema di distribuzione.
Le particolarità di WordPress, LocalWP e Webempresa le vedremo in un altro articolo.
Qui ci interessa una regola generale: una distribuzione completata correttamente non significa che la funzionalità funzioni bene.
Una volta pubblicata la modifica, dobbiamo verificare l'applicazione reale.
Nel nostro esempio, significa visitare le pagine pubbliche, controllare gli articoli in evidenza, navigare nell'elenco e assicurarci di non aver alterato altre funzionalità.
Dobbiamo anche confermare che venga mostrata la nuova versione. A volte il codice viene pubblicato correttamente, ma una cache continua a servire contenuti precedenti, come è successo a me con WP Rocket.
Negli sviluppi importanti dobbiamo sapere come ripristinare la versione stabile se qualcosa va storto.
Solo dopo queste verifiche possiamo affermare che la funzionalità è terminata.
Passo 9. Chiudere l'attività e preparare lo sviluppo successivo
Una volta verificato il risultato, chiediamo a Codex di aggiornare Linear e la documentazione del progetto.
Deve registrare cosa è stato sviluppato, quale versione è pubblicata, quali test abbiamo eseguito e se rimane qualche problema aperto.
L'attività passa a completata dopo la verifica in produzione, non quando Codex finisce di programmare né quando Antigravity emette il suo GO.
Questa documentazione ha un altro vantaggio: possiamo chiudere la sessione e iniziarne una nuova senza perdere il contesto.
Consiglio infatti di farlo quando iniziamo una funzionalità diversa. Gli agenti possono recuperare regole, requisiti e decisioni dai documenti del progetto, invece di dipendere da conversazioni interminabili.
Col tempo potremo automatizzare parte del coordinamento tra Codex e Antigravity, anche se per il momento preferisco mantenerlo manuale, verificare che la procedura funzioni e acquistare fiducia prima di eliminare passaggi di supervisione.
Vale la pena lavorare così per qualsiasi sviluppo?
No.
Per creare una prova o sperimentare per venti minuti, preparare documentazione, due verifiche e un processo di pubblicazione sarebbe eccessivo.
Ma quando sviluppiamo un sito vero, un'applicazione per un cliente o un progetto da mantenere per mesi, il lavoro aggiuntivo ha perfettamente senso.
Il vantaggio di questa procedura non è eliminare gli errori né sostituire le conoscenze di programmazione, ma permetterci di lavorare in modo più ordinato, conservare le decisioni e individuare i problemi prima che arrivino agli utenti. Riduciamo gli errori tipici del Vibe Coding iniziale.
E poiché gli agenti svolgono la maggior parte delle attività operative, il nostro intervento si concentra su ciò che conta: decidere cosa vogliamo, approvare come realizzarlo e verificare che il risultato funzioni.
Conclusione
Nel primo articolo abbiamo preparato il computer. In questo abbiamo preparato il nostro modo di lavorare.
Ora sappiamo come:
- Trasformare un'esigenza in requisiti.
- Chiedere un piano a Codex.
- Verificarlo con Antigravity.
- Sviluppare una funzionalità.
- Esaminare il codice.
- Pubblicarla con il controllo delle versioni.
- Documentare tutto.
Non si tratta semplicemente di programmare più velocemente grazie all'intelligenza artificiale, ma di poter mantenere ciò che sviluppiamo, capire cosa è stato modificato e disporre di una procedura per correggere i problemi quando si presentano.
Nella prossima parte applicheremo questo metodo a WordPress: sviluppo locale, test, file versionati e distribuzioni su un hosting reale.
Domande frequenti
Devo saper programmare per utilizzare questa procedura?
Non è indispensabile scrivere codice, ma bisogna comprendere i concetti di base dello sviluppo e imparare a interpretare test e rischi. L'IA non elimina la nostra responsabilità sul risultato.
È obbligatorio usare Codex e Antigravity?
No. Puoi sostituirli con altri agenti di sviluppo e revisione. L'importante è separare i ruoli ed evitare che lo sviluppatore sia l'unico a valutare il proprio lavoro.
Mi servono Notion e Linear?
Linear è lo strumento per le attività che usiamo in questo tutorial. Notion è facoltativo nei progetti semplici, anche se lo consiglio quando si accumulano requisiti, decisioni e documentazione. In alternativa puoi conservare queste informazioni in Markdown.
Cosa faccio quando Antigravity emette un NO-GO?
Passa il rapporto a Codex, chiedigli di correggere i problemi e ripeti la verifica. Non passare automaticamente alla fase successiva.
Perché fare due verifiche?
Perché la prima cerca problemi nell'impostazione e la seconda controlla l'implementazione. Esaminare solo il codice può lasciar passare errori di progettazione che sarebbe stato più semplice correggere prima.
Posso usare questo metodo con WordPress o altre tecnologie?
Sì. La procedura è indipendente dal linguaggio e dalla piattaforma. Cambiano i test, gli ambienti e i meccanismi di pubblicazione.
Quando è davvero conclusa un'attività?
Quando la versione autorizzata è stata pubblicata, è stato verificato che funziona in produzione e le prove e le decisioni sono state registrate.

Lascia un commento