Claude Code durante la notte: loop engineering e Ralph Loop nel 2026

Documentazione di riferimento Ailoot: ailoot.ai/docs/.

Che cos’è la loop engineering e perché dovrebbe interessarti?#

E la seconda affermazione spiega la portata:

Dietro queste affermazioni c’è un nuovo ruolo ingegneristico: sei l’architetto dei cicli, non un operatore alla tastiera.

Fallo una volta oggi e, ogni giorno, i contatti aumenteranno, gli articoli verranno pubblicati automaticamente, il bot gestirà la corrispondenza e il report delle metriche arriverà sulla tua scrivania entro le 9. Lo costruisci e funziona ogni giorno senza di te.

Se apri ancora Claude Code, scrivi un prompt, aspetti, leggi e scrivi un altro prompt, ti stai perdendo il cambiamento più grande del 2026. I modelli sono diventati abbastanza potenti da lavorare in cicli senza supervisione.

In che cosa Ralph Loop è diverso da una normale richiesta a Claude Code#

Al suo nucleo, la tecnica è un semplice ciclo bash attorno a un agente:

Il codice originale che ha dato il via a tutta l’ondata:

while :; do cat PROMPT.md | claude-code ; done

Un prompt in un file, un ciclo infinito attorno a esso. E il commento più schietto dell’autore:

Anthropic ha integrato la stessa logica nel plugin ralph-loop e nei comandi /loop, /goal e /batch di Claude Code: sono disponibili direttamente nel terminale, senza script. Il fatto stesso che Anthropic abbia pubblicato un plugin per ripetere i prompt all’infinito ha suscitato un dibattito nella GitHub Issue #23084 sulla correttezza di questo approccio verso il modello. Il dibattito è aperto; il plugin funziona.

Tre comandi integrati in Claude Code: /loop, /goal, /batch#

/goal è il comando più simile a Ralph Loop. Dietro le quinte, un modello valutatore (Haiku per impostazione predefinita) controlla a ogni turno se l’obiettivo è stato raggiunto. In caso contrario, l’iterazione successiva riceve un suggerimento su cosa correggere esattamente. In caso affermativo, si ferma. Ho trattato /goal in dettaglio nella guida su come eseguire Claude Code autonomamente durante la notte con /goal, che include scenari pronti all’uso per 14 ore di lavoro.

/batch è un comando raro ma potente. Quando devi apportare la stessa modifica a oltre 100 file (migrazione API, sostituzione di componenti, rinomina), /batch invia ogni file a un subagente nel proprio git worktree. Le modifiche non entrano in conflitto: ogni agente lavora in una copia isolata. Per saperne di più sui subagenti, consulta la guida sui subagenti annidati.

Nella descrizione dell’approccio dell’autore, viene chiamato semplicemente:

Limiti rigidi per /loop e /goal:

• Un’attività viene eseguita finché Claude Code è aperto. Chiudi il terminale e il ciclo si interrompe. Per un ciclo notturno serio, usa un server remoto o un tuo wrapper shell.
• La durata massima di un’attività ricorrente è 7 giorni (poi viene eliminata automaticamente per proteggerti dai cicli dimenticati).
• Fino a 50 attività simultanee in una sessione.

Come avviare il tuo primo ciclo autonomo in 5 minuti#

5 passaggi:

1. Apri il progetto in Claude Code

   Vai alla radice del progetto nel terminale ed esegui claude. Aspetta che Claude legga CLAUDE.md e indicizzi il repository.

