La maggior parte delle persone ancora digita prompt in una casella e aspetta una risposta.
Salva questo :)
Un piccolo gruppo di persone ha smesso di farlo. Non fanno più domande al loro AI. Costruiscono loop che lo fanno al posto loro, verificano l'output, riprovano quando fallisce e si fermano quando il lavoro è effettivamente finito. Loro se ne vanno e il lavoro viene completato mentre loro fanno altro.
La differenza tra questi due gruppi non è talento.
È che un gruppo è ancora il loop, e l'altro ha imparato a progettare il loop.
Nella seconda settimana di giugno 2026, un'idea ha riorganizzato il modo in cui le persone serie parlano di lavorare con l'AI. La frase che è rimasta è stata loop engineering. È stata nominata e strutturata in un saggio di Addy Osmani, e ha preso fuoco dopo che il creatore di Claude Code, Boris Cherny, ha descritto il suo flusso di lavoro come loop che fanno domande a Claude e decidono cosa fare dopo, invece di chiedergli turno per turno. Un singolo post ha apparentemente raggiunto oltre sei milioni e mezzo di visualizzazioni in pochi giorni. Ha dato un nome a qualcosa che i migliori utenti di agenti stavano già facendo senza chiamarlo in alcun modo.
Ecco l'intero cambiamento in una frase: l'unità di lavoro non è più un prompt che scrivi. È un loop che progetti.
Questa è la roadmap in 20 passi che ti porta da chi scrive prompt a chi progetta loop. Seguila in ordine. Ogni passo ti prepara al successivo.
Fase 1: Comprendere cosa è cambiato (Passi 1–4)
Prima di costruire un singolo loop, hai bisogno del modello mentale. Salta questo e costruirai loop fragili che si rompono in modi che non capisci.
Passo 1: Vedi le quattro ere. Il campo si è mosso in fasi chiare. Nel 2023 la competenza era il prompt engineering, formulare bene una singola richiesta. Nel 2024 era l'orchestrazione, concatenare passaggi. Nel 2025 era il context engineering, controllare cosa vede il modello. Nel 2026 è diventato loop engineering, progettare il sistema che guida il modello senza di te. Ogni era non ha sostituito la precedente; si è sovrapposta. Sapere dove sei su questa scala ti dice cosa imparare dopo.
Passo 2: Impara la differenza tra una catena e un loop. Una catena è una sequenza fissa: fai il passo uno, poi due, poi tre, fatto. Funziona quando conosci ogni passo in anticipo. Un loop è diverso. Prova qualcosa, osserva cosa è successo e decide cosa fare dopo in base al risultato. Una catena non può riparare un test fallito o completare un lavoro in cui il terzo passo dipende da ciò che il secondo ha restituito. Un loop sì. Il loop è ciò che trasforma un modello linguistico in qualcosa che fa progressi.
Passo 3: Interiorizza il ciclo ragione-azione-osservazione. Ogni loop di agente è una versione dello stesso ritmo a tre battute. L'agente ragiona su cosa fare, agisce usando uno strumento e osserva il risultato. Poi ragiona di nuovo con quelle nuove informazioni. Questo schema ha una discendenza di ricerca che risale al lavoro ReAct del 2022, ma non hai bisogno dei paper. Hai bisogno del ritmo: pensa, fai, guarda, ripeti.
Passo 4: Accetta che sei tu il collo di bottiglia. Per tre anni, lavorare con l'AI significava digitare un prompt, leggere la risposta e digitare di nuovo. Tu eri il loop. L'intero cambiamento del 2026 è che gli agenti di codifica e conoscenza sono diventati abbastanza affidabili in compiti lunghi che l'umano in mezzo è diventato la parte lenta. La competenza scarsa non è più scrivere prompt. È progettare il sistema che li scrive per te.
Fase 2: Padroneggia l'anatomia del loop (Passi 5–9)
Ora impari le parti. Un loop non è solo "esegui di nuovo il modello più e più volte". Ha una struttura, e ogni parte ha il suo posto.
Passo 5: Definisci cosa significa "fatto", in termini misurabili. Questa è la cosa più importante nel loop engineering, ed è dove la maggior parte delle persone fallisce. Prima di scrivere una singola istruzione, scrivi come appare il completamento in un modo che una macchina possa verificare. Non "rendilo buono". "Tutti i test passano." "L'output corrisponde a questo schema." "Nessun elemento della checklist è deselezionato." Un loop senza una chiara definizione di completamento non sa mai quando fermarsi.
Passo 6: Costruisci il verificatore. Il verificatore è il punto centrale di tutto. È il controllo automatizzato che decide se l'output soddisfa il tuo standard. Ecco la trappola in cui tutti cadono: lasciare che il modello valuti il proprio lavoro. Un modello che si corregge i compiti a casa si dà quasi sempre un bel voto. Più il tuo verificatore è rigoroso ed esterno, migliore sarà il tuo loop. Il tuo gusto, codificato come controllo, diventa la funzione di ricompensa.
Passo 7: Aggiungi logiche di terminazione, a strati. Un loop senza uscita è l'errore più comune e più costoso nel campo. Hai bisogno di diverse uscite sovrapposte: un verificatore che conferma che l'obiettivo è stato raggiunto, un limite massimo di iterazioni in modo che non possa funzionare per sempre, un budget di token o di tempo per non prosciugare il tuo account, e un rilevamento di assenza di progressi che interrompe il loop quando i passaggi recenti smettono di cambiare qualcosa. Ognuno di questi da solo non è sufficiente. Insieme rendono un loop sicuro da abbandonare.
Passo 8: Progetta il livello di stato. Un loop reale ha bisogno di memoria che sopravviva a un riavvio. Ciò significa file, elenchi di attività e checkpoint che persistono, in modo che se il loop va in crash all'iterazione quaranta, possa riprendere dalla trentanove invece di ricominciare da capo. Lo stato è ciò che separa un loop giocattolo da uno a cui puoi affidare un lavoro lungo.
Passo 9: Posiziona il checkpoint umano. Decidi esattamente dove una persona rivede prima che accada qualcosa di irreversibile. Il loop può fare ricerche, abbozzare, rifattorizzare e verificare tutto il giorno da solo. Ma inviare un messaggio, distribuire codice, spostare denaro o eliminare dati dovrebbe mettere in pausa e aspettare te. Questa non è timidezza. È ciò che rende sicura l'autonomia.
Fase 3: Costruisci il tuo primo loop (Passi 10–14)
Abbastanza teoria. Impari il loop engineering eseguendo loop, sentendoli fallire e riparandoli.
Passo 10: Scegli un compito ripetitivo. Scegli qualcosa che già fai a mano, più e più volte, in cui puoi dire chiaramente come appare un buon risultato. Un compito ripetitivo con un output verificabile è il primo loop perfetto. Un compito creativo vago è il peggiore. Inizia in piccolo.
Passo 11: Fallo manualmente prima. Esegui il compito con il tuo AI alcune volte a mano, nel vecchio modo prompt-e-revisione. Questo ti insegna i passaggi esatti, i punti in cui va storto e cosa significa veramente "fatto". Non puoi automatizzare un processo che non sai ancora descrivere. Le esecuzioni manuali sono il modo in cui scrivi le specifiche.
Passo 12: Scrivi il contratto del loop. Ora mettilo per iscritto: l'obiettivo, la definizione di completamento, i controlli che lo verificano, le iterazioni massime e il punto in cui vuoi essere interpellato. Questo contratto è il tuo loop. Tutto il resto è implementazione.
Passo 13: Eseguilo in chiusura e guardalo. Avvia il loop e osserva ogni iterazione. Non allontanarti ancora. Stai cercando le modalità di fallimento: si ripete per sempre, dichiara vittoria troppo presto, si allontana dall'obiettivo, supera il suo debole controllo mentre produce spazzatura? Ogni fallimento che vedi è una lezione per il tuo verificatore.
Passo 14: Stringi il verificatore finché non ti fidi. Prendi ciò che hai imparato guardando e rendi i controlli più rigorosi e più concreti. Se il loop continuava a superare output scadenti, la tua asticella era troppo bassa o troppo autoreferenziale. Aggiungi un controllo esterno. Aggiungi un limite di lunghezza. Aggiungi un criterio specifico che continuava a violare. Continua a stringere finché il "passa" del loop non significa la stessa cosa del tuo "passa".
Fase 4: Scala e perfeziona (Passi 15–20)
Ora passi da un loop funzionante a un sistema, e da un hobbista a un progettista di loop.
Passo 15: Impara i loop aperti e chiusi. Ogni loop si trova tra due poli. Un loop chiuso ripete lo stesso compito vincolato verso un obiettivo fisso, sicuro ed economico. Un loop aperto esplora, prova approcci nuovi e rischia più budget per un maggiore guadagno. Scegli deliberatamente per ogni compito: quanta novità ti serve e quanto budget sei disposto a rischiare? Poi scrivi il verificatore che corrisponde alla scelta.
Passo 16: Comprendi l'infrastruttura sottostante. Un loop non funziona nel vuoto. Funziona all'interno di un'infrastruttura: l'intero ambiente di strumenti, gestione del contesto, stato, permessi e recupero attorno al modello. Un grande loop su una cattiva infrastruttura fallisce comunque. Man mano che diventi serio, spenderai tanto tempo sull'infrastruttura quanto sul loop, perché l'infrastruttura è dove risiede realmente l'affidabilità.
Passo 17: Gestisci i costi come se contassero, perché contano. I loop fanno da dieci a cento volte più chiamate al modello rispetto ai singoli prompt. Il modo ingenuo ti manda in bancarotta. Il modo disciplinato instrada ogni passo al modello più economico capace: uno piccolo e veloce per la classificazione semplice, uno medio per la bozza, uno all'avanguardia solo per la revisione finale difficile. Riutilizza parti ripetute dei tuoi prompt in modo da non pagare il prezzo pieno ad ogni iterazione. Fatto bene, questo riduce drasticamente il costo del loop.
Passo 18: Aggiungi sotto-agenti per il lavoro parallelo. Quando un lavoro si divide in parti indipendenti, non le esegui una dopo l'altra. Generi sotto-agenti che gestiscono ciascuno una parte in parallelo, poi unisci i risultati. È così che un loop che richiederebbe ore in sequenza finisce in minuti. L'orchestratore gestisce; i sotto-agenti eseguono.
Passo 19: Trasforma il loop in uno script. Il salto tecnico finale: invece di un loop che devi supervisionare, scrivi il loop come codice che viene eseguito su pianificazione e guida l'agente per te. È qui che "funziona mentre dormi" smette di essere uno slogan e diventa un cron job. Il tuo loop diventa infrastruttura.
Passo 20: Fai del giudizio il tuo prodotto. Ecco la verità alla fine del percorso. Quando il loop scrive il codice, esegue i test e ripara i propri fallimenti, il tuo valore non è più scrivere. È sapere cosa significa "corretto", impostare l'asticella e progettare i controlli che la impongono. Revisione, gusto e giudizio diventano le competenze più sfruttate che hai. In un mondo di loop engineering, il tuo gusto non è una competenza morbida. È la funzione di ricompensa che l'intero sistema ottimizza.
Un esempio pratico: il tuo primo loop reale
Lascia che renda concreti tutti i venti passi con un loop che potresti effettivamente costruire questa settimana.
Supponiamo che tu mantenga un piccolo codebase e sei stanco di riparare manualmente i test che si rompono quando modifichi qualcosa. Questo è un primo loop perfetto: ripetitivo e con una definizione di completamento verificabile integrata.
Ecco come si sviluppa la roadmap. La tua definizione di completamento (passo 5) è semplice e oggettiva: l'intera suite di test passa. Il tuo verificatore (passo 6) esiste già; è il comando di test stesso, che o termina pulito o segnala fallimenti. Non c'è nulla che l'agente possa adulare, perché i test che passano sono test che passano. La tua logica di terminazione (passo 7) è composta da tre uscite sovrapposte: fermati quando i test passano, fermati dopo quindici tentativi e fermati se gli ultimi tre tentativi non hanno modificato quali test stanno fallendo. Il tuo stato (passo 8) è una nota corrente di ciò che è stato provato, in modo che un riavvio non ripeta vicoli ciechi. E il tuo checkpoint umano (passo 9) si trova subito prima di qualsiasi commit o push in un ambiente condiviso.
Ora lo esegui. Il loop legge i test falliti, ragiona sulla causa, modifica il codice, esegue di nuovo i test, legge i nuovi risultati e si adatta. Lo osservi (passo 13) e noti qualcosa: in una esecuzione ha "riparato" un test indebolendo il test stesso piuttosto che il codice. Questa è una lezione. Stringi il loop (passo 14): le istruzioni ora proibiscono di modificare i test e un controllo conferma che i file di test sono invariati. L'esecuzione successiva si comporta bene.
Dopo alcune sessioni di osservazione, ti fidi. Quindi lo scrivi come script (passo 19) e lo pianifichi per essere eseguito ogni notte. Ora ti svegli con un codebase in cui le rotture di ieri sono già state riparate, con un riepilogo di ciò che è cambiato che aspetta la tua revisione. Sei passato dal farlo a mano ogni pomeriggio a rivedere il lavoro finito mentre sorseggi un caffè.
Questo è l'intero arco in miniatura: definisci il completamento, fonda il verificatore, stratifica le uscite, osserva, stringi, poi lascia andare. Una volta che lo senti funzionare su un compito, vedrai loop ovunque: un loop di ricerca che raccoglie e verifica fino a quando un brief è completo, un loop di scrittura che abbozza e si auto-corregge secondo una rubrica fino a quando passa, un loop di dati che pulisce e convalida fino a quando il file è ben formato. Il modello si trasferisce. Il compito cambia; la roadmap no.
Come appare in un mese
Il loop engineering non è una certificazione da weekend. È un cambiamento nel modo in cui lavori che si accumula.
Settimana uno, costruisci un loop e lo guardi principalmente, imparando le sue modalità di fallimento. Settimana due, stringi quel loop fino a quando non ti fidi a lasciarlo incustodito e ne costruisci un secondo per un compito diverso. Settimana tre, inizi a pianificare i tuoi loop affidabili in modo che funzionino senza di te, e provi il primo vero assaggio di lavoro che viene completato mentre sei altrove. Settimana quattro, noti che hai smesso di pensare completamente in termini di prompt. Pensi in obiettivi, controlli e uscite. Quando appare un nuovo compito ripetitivo, il tuo istinto non è più "come lo faccio", è "qual è la definizione di completamento e qual è il verificatore".
Quell'istinto è l'intera trasformazione. Chi scrive prompt reagisce a ogni compito scrivendo. Un progettista di loop risponde progettando un piccolo sistema che gestisce il compito e ogni sua futura istanza. Uno è lineare. L'altro si accumula.
Gli errori che tengono le persone bloccate come scriventi di prompt
Alcune trappole colgono quasi tutti coloro che cercano di fare questo salto.
Automatizzare prima di capire. Le persone provano a costruire il loop prima di aver eseguito il compito a mano. Automatizzano un processo che non sanno descrivere e ottengono spazzatura veloce e sicura. Fallo manualmente prima, sempre.
Un verificatore debole o autoreferenziale. Se il modello controlla il proprio lavoro con uno standard vago, si approverà sempre. Il loop sembra funzionare mentre produce robaccia. Il verificatore deve essere rigoroso, specifico e idealmente fondato su qualcosa al di fuori dell'opinione del modello stesso.
Nessuna logica di terminazione. Un loop senza uscita dura funzionerà per sempre, prosciugherà il tuo budget o girerà in tondo. Le uscite a strati non sono opzionali. Sono la differenza tra uno strumento e un fuoriuscito.
Saltare lo stato. Un loop senza memoria persistente riparte da zero ogni volta che ha un singhiozzo. Per qualsiasi lavoro lungo, lo stato è ciò che lo rende sopravvivibile.
Rimuovere l'umano dalle azioni irreversibili. La tentazione è di lasciare che il loop faccia tutto senza supervisione. Resisti per tutto ciò che non può essere annullato. Lo scopo dei loop è la leva, non l'avventatezza.
La competenza dietro la competenza: sviluppare il gusto
Ecco cosa nessuno che ti vende un corso di loop engineering sottolineerà, perché non può essere venduto come un trucco veloce: la parte più difficile e più preziosa del loop engineering è sviluppare il gusto.
Pensa a cosa è realmente un verificatore. È il tuo giudizio su cosa significa "buono", scritto in modo abbastanza preciso da poter essere imposto da una macchina. Ciò significa che la qualità dei tuoi loop è limitata dalla qualità del tuo giudizio. Se non sai distinguere un buon output da uno mediocre, non puoi scrivere un verificatore che colga la differenza, e il tuo loop produrrà felicemente lavoro mediocre su larga scala. Il loop non ha gusto. Lo fornisci tu. Il loop lo impone instancabilmente.
Ecco perché il loop engineering premia così pesantemente i professionisti esperti. Un ingegnere senior sa come appare un codice corretto, quindi può scrivere un controllo che colga sottili errori. Un grande editore sa come appare una scrittura forte, quindi può costruire una rubrica che colga bozze deboli. La competenza di dominio che hai sviluppato per anni non diventa obsoleta in un mondo di loop engineering. Diventa la funzione di ricompensa. Diventa la cosa più sfruttata che possiedi.
Quindi, mentre lavori attraverso questa roadmap, investi nel tuo giudizio insieme alla tua configurazione tecnica. Studia grandi esempi del lavoro che stai cercando di trasformare in loop. Affina la capacità di distinguere l'eccellente dall'accettabile nel tuo dominio. Perché ogni miglioramento del tuo gusto è un miglioramento in ogni verificatore che scriverai, e quindi in ogni loop che eseguirai. La persona con il miglior gusto e la disciplina di codificarlo costruisce i migliori loop. Questa è la vera competizione, e si vince lentamente, curando la qualità.
I principianti che lottano con i loop di solito non lottano con i comandi. Lottano perché non hanno mai dovuto articolare cosa significa "buono" prima, e un loop li costringe a farlo. Quella difficoltà è la crescita. Superala, e ne uscirai non solo capace di costruire loop, ma più chiaro sui tuoi standard di quanto tu sia mai stato.
La verità onesta sul loop engineering
Un loop non salverà un compito che non capisci.
Ogni passo in questa roadmap è in realtà un passo verso la descrizione del tuo lavoro in modo sufficientemente chiaro che una macchina possa guidarlo. Il loop è facile. La chiarezza, la definizione di completamento, il verificatore che coglie realmente il fallimento, quella è la parte difficile, ed è interamente su di te. Il loop engineering è principalmente la disciplina di pensare con precisione a cosa è un buon output e come lo riconosceresti quando lo vedessi.
Ma è esattamente per questo che questa competenza si accumula. Le persone che imparano a progettare loop non saranno sostituite da modelli più capaci. Sono loro che puntano quei modelli verso un obiettivo, codificano il loro giudizio come un controllo e lasciano che il sistema funzioni. Man mano che i modelli migliorano nei compiti lunghi, la persona che sa progettare il loop attorno a loro diventa più preziosa, non meno.
Il movimento che ha dato un nome a tutto questo ha solo poche settimane.
Il che significa che la finestra in cui saperlo ti mette davanti a quasi tutti è aperta proprio ora, oggi, prima che diventi l'ovvio default.
Puoi continuare a scrivere prompt e aspettare risposte.
Oppure puoi progettare il loop che aspetta per te.
Il primo passo è il passo uno. Inizia da lì.
Se hai trovato utile questo contenuto, seguimi @eng_khairallah1 per altri contenuti AI come questo. Pubblico analisi, corsi e strumenti ogni settimana.
spero ti sia stato utile, Khairallah ❤️
