Come creare un agente Claude Code che corregge i propri bug in un loop (configurazione completa inclusa)

Claude scrive codice, un test fallisce e ti restituisce l'errore da gestire.

Un agente auto-riparante non fa così: legge il proprio fallimento, corregge la causa e riprova finché non è tutto verde.

Lo configuri una volta e smetti di essere il debugger non pagato del tuo agente.

Ecco la configurazione completa che ti serve 👇

Prima di iniziare, condivido note giornaliere su AI e vibe coding nel mio canale Telegram: https://t.me/zodchixquant🧠

Perché un singolo tentativo non basta

Di default, Claude esegue un compito una volta. Un test fallisce, riporta l'errore e aspetta. Tu lo leggi, lo incolli di nuovo, gli dici di riprovare. Stai facendo il debug, lui sta solo scrivendo.

Un agente auto-riparante ribalta tutto. Legge il proprio fallimento, capisce che tipo di bug è, corregge quella causa e riprova, proprio come farebbe un debugger. Tu intervieni solo quando passa o si blocca davvero.

File 1: il comando fix

Questo è il ciclo che esegui effettivamente. Inseriscilo in .claude/commands/fix.md:

1---
2description: Esegui un compito e auto-ripara finché tutti i test non passano
3argument-hint: <task>
4allowed-tools: Read, Write, Edit, Glob, Grep, Bash
5model: sonnet
6---
7
8Compito: $ARGUMENTS
9
10Ciclo:
111. Implementa il compito.
122. Esegui la suite di test: `npm test` (o pytest, cargo test).
133. Se tutti i test passano: fermati e mostrami il risultato.
144. Se un test fallisce: classifica il tipo di errore, identifica la causa principale,
15   correggi quella causa, poi torna al passo 2.
165. Limite massimo di 5 tentativi. Annuncia il numero del tentativo ogni giro.
17
18L'ordine classifica-poi-correggi è il punto chiave. Diagnosi prima
19della modifica, ogni giro. Mai indebolire un test per farlo passare, correggi il codice.

Tu scrivi /fix aggiungi paginazione all'endpoint degli utenti e l'agente scrive, testa e si ripara fino a quando la suite è verde.

File 2: l'hook di controllo automatico

Il comando funziona su richiesta. L'hook rende automatico il controllo automatico su ogni modifica.

Aggiungi a .claude/settings.json:

1{
2  "hooks": {
3    "PostToolUse": [
4      {
5        "matcher": "Write|Edit",
6        "hooks": [
7          { "type": "command", "command": "npm test --silent 2>&1 | tail -5 || echo 'TEST FALLITI, correggi prima di continuare'" }
8        ]
9      }
10    ]
11  }
12}

Ora ogni volta che Claude modifica un file, i test vengono eseguiti e il risultato torna nella sua vista.

Un fallimento appare immediatamente, così l'agente lo corregge nello stesso flusso invece di andare avanti e accumulare altre modifiche su codice rotto.

File 3: insegnagli a leggere l'errore

Questo è il file che separa un vero debugger da un indovino. La maggior parte degli agenti vede "test fallito" e inizia a modificare a caso.

Un buon agente legge prima il tipo di errore, perché ogni tipo indica una causa diversa. Inseriscilo in CLAUDE.md:

1## Come leggere un fallimento prima di correggerlo
2
3Nomina sempre per primo il tipo di errore. Ognuno significa qualcosa di diverso:
4
5- Errore di asserzione (atteso X, ottenuto Y): la logica è sbagliata.
6  Risali dall'asserzione a dove è stato costruito il valore.
7  Correggi il calcolo, non l'aspettativa del test.
8
9- Errore di tipo / undefined is not a function: un disallineamento di forma.
10  Qualcosa è nullo, o il tipo sbagliato è arrivato a questa riga.
11  Trova da dove proviene quel valore, proteggilo o correggilo lì.
12
13- Timeout / blocco: manca un await, o una promise non si risolve mai.
14  Cerca chiamate asincrone senza await, o una condizione che non cambia mai.
15
16- Import / modulo non trovato: problema di percorso o dipendenza, non di logica.
17  Correggi il percorso o installa, non toccare il codice che lo usa.
18
19- Instabile (a volte passa): stato condiviso o tempismo, mai casuale.
20  Cerca test dipendenti dall'ordine o tempo/rete non simulati.
21
22Regola: dichiara il tipo e la causa principale in una frase ad alta voce
23prima di modificare. Se non riesci a nominare la causa, stai indovinando. Fermati.

Un errore di tipo e un errore di asserzione richiedono mosse opposte: uno è un problema di forma dei dati a monte, l'altro è logica sbagliata nel punto. Classifica prima e l'agente correggerà la cosa giusta.

Salta questo passaggio e l'agente modificherà a caso finché il rosso non scompare, ed è così che ottieni una suite verde ma silenziosamente rotta.

Cosa vedi effettivamente

Tu scrivi una riga:

1/fix il formattatore di date restituisce fusi orari sbagliati

Poi lavora da solo:

1Tentativo 1
2  test eseguiti → FALLITO
3  tipo: asserzione (atteso 5, ottenuto 11)
4  causa: dimensione pagina non applicata alla query
5  corretto il LIMIT clause (clausola LIMIT)
6
7Tentativo 2
8  test eseguiti → FALLITO
9  tipo: errore di tipo (offset is undefined)
10  causa: pagina 1 non invia offset, default sbagliato
11  aggiunto offset = (page-1)*size
12
13Tentativo 3
14  test eseguiti → TUTTI VERDI (7/7)
15
16Risolto in 3 tentativi. Vuoi rivedere il diff?

Non hai mai incollato un errore. Ha letto i suoi fallimenti, ha nominato ogni causa e ha corretto fino a quando la suite è passata.

Errori comuni

Correggere prima di diagnosticare. Il più grande. Un agente che modifica prima di nominare il tipo di errore sta indovinando, e indovinare trasforma il rosso in verde per fortuna, non correggendo. La regola classifica-prima è l'unica difesa.

Trattare tutti gli errori allo stesso modo. Un timeout e un errore di asserzione non hanno nulla in comune, ma un agente senza la guida dei tipi di errore tratta entrambi come "qualcosa non va" e modifica la riga più vicina. Metà delle tue correzioni finiscono nel file sbagliato.

Correggere il sintomo. Avvolgere una chiamata che genera eccezioni in try/catch fa passare il test ma lascia il bug. Il protocollo vieta di silenziare gli errori proprio per questo motivo.

Permettere che indebolisca i test. Un agente autorizzato a modificare i test finirà per cancellare quello fallito per diventare verde. Una suite che passa ma non prova nulla è il risultato peggiore, quindi questa regola è non negoziabile.

Configurazione in 5 minuti

2 minuti: crea .claude/commands/fix.md.

1 minuto: aggiungi l'hook PostToolUse a settings.json.

1 minuto: aggiungi il protocollo di auto-debug a CLAUDE.md.

1 minuto: esegui /fix su un bug noto e guardalo lavorare sulla causa, tentativo dopo tentativo.

Smetti di essere l'umano che inoltra errori. L'agente legge il suo rosso e corregge finché è verde. Non è diventato più intelligente, ha solo smesso di restituirti il problema.

Grazie per aver letto!

Condivido note giornaliere su AI, finanza e vibe coding nel mio canale Telegram: https://t.me/zodchixquant