Fable 5: Guida per principianti al Loop Engineering

Ecco la traduzione in italiano del testo fornito, seguendo tutte le linee guida specificate.

L'ingegneria dei loop è il più grande cambiamento mai visto nel prompting dell'AI.

Abbinala a Fable 5 e avrai agenti AI che lavorano per te mentre dormi, costruendo qualsiasi cosa tu possa immaginare.

Questa guida ti insegna esattamente come iniziare.

Una guida per principianti all'ingegneria dei loop e a come una persona comune può sfruttare /loop.

Indice

• Cosa diavolo è un Loop?
• Anatomia del Loop 101
• Prompting 101
• /loop Consigli da Pro

Cosa diavolo è un Loop?

TL;DR

L'ingegneria dei loop è essenzialmente un modo per far sì che gli agenti si diano prompt da soli ed evitino iterazioni manuali.

Prima dell'ingegneria dei loop: Fai un prompt all'AI → L'AI risponde → Iteri → Ripeti

Con l'ingegneria dei loop: Progetti un loop → L'agente torna con un risultato finalizzato (l'agente completa tutte le ricerche, i vai-e-vieni, ecc.)

La persona che ha effettivamente costruito Claude Code (Boris Cherny) l'ha detto chiaramente:

"Non faccio più prompt a Claude. Ho dei loop in esecuzione che fanno prompt a Claude. Il mio lavoro è solo scrivere loop."

Questo è il singolo più grande cambiamento nel fare prompt all'AI che abbiamo mai visto.

Per ora, è tutto ciò che devi sapere. Ciò che è più importante è l'anatomia del loop e come sfruttare effettivamente questo cambiamento per sbloccare la produttività dell'AI.

Anatomia del Loop 101

Anatomia del Loop 101

Per questa guida, farò riferimento a Claude Code, ma questi principi si applicano alla maggior parte degli strumenti e framework AI.

Ogni loop in Claude Code ha le stesse sei parti funzionanti.

Padroneggia queste e sarai in grado di costruire qualsiasi cosa.

1. Trigger (Automazioni)

Il trigger è ciò che avvia il loop.

In Claude Code, attivi le automazioni del loop agente con /schedule e /loop (maggiori dettagli sul prompting più avanti).

/loop viene eseguito a un intervallo specificato; senza un intervallo, si auto-regola in base all'output.

2. Layer di Esecuzione

Qui è dove Claude fa effettivamente il lavoro.

Legge lo stato corrente, agisce e produce output.

Non è necessario alcun input manuale: guarda e basta Claude lavorare.

3. Il Verificatore

Qui è dove dai a Claude un punto di controllo.

Cose come: Test, una build, uno screenshot da confrontare.

Usare un layer di verifica aiuta a garantire che Claude sia effettivamente sulla strada giusta e non produca robaccia.

Puoi usare il comando /goal, che fa un passo avanti eseguendo un modello veloce separato per valutare il lavoro dopo ogni turno.

4. Regole di Arresto

Ogni loop necessita di due tipi di condizioni di arresto:

1. Arresto per successo (tutti i test superati, attività completata)
2. Arresto per fallimento (conteggio tentativi superato, errore irreversibile).

Puoi anche aggiungere regole di arresto, come un budget di token, che può aiutare a gestire la spesa dell'AI.

1Rendile esplicite nelle tue istruzioni, non implicite:
2Hai un massimo di 20 tentativi. Se tutti i test sono superati, segnala "TASK_COMPLETE" e fermati.
3Se incontri un errore che non puoi risolvere dopo 3 tentativi, segnala "TASK_FAILED: [motivo]" e fermati.

5. Memoria (File di Avanzamento)

Tenere un file markdown dei progressi di Claude è generalmente una buona pratica.

Un semplice registro di ciò che è stato fatto in modo da poter controllare il suo lavoro e tornare indietro se necessario.

6. Competenze (CLAUDE.md)

Le competenze sono set di istruzioni salvati che congelano la conoscenza del progetto in modo che l'agente non debba re-imparare lo stesso contesto ad ogni sessione.

Il tuo file CLAUDE.md è ciò che dà personalità al loop e imposta i suoi vincoli per ogni esecuzione.

Consiglio: Mantienilo breve. Un file di regole gonfio viene pagato ad ogni singolo battito del loop.

Metti insieme tutti e sei, e la struttura ottimale del loop appare così:

1TRIGGER   →  ogni 15 min / su commento PR / su fallimento CI
2ESECUTORE →  Claude svolge il compito
3CONTROLLORE →  modello separato valuta l'output
4ARRESTO   →  tutti i test verdi, o 10 iterazioni, o $5 spesi
5MEMORIA   →  progress.md aggiornato ad ogni esecuzione
6COMPETENZE →  CLAUDE.md letto all'inizio di ogni sessione

Prompting 101 (mettere insieme le cose)

Scrivere prompt /loop non è come fare prompt normali. Hai bisogno di un leggero cambiamento mentale quando fai ingegneria dei loop.

Quando fai un prompt normale a Claude, stai semplicemente scrivendo un'istruzione/compito.

Quando progetti un loop, stai scrivendo una condizione finale che deve essere soddisfatta.

Esempio

Prompt (singolo turno):

1Ripara i test falliti nel modulo di autenticazione.

Condizione obiettivo (loop):

1/loop tutti i test nel modulo di autenticazione sono superati e la copertura è superiore all'80%

Un prompt dice a Claude cosa fare, mentre una condizione obiettivo dice a Claude quando fermarsi.

L'anatomia di una buona condizione obiettivo

Ogni buon prompt /loop ha tre cose:

1. Uno stato finale verificabile
2. Un vincolo di ambito (quali file, quali cartelle, quali compiti)
3. Una regola di arresto (iterazioni massime o budget)

Ecco il template:

/loop [stato finale verificabile/tempo], toccando solo [ambito], fermati dopo [X] vincoli, usa [X] Competenze, usa agenti verificatori per [x] punto di controllo, e tieni un file di memoria di tutto il tuo lavoro.

Questa è la struttura base /loop che ogni principiante dovrebbe usare per ottenere ottimi risultati senza complicare eccessivamente le cose.

CLAUDE.md

Pensa al tuo CLAUDE.md come al documento di briefing che il tuo loop legge prima di iniziare ogni esecuzione.

Assicurati di includere tutto ciò che ripeteresti normalmente in un prompt, il tuo stack, le tue regole, le tue preferenze, ecc.

Ancora una volta, mantienilo breve. Ogni riga extra di contesto gonfio costa token.

Mettere tutto insieme (un esempio di /loop per un brief di ricerca):

1CLAUDE.md (impostato una volta):
2Stile di ricerca: completo, citato, senza fronzoli
3Formato output: markdown con titoli chiari
4Non creare mai file al di fuori di /research
5Fonti preferite: fonti primarie, pubblicazioni rinomate, dati ufficiali
6Budget massimo per sessione: $3
7Competenza (impostata una volta):
8/skill verify-research: prima di segnare qualsiasi sezione come completa, conferma
9che ogni affermazione principale abbia una fonte, ogni sezione abbia almeno 3 punti dati
10di supporto, e non ci siano lacune evidenti. Non consegnare mai ricerche superficiali.
11Il loop:
12/loop ogni 30 minuti,
13
14toccando solo /research/brief.md,
15
16fermati dopo 10 iterazioni o se la stessa query di ricerca appare
173 volte di seguito senza che emergano nuove informazioni,
18
19usa la competenza verify-research dopo che ogni sezione è stata abbozzata,
20
21usa un agente verificatore per controllare la qualità delle fonti e la completezza
22della copertura a metà strada e prima dell'invio finale,
23
24e tieni un file di memoria in /research/progress.md che registri
25quali sezioni sono state completate, quali fonti sono state utilizzate,
26e quali angolazioni necessitano ancora di copertura — leggilo all'inizio
27di ogni esecuzione e aggiornalo alla fine.
28
29Argomento: [il tuo argomento qui]
30
31Ogni principio in un unico posto. Il loop viene eseguito su un timer, rimane limitato a un file, si ferma da solo in caso di stallo o budget, usa una competenza salvata come gate di qualità, avvia un verificatore separato in due punti di controllo e mantiene un file di memoria persistente in modo che ogni esecuzione riprenda esattamente da dove si era fermata la precedente.

/loop Consigli da Pro

Una sezione di consigli da pro su /loop per iniziare

• Inizia con /goal prima di /loop: È lo stesso comportamento, ma più facile da capire per un principiante.
• Dedica più tempo al deliverable: Quando progetti loop, concentrati su come vuoi che appaia l'obiettivo finale - tutto il resto è praticamente rumore di fondo.
• Abbina lo sforzo al compito: Il tuo sforzo di ragionamento predefinito dovrebbe essere alto. Usa xHigh, Max e Ultracode solo per build complesse.
• Sottoagenti: Ogni sottoagente inizia con una finestra di contesto fresca. Sfrutta la possibilità di distribuire sottoagenti all'interno dei loop.
• Imposta sempre un limite: Prendi l'abitudine di impostare un limite di iterazione massimo e un budget in dollari prima di ogni esecuzione.
• Esegui /compact manualmente prima di sessioni lunghe: Quando la finestra di contesto si avvicina al suo limite, l'SDK si compatta automaticamente. Puoi anche attivarlo prima con /compact.
• I loop funzionano per molto più del codice: Puoi usare /loop per tutti i compiti. Sentiti libero di essere creativo e usare i loop per scrittura, ricerca e compiti non convenzionali che non riguardano il codice.

Conclusione

Spero che questa guida su /loop ti sia stata utile.

Se è stato così, assicurati di seguirmi su @aiedge_ - pubblico articoli sull'AI proprio come questo 2-3 volte a settimana.

Se ti piace il contenuto scritto sull'AI, sentiti libero di iscriverti alla mia newsletter gratuita qui:

https://newsletter.aiedgehq.co/

https://newsletter.aiedgehq.co/

100% gratuito, niente spam e cancellazione in qualsiasi momento.

Infine, se puoi, per favore segui il mio nuovo account di clip dove pubblico brevi video che discutono argomenti di tendenza sull'AI/mercato - sono sicuro che ne trarrai molto valore💙

https://x.com/DeutscherClips/status/2072924183861018957