2. Definisci un obiettivo e una condizione di arresto

   L’obiettivo è ciò che va fatto. La condizione di arresto indica a Claude come capire che ha finito. Idealmente, è un comando che restituisce 0 o 1. Esempio: «Obiettivo: tutti i 23 test in tests/api/*.test.ts passano. Fermati quando pnpm test restituisce exit 0».

3. Esegui /goal

   Comando:

   /goal Tutti i test in tests/api/*.test.ts devono passare. Esegui pnpm test, leggi gli errori, correggili e riesegui il comando. Fermati quando il codice di uscita = 0. Massimo 20 iterazioni.
   

   Claude avvia il ciclo: esegue i test, rileva un errore, apre il file, lo corregge e li riesegue.

4. Imposta un limite di spesa

   In una scheda sullo sfondo, usa /usage per monitorare l’utilizzo. Imposta un limite di token o di spesa per la giornata, così non consumi tutto il saldo in un solo ciclo. Maggiori dettagli nella guida su come non esaurire i limiti di Claude Code.

5. Continua con le tue attività

   Torna dopo 30 minuti. Se il compito è semplice, vedrai già «DONE, tutti i test passano». Se è più complesso, leggi il report: «interrotto all’iterazione 20, motivo X». Correggi a mano ciò che il ciclo non è riuscito a fare, poi riavvialo.

Schema con verificatore: come Claude controlla il proprio lavoro in un ciclo#

Esistono tre tipi di verificatori:

1. Tecnico (codice di uscita): il più affidabile. pnpm test, npm run lint, tsc --noEmit, playwright test. Restituiscono 0 o 1, senza bisogno di interpretazione. Anche /goal funziona così: utilizza dietro le quinte il modello valutatore Haiku, che controlla a ogni turno se la condizione è stata soddisfatta (fino a 4000 caratteri).

2. Modello valutatore: un secondo modello esamina il risultato del primo e lo valuta secondo una rubrica. È adatto ai compiti privi di un controllo formale («Lo stile di scrittura è buono?» «Il design è in linea con il marchio?»). In Anthropic si chiama Claude Code Review: una modalità in cui un agente revisore separato cerca errori logici, casi limite e problemi di sicurezza nel lavoro dell’agente principale. Secondo i dati interni di Anthropic, individua l’84% dei problemi nelle PR di grandi dimensioni (rispetto al 16% dell’approccio di base).

3. Controllo personalizzato: uno script shell che scrivi tu. «Se i log non contengono la parola ERROR, è fatto». «Se il file output.json esiste ed è analizzabile, è fatto». «Se la pagina /pricing restituisce 200, è fatto».

Ecco un modello di prompt che puoi inserire in CLAUDE.md o in un comando:

Trova 10 motivi per cui questo progetto potrebbe essere andato a rotoli. 
Mettiti nella situazione in cui qualcosa è andato storto. 
Posso ripercorrere questa storia molte volte, 
prima di rilasciarla al pubblico.

L’errore più comune dei principianti è avviare un ciclo senza un verificatore. L’agente gira a vuoto: scrive codice, non lo controlla, crede di aver finito, passa all’iterazione successiva e riscrive ciò che aveva già fatto. Tre ore dopo, è tutto un disastro e il conto è di $200.

La regola migliore: scrivi prima il verificatore, poi avvia il ciclo. Se non riesci a esprimere la condizione di arresto in una riga, il compito non è pronto per essere automatizzato.

Come non spendere migliaia di dollari durante la notte: limiti di spesa e condizioni di arresto#

Tre freni essenziali per qualsiasi ciclo notturno:

1. Limite di iterazioni. --max-iterations 20. Il ciclo non può essere eseguito più di N volte, anche se il verificatore non scatta. Se dopo 20 iterazioni non ha raggiunto la condizione di arresto, il compito è bloccato e richiede l’intervento umano.

2. Limite di token o di spesa. /usage limit 50: non più di $50 al giorno. Quando si avvicina al limite, il ciclo si ferma da solo e invia un avviso. Questo protegge da una situazione fuori controllo.

3. Controllo dei progressi con un contratto esplicito. Il confronto di HEAD qui sotto rileva nuovi commit, non ogni modifica al codice. Usalo solo in un worktree isolato in cui ogni iterazione che cambia codice registra un commit locale prima del confronto. Modifiche utili non registrate non cambiano HEAD e possono sembrare stallo. Conserva anche l’esito del verificatore: un commit prova una modifica registrata, non un miglioramento o il superamento del compito.

Struttura illustrativa di wrapper con tre controlli. Le righe di rendicontazione del costo e invocazione sono esempi specifici del runner, non una procedura CLI verificata: conferma le interfacce della versione installata. Il controllo basato sui commit richiede un checkpoint locale per ogni iterazione che modifica codice. Se il runner lascia modifiche non registrate, fermati per esaminarle senza chiamarle assenza di progressi.

#!/bin/bash
PROMPT="$1"
MAX_ITER=20
MAX_COST_USD=50
COMPLETION="DONE"
PREV_HASH=""
STAGNATION=0

for i in $(seq 1 $MAX_ITER); do
  # Limite di spesa
  CURRENT_COST=$(claude usage --json | jq '.cost_usd')
  if (( $(echo "$CURRENT_COST > $MAX_COST_USD" | bc -l) )); then
    echo "STOP: budget cap $MAX_COST_USD reached"
    break
  fi

  # Esecuzione
  OUTPUT=$(claude code -p "$PROMPT" --auto-accept)

  # Controllo del completamento
  if echo "$OUTPUT" | grep -q "$COMPLETION"; then
    echo "STOP: completion signal"
    break
  fi

  # Solo progressi registrati: ogni iterazione che modifica codice richiede un commit.
  # HEAD non rileva modifiche utili non registrate.
  CURRENT_HASH=$(git rev-parse HEAD 2>/dev/null)
  if [ "$CURRENT_HASH" = "$PREV_HASH" ]; then
    STAGNATION=$((STAGNATION + 1))
    if [ "$STAGNATION" -ge 3 ]; then
      echo "STOP: stagnation 3 iterations"
      break
    fi
  else
    STAGNATION=0
  fi
  PREV_HASH="$CURRENT_HASH"
done

Verifica il controllo prima di estendere lo scheletro: una modifica senza commit è lavoro non registrato; un commit di checkpoint cambia HEAD; solo il verificatore separato dimostra il successo. Tre hash invariati indicano assenza di cambiamenti registrati secondo il contratto, non che tutti i file siano rimasti identici. Puoi poi aggiungere: un avviso Slack quando si ferma, un report automatico via Telegram al mattino, una notifica push quando il budget raggiunge l’80%. Il principio è lo stesso: un ciclo ha bisogno di freni, non solo di acceleratore.

5 scenari di cicli notturni pronti all’uso#

Scenario 1: far passare i test che falliscono

/goal Ci sono 47 test non superati nella directory tests/. Obiettivo: farli passare tutti.
Esegui pnpm test, leggi stderr, apri il file con l’errore, correggilo ed esegui di nuovo pnpm test.
Fermati quando exit 0. Massimo 30 iterazioni.

Scenario 2: refactoring esteso su 200 file

/batch Sostituisci la vecchia API client apiV1 con la nuova apiV2 in tutti i file sotto src/**/*.ts.
Ogni file ha il proprio worktree. Dopo la sostituzione, esegui tsc --noEmit; correggi gli eventuali errori.
Unisci i worktree alla fine.

Scenario 3: monitoraggio notturno della produzione

/loop 30m Ogni 30 minuti, controlla https://your-app.example.com/api/health.
Se non restituisce 200, leggi i log, trova la causa, correggila e ridistribuisci.
Registra ogni iterazione in /tmp/night-monitor.log.

Scenario 4: importare un grande insieme di dati con deduplicazione

/goal Importa il file CSV /tmp/import.csv (12,000 righe) nella tabella clients.
Per ogni riga, verifica se c’è un duplicato tramite email; se non c’è, inseriscila; se ce n’è uno, aggiornala.
Registra i conflitti in /tmp/conflicts.log. Fermati quando è stata elaborata l’ultima riga.

Scenario 5: pipeline per articoli (configurazione tipica)

Per un servizio online o un’agenzia che ha regolarmente bisogno di articoli SEO, lo scenario è questo:

/loop 8h Ogni 8 ore: apri il file delle attività in coda per individuare argomenti con stato 'queued'.
Se è disponibile un argomento, esegui la skill per scrivere una guida.
Pubblica su dev. Cambia lo stato in 'review'. Avvisa la persona responsabile su Telegram.

Cosa fornire a ogni iterazione: CLAUDE.md e il Second Brain come stato#

Tre livelli di “memoria” del progetto trasformano un prompt una tantum in un ciclo controllato:

1. CLAUDE.md: la costituzione del progetto. Che cos’è il prodotto, qual è lo stack, quali sono le regole e cosa non si deve mai fare. Claude legge questo file all’avvio di ogni sessione e a ogni iterazione del ciclo. Senza, Claude deve “riaprire” il progetto ogni volta, consumando il contesto e aumentando il rischio di allucinazioni. Trovi un modello pronto all’uso e 6 regole nella guida CLAUDE.md.

2. Second Brain: una cartella di conoscenze aziendali: prodotto, pubblico, obiettivi, economia, marketing. Non codice: significato. Quando il ciclo scrive un articolo o cerca una risposta per l’assistenza, consulta il Second Brain e risponde nel contesto del progetto, non partendo dal nulla.

3. Context engineering: ciò che fornisci esattamente a Claude in ogni iterazione. Non l’intera cartella del Second Brain, né tutto il repository: solo ciò che è pertinente. Plan Mode è utile: Claude determina quali file servono per il compito e legge solo quelli. Maggiori dettagli nella guida Plan Mode.

Il principio operativo principale che ho dovuto inculcare a forza di errori:

Senza tutti e tre i livelli, il ciclo diventa un ciclo infinito con un conto sempre più alto.

Cosa c’è in ogni sessione? Compiti diversi: un ciclo corregge bug, un altro scrive nuove funzionalità, un terzo esamina le PR del team, un quarto ottimizza le prestazioni e un quinto prepara la documentazione. Non un unico agente generalista. Decine di agenti specializzati, ciascuno con la propria skill, il proprio obiettivo e il proprio verificatore.

Il cambiamento di prospettiva fondamentale:

Per un imprenditore senza programmatori, questo significa qualcosa di concreto. Hai un account Claude da $200/mese e un normale laptop. Puoi avviare 5 cicli in parallelo: assistenza, articoli, metriche, test di un nuovo prodotto e monitoraggio dei concorrenti. Ognuno viene eseguito nella propria scheda di Claude Code. Al mattino, leggi il riepilogo. È già la norma lavorativa nell’estate del 2026.

Quattro errori comuni dei cicli autonomi#

Errore 1: «ciclo di allucinazioni»

L’agente decide di aver finito anche se il verificatore non è scattato. Oppure non c’è proprio alcun verificatore. Tre ore dopo Claude dice: «Tutto fatto!», ma i test falliscono, la pagina non si apre e niente funziona. Hai già speso $80 in iterazioni inutili.

Soluzione: un verificatore rigoroso (il codice di uscita del comando), non un controllo verbale.

Errore 2: «budget esaurito durante la notte»

Senza un limite di spesa, un ciclo diventa una granata senza spoletta.

Soluzione: /usage limit oppure uno script esterno che usa claude usage --json per fermare il ciclo al raggiungimento di una soglia.

Errore 3: «il ciclo ha perso il contesto tra le iterazioni»

Nell’iterazione 1, Claude ha preso una decisione architetturale. Alla 7 l’aveva dimenticata e ha preso la decisione opposta. Dopo 15 iterazioni, il codice è un ammasso.

Soluzione: un livello di stato tramite CLAUDE.md e la cartella Second Brain. Il ciclo scrive ogni decisione architetturale in un file che legge nell’iterazione successiva.

Errore 4: «la condizione di arresto è imprecisa: il ciclo va avanti all’infinito»

/goal "Rendi bella la pagina": cosa significa «bella»? Senza una metrica inequivocabile, il ciclo non si fermerà mai. Continuerà fino a raggiungere il limite di iterazioni o di spesa.

Soluzione: la condizione di arresto deve essere sempre misurabile. Non «bella», ma «Lighthouse Performance ≥ 90, Accessibility ≥ 95». Non «funziona», ma «i test in tests/pricing.test.ts passano».

Quando la loop engineering non serve#

Non sono adatti a un ciclo autonomo:

• Un compito creativo una tantum. Un sito web per un nuovo prodotto, un logo, un memo strategico. Qui un ciclo è eccessivo; è più facile scrivere un prompt e perfezionare il risultato a mano.
• Un compito senza verificatore. Se non riesci a esprimere la condizione di arresto come codice di uscita o segnale inequivocabile, non avviare il ciclo; altrimenti diventerà un rogo senza fine.
• Un compito che richiede una valutazione soggettiva. «Fallo suonare meglio», «migliora la UX perché sia più gradevole»: servono te, non un ciclo.
• Un ambito nuovo e sconosciuto. Se tu stesso non sai come dovrebbe apparire il risultato completato, non eseguire Claude in un ciclo. Prima capiscilo, poi automatizzalo.

E la regola principale che ho imparato dagli errori:

La domanda fondamentale prima di avviare un ciclo è: posso descrivere in una riga come saprò che Claude ha finito? Se sì, il ciclo può essere utile. Se no, definisci prima una condizione verificabile, poi avvialo.

La loop engineering è un livello che si aggiunge a tutto ciò che già sai su Claude Code. Continua a esplorare Ailoot su ailoot.ai.