Perché gli agenti di coding ignorano le istruzioni
La regola dice di fermarsi, ma l'agente continua? Scopri se non è nel contesto, è vaga, contraddetta o troppo lontana, con una diagnosi pratica.
Perché gli agenti di coding ignorano le tue istruzioni
Gli agenti di coding ignorano le tue istruzioni per quattro motivi, e nessuno di questi dipende dal fatto che tu sia stato troppo cortese. La regola non è mai entrata nella context window. La regola era troppo vaga per verificare un'azione rispetto a essa. Qualcos'altro nella context window la contraddiceva, di solito il codice che l'agente aveva appena letto. Oppure la regola è ancora caricata, ma si trova molto indietro rispetto al turno corrente, e l'agente lavora su ciò che ha più vicino.
Ogni causa richiede una correzione diversa, quindi il primo compito consiste nel distinguerle. Le lettere maiuscole e la parola IMPORTANT non sono una diagnosi. Gli aspetti tecnici descritti di seguito usano Claude Code come esempio pratico, perché il suo comportamento nel caricamento e nella compattazione è documentato in dettaglio a ottobre 2026. Gli altri strumenti differiscono nei dettagli, ma in linea generale si comportano allo stesso modo.
Prima di tutto, due termini. La context window è il blocco di testo che il modello vede in un determinato turno: il system prompt, i file delle istruzioni, la conversazione e ogni file letto dall'agente. L'harness è il programma che circonda il modello, cioè il componente che legge i file dal disco e assembla quel blocco. Quasi ogni lamentela espressa in questo articolo riguarda in realtà l'harness, non il modello.
Il file di istruzioni è un messaggio, non un'impostazione
Un file di istruzioni non è una configurazione. Nulla nel runtime legge CLAUDE.md e la applica. L'harness legge il file dal disco e incolla il testo nella conversazione. In Claude Code, quel contenuto viene fornito come messaggio dell'utente dopo il prompt di sistema. Il modello vede quindi le tue regole nello stesso modo in cui vede qualsiasi altro testo digitato.
Questo ha una conseguenza scomoda. Le tue regole competono con ogni altro testo presente nella finestra, sullo stesso piano. Una regola è un'affermazione. Il file appena aperto dall'agente è un'evidenza. Quando i due elementi sono in conflitto, spesso prevale l'evidenza e non viene generato alcun errore, perché dal punto di vista del modello non è successo nulla di errato.
La documentazione ufficiale lo afferma chiaramente: i file di istruzioni vengono trattati come contesto, non come configurazione applicata. Per bloccare un'azione indipendentemente dalla decisione del modello, serve un hook, non una frase. Tieni presente questo principio. La maggior parte delle correzioni alla fine di questo articolo consiste nell'applicarlo a un caso specifico.
Quali file di istruzioni vengono caricati e quando
Claude Code risale l'albero delle directory partendo da quella in cui lo hai avviato. Tutti i file CLAUDE.md e CLAUDE.local.md compresi tra la radice del filesystem e la directory di lavoro vengono caricati integralmente all'avvio. Vengono concatenati in quest'ordine, quindi il file più vicino alla directory da cui hai avviato Claude Code viene letto per ultimo; all'interno della stessa directory, il file .local viene aggiunto dopo quello principale.
I file nelle sottodirectory al di sotto della directory di lavoro si comportano diversamente. Non vengono caricati all'avvio. Vengono caricati quando l'agente legge un file in quella directory. Lo stesso vale per le regole con ambito limitato al percorso in .claude/rules/ che contengono il campo di frontmatter paths:: entrano nel contesto quando viene letto un file corrispondente, non a ogni turno. Dalla versione v2.1.309, i file caricati in questo modo hanno anche un limite di dimensione per file (40,000 caratteri con una finestra di contesto da 200K) e l'agente riceve soltanto l'inizio dei file più lunghi. Di conseguenza, le regole vicine alla fine di un file annidato di grandi dimensioni potrebbero non entrare mai nel contesto.
Questa differenza spiega gran parte dei problemi segnalati. Inserisci una regola in packages/api/CLAUDE.md, poni una domanda sull'API e l'agente risponde senza mai aprire un file in packages/api/. La regola non è stata ignorata. Non era mai presente. Se il repository distribuisce le indicazioni in file di istruzioni per pacchetto in un monorepo, questo è il primo controllo da eseguire, ogni volta.
Un'altra situazione problematica riguarda il caricamento dei repository che hanno adottato AGENTS.md come standard. Dalla versione v2.1.277, Claude Code legge AGENTS.md come istruzioni del progetto per impostazione predefinita, ma solo quando nella directory di lavoro o in una directory superiore non sono presenti CLAUDE.md, .claude/CLAUDE.md o CLAUDE.local.md (il tuo ~/.claude/CLAUDE.md personale non conta). Aggiungi uno qualsiasi di questi file, anche un CLAUDE.local.md per le note personali, e Claude Code legge invece i tuoi file CLAUDE.md, escludendo completamente AGENTS.md. Per caricarli entrambi, imposta Istruzioni del progetto su claude-md-and-agents-md in /config. Nelle versioni precedenti alla v2.1.277, oppure quando vuoi mantenere un CLAUDE.md, il collegamento consiste in un CLAUDE.md la cui prima riga è @AGENTS.md. Questa riga importa il file all'avvio; sotto puoi aggiungere eventuali note specifiche per Claude. Funziona anche un collegamento simbolico, quando non devi aggiungere altro. Decidere che cosa inserire in quel file è una questione distinta, trattata in separare le istruzioni per l'agente dalla documentazione per gli utenti.
Conferma che il file sia stato caricato prima di riscriverlo
Non modificare il testo finché non hai la certezza che l'agent possa vedere il file. Sono disponibili due controlli; esegui prima quello più rapido.
Esegui /context nella sessione. Mostra la finestra corrente suddivisa per categoria e, nell'elenco Memory files, indica tutti i file di istruzioni caricati all'avvio. Se un file non compare nell'elenco, non è stato caricato all'avvio; di conseguenza, nulla di ciò che scrivi al suo interno può avere effetto finché qualcosa non lo carica. Un file annidato in una sottodirectory non compare nell'elenco perché viene caricato su richiesta; quando viene caricato, nel terminale compare una riga Loaded con il relativo percorso. /memory elenca i percorsi dei file e li apre per la modifica, compresi quelli che non esistono ancora.
Per una verifica più approfondita, registra i caricamenti. L'evento hook InstructionsLoaded viene attivato ogni volta che un CLAUDE.md o un file di regole entra nel contesto. Il relativo matcher indica il motivo del caricamento: session_start, nested_traversal, path_glob_match, include o compact. Inserisci questo contenuto in .claude/settings.json:
{
"hooks": {
"InstructionsLoaded": [
{
"matcher": "nested_traversal",
"hooks": [
{
"type": "command",
"command": "cat >> /tmp/instructions-loaded.log"
}
]
}
]
}
}L'hook riceve il payload come JSON tramite lo standard input; cat aggiunge quindi l'intero record. Monitoralo con tail -f /tmp/instructions-loaded.log mentre lavori. Lo stato di uscita di questo evento viene ignorato, quindi l'hook può soltanto osservare e non bloccare. Se durante una sessione in cui ti aspettavi il caricamento il file annidato non compare mai nel log, interrompi la riscrittura. Il problema è il posizionamento. Fa eccezione un AGENTS.md letto direttamente da Claude Code, che non attiva questo evento: cerca invece il relativo percorso in /memory. Un AGENTS.md importato da un CLAUDE.md attiva l'evento normalmente.
Cosa comporta una sessione lunga per le regole
In questo caso si applicano due effetti distinti, che richiedono risposte diverse.
Distanza. Finché non viene eseguita una compattazione, una regola dichiarata al turno 1 è ancora nella finestra al turno 90, ma deve competere con 90 turni di testo più recente e più specifico rispetto all'attività che stai svolgendo in quel momento. Dopo una compattazione, una regola digitata soltanto nella chat potrebbe non essere più presente nella finestra: la documentazione di Claude Code avverte che le istruzioni delle prime fasi della conversazione possono andare perse. Questo è il secondo effetto descritto di seguito. Non puoi eliminare il fattore distanza tramite la configurazione, ma puoi misurarlo. Esegui la stessa attività in una sessione nuova. Se la regola viene rispettata nella sessione nuova ma non più nel corso di una sessione lunga, la causa è la distanza o la compattazione.
Compattazione. Quando la finestra si riempie, l'harness riepiloga la conversazione fino a quel momento e prosegue a partire dal riepilogo. Il riepilogo conserva ciò che il suo generatore ha ritenuto importante, che non coincide necessariamente con ciò che consideri importante. La documentazione di Claude Code descrive il comportamento per ciascun meccanismo, e le differenze sono significative. La root del progetto CLAUDE.md e le regole senza ambito vengono reinserite dal disco dopo una compattazione. La memoria automatica viene reinserita dal disco. Le regole con frontmatter paths: vengono perse finché non viene letto di nuovo un file corrispondente. I file CLAUDE.md annidati nelle sottodirectory vengono persi finché non viene letto di nuovo un file in quella sottodirectory.
Classifica le istruzioni in base a questa tabella e otterrai direttamente l'ordine di fragilità. Una regola digitata soltanto nella chat è l'elemento più fragile della sessione: persiste solo se il riepilogo l'ha mantenuta. Una regola in packages/api/CLAUDE.md viene subito dopo, perché è stata caricata una volta, poi eliminata dal riepilogo e torna disponibile solo alla lettura successiva in quella directory. Una regola nel file della root del progetto è la più duratura, perché viene riletta dal disco ogni volta.
Quindi, se un'istruzione deve restare valida per l'intera sessione, deve trovarsi nel file della root del progetto, senza frontmatter paths:. Tutto il resto è un compromesso da scegliere consapevolmente. Gestione degli elementi mantenuti nella finestra di contesto descrive /compact con un argomento focus e /clear tra attività non correlate; entrambi modificano la frequenza con cui il generatore del riepilogo può decidere quali fossero le tue regole.
Perché il codice circostante prevale sulla regola
Questo è il problema che viene descritto più spesso e diagnosticato meno spesso. Il file stabilisce che l'accesso al database passa dal repository layer. L'agente scrive un handler che chiama direttamente l'ORM (object relational mapper). Non ha ignorato le tue indicazioni per motivi di stile. Ha seguito le evidenze disponibili.
Una regola descrive una preferenza. Il codice ne dimostra una. Quando l'agente apre tre file del modulo che sta per modificare e tutti e tre chiamano direttamente l'ORM, il contesto contiene una frase astratta da una parte e tre esempi concreti, recenti e pertinenti all'attività dall'altra. Copiare il pattern locale è in genere il comportamento corretto. In questo caso è sbagliato solo perché tu sai qualcosa che il contesto non sa: quei file contengono codice legacy.
Scrivilo quindi nella regola. Le regole che indicano le proprie controevidenze resistono al confronto con un repository reale. Le regole che esprimono soltanto una preferenza non ci riescono.
Il nuovo accesso al database passa daapp/repositories/. I file sottoapp/legacy/chiamano ancora direttamente l'ORM. Si tratta di codice obsoleto, non del pattern da seguire. Non copiarlo.
La seconda frase svolge il lavoro principale. Dice all'agente che cosa troverà e come deve interpretarlo, prima che lo trovi. La stessa correzione si applica a qualsiasi regola che il repository contraddice in modo evidente: uno stile dei commit che la cronologia non segue, una struttura dei test ignorata da metà della suite, una convenzione per gli import applicata solo al nuovo codice. Quando il codice non è coerente con il file, indica la discrepanza nel file.
Una regola vaga non può essere verificata e quindi non può essere applicata
"Scrivi codice pulito." "Non progettare troppo." "Mantieni la semplicità." "Fai attenzione alle migrazioni." Nessuna di queste indicazioni può essere verificata rispetto a un'azione specifica, né dall'agente né da te. Se un agente riceve una regola che non può verificare sul proprio output, procede per tentativi e tu valuti il risultato in base a una sensazione.
Applica questo test a ogni riga del file. Scrivi il comando shell che restituisce un codice diverso da zero quando la regola viene violata. Se non puoi scrivere quel comando, la regola non è verificabile. Confronta queste coppie:
- Non verificabile: "Mantieni le funzioni brevi." Verificabile: "Una funzione più lunga di 60 righe deve avere sopra di sé un commento che spieghi il motivo."
- Non verificabile: "Testa le modifiche." Verificabile: "Esegui
npm teste incolla il numero di errori prima di considerare completata un'attività." - Non verificabile: "Mantieni i file organizzati." Verificabile: "I gestori HTTP si trovano in
src/api/handlers/. Nient'altro deve essere inserito in quella directory." - Non verificabile: "Formatta correttamente il codice." Verificabile: "Usa un'indentazione di 2 spazi nei file
.ts."
"Non progettare troppo" è l'indicazione a cui le persone rinunciano per prima, perché la correzione non consiste in una frase più breve, ma in una frase più lunga: specificare che cosa significa esattamente la modifica minima che risolve il problema fornisce all'agente criteri con cui confrontare il proprio diff.
La dimensione presenta lo stesso problema sotto un'altra forma. Le linee guida di Claude Code raccomandano meno di 200 righe per file di istruzioni e dichiarano esplicitamente che i file più lunghi riducono il livello di applicazione delle istruzioni. Un file di 700 righe non contiene istruzioni più vincolanti. Contiene 700 affermazioni con più possibilità di contraddirsi e viene conteggiato nella finestra a ogni singolo turno, il che si riflette direttamente sull'utilizzo dei token. La strutturazione del file, con ogni regola sotto un'intestazione che il lettore possa scorrere rapidamente, è descritta in scrivere un file di istruzioni che l'agente possa applicare. Meglio ancora, elimina le parti descrittive anziché prescrittive: una panoramica delle directory che indica dove si trovano gestori e modelli è una struttura che l'agente può consultare quando serve tramite una mappa analizzata del repository, invece di mantenerla nella finestra a ogni turno.
Come diagnosticarlo in dieci minuti
Esegui questi comandi nell’ordine indicato. Passare direttamente all’ultimo passaggio è il motivo per cui si finisce con un file lungo di regole scritte in modo perentorio che continua a non funzionare.
- Verifica che il file sia stato caricato. Esegui
/contexte leggi l’elenco Memory files, oppure, per un file annidato, cerca la relativa rigaLoadednel terminale. Se il file non è presente, correggi il percorso e interrompi la procedura. Nessun altro controllo dell’elenco è ancora applicabile. - Riproduci il problema in una nuova sessione. Avvia una nuova sessione e assegna l’attività più semplice che dovrebbe attivare la regola. Se in questa fase funziona ma fallisce in una sessione lunga, il problema riguarda la distanza o la compattazione. Se fallisce anche qui, il problema è nella regola.
- Rimuovi la concorrenza. Richiedi la stessa modifica in una directory il cui codice esistente segue già la regola. Se la conformità migliora, il codice circostante prevaleva sulla tua istruzione.
- Cerca un conflitto. Due file che forniscono indicazioni diverse per lo stesso comportamento costituiscono un errore documentato: il modello può sceglierne uno in modo arbitrario e non ti dirà di averlo fatto.
- Rendi la regola verificabile e ripeti il test. Riscrivi la regola indicando un percorso concreto e una condizione. Un aumento netto della conformità indica che la causa era la formulazione.
Il passaggio 4 richiede un solo comando. Esegui grep su ogni origine delle istruzioni per cercare l’argomento, non soltanto nel file che stavi modificando:
grep -rni "migration" --include="CLAUDE.md" --include="CLAUDE.local.md" --include="AGENTS.md" .
grep -rni "migration" .claude/rules/ ~/.claude/CLAUDE.md ~/.claude/rules/ 2>/dev/nullSe due file contengono indicazioni diverse, hai trovato il problema. Elimina una delle due indicazioni. Non cercare di stabilire una priorità usando formulazioni più categoriche, perché non esiste un motore di priorità a cui fare riferimento. In Claude Code v2.1.283 o versioni successive, /doctor prompt-audit esegue una versione più ampia di questa ricerca nei file delle istruzioni, nelle regole e nelle competenze, quindi segnala le contraddizioni e propone modifiche senza applicarle finché non lo richiedi.
Le correzioni, in ordine di efficacia
Ogni passaggio riportato di seguito ha un'efficacia maggiore del precedente e richiede più lavoro di configurazione. Partite dall'alto quando una regola è semplice da riscrivere. Scendete al passaggio successivo non appena la regola diventa abbastanza importante da rendere inaccettabili le omissioni occasionali.
- Rendete concreta la regola. Indicate un percorso, un comando o una condizione. Aggiungete le prove contrarie che l'agente troverà nel repository, come mostrato in precedenza. Questo non costa nulla e risolve una percentuale sorprendentemente alta dei casi.
- Avvicinatela a ciò che deve governare. Usate un
CLAUDE.mdannidato, una regola con ambito limitato al percorso in.claude/rules/oppure un commento all'inizio del file stesso. In questo modo la regola viene letta insieme al codice a cui si applica. Accettate il compromesso: tutto ciò che viene caricato in questo modo viene rimosso alla successiva compattazione e ritorna alla successiva lettura corrispondente. - Spostate l'applicazione della regola in un hook. La prosa chiede. Un hook decide. Gli hook vengono eseguiti come codice in eventi fissi del ciclo di vita e si applicano indipendentemente dalla conclusione a cui arriva il modello.
- Affidate la regola a uno strumento deterministico ed eliminate la prosa. Formattazione, ordine degli import, lunghezza delle righe, import vietati, formato dei messaggi di commit.
ruff format,prettier --write,eslint, un hookpre-commit. Il formatter è corretto ogni volta e non consuma token. La frase è corretta nella maggior parte dei casi e consuma token a ogni turno.
Ecco il passaggio 3 completo. Supponiamo che l'agente non debba mai modificare i file delle migrazioni. Inserite quanto segue in .claude/settings.json:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/guard-migrations.sh"
}
]
}
]
}
}E quanto segue in .claude/hooks/guard-migrations.sh:
#!/usr/bin/env bash
set -euo pipefail
path=$(jq -r '.tool_input.file_path // empty')
case "$path" in
*/migrations/*)
echo "Files under migrations/ are written by hand. Stop and ask first." >&2
exit 2
;;
esac
exit 0Eseguite chmod +x .claude/hooks/guard-migrations.sh, quindi avviate una nuova sessione e chiedete all'agente di modificare un file in migrations/. La modifica viene rifiutata e il messaggio restituito indica il motivo. Un codice di uscita 2 in PreToolUse blocca la chiamata allo strumento prima dell'esecuzione e il testo su stderr viene passato al modello come messaggio di blocco. ${CLAUDE_PROJECT_DIR} restituisce la directory principale del progetto, quindi l'hook funziona indipendentemente dalla directory in cui si trova l'agente. L'agente non deve accettare la regola, ricordarla o averla ancora nel contesto. La modifica non viene eseguita.
Per un divieto semplice che non contiene logica, permissions.deny nelle impostazioni svolge lo stesso compito senza uno script da mantenere, mentre le modalità di autorizzazione determinano quali operazioni vengono eseguite senza chiedervi conferma. Se un'istruzione deve effettivamente trovarsi a livello del prompt di sistema anziché in un messaggio dell'utente, --append-system-prompt la inserisce in quel punto. Si tratta però di un flag di avvio che deve essere passato di nuovo a ogni nuova sessione; per questo è più adatto agli script che al lavoro interattivo.
Cosa non si può ottenere con le sole istruzioni
Chiarisci quale metà del problema dipende da te. Posizione, formulazione, conflitti tra file e dimensione dei file sono problemi dell'autore, che l'autore deve risolvere. Il resto dipende dal comportamento del modello e una formulazione migliore non lo eliminerà.
Accettare non significa rispettare. Un agente riconosce una regola, te la ripete correttamente e la viola due chiamate agli strumenti dopo. Il riconoscimento non costa nulla e non consente di prevedere il comportamento. Non considerarlo una correzione e non usarlo come test.
Alcune abitudini persistono. Aggiungere commenti, introdurre una gestione degli errori difensiva, scrivere un riepilogo finale, eseguire il comando successivo più ovvio. Questi comportamenti ricompaiono quando una regola li vieta, anche se con una frequenza ridotta e non pari a zero. Puoi misurare la tua frequenza: esegui la stessa attività dieci volte in sessioni nuove e conta le violazioni. Se quel numero deve essere zero, la regola deve uscire dal prompt. Dichiarare conclusa un'attività quando una parte è ancora incompleta ha la stessa origine. La correzione deve essere strutturale, non verbale: la skill unlazy sostituisce la frase con un Depth Tree e con file gate che l'agente deve superare prima di poter dichiarare conclusa l'attività.
La sessione stessa diventa un esempio. Se l'agente ha violato la regola al turno 12 e lo hai lasciato fare, quella violazione ora fa parte del contesto come dimostrazione ed è molto più recente della regola. Correggi una violazione nel momento in cui la rilevi. Una violazione non corretta insegna quel comportamento al resto della sessione.
Un file di istruzioni non è un confine di sicurezza. Modifica il comportamento, ma non lo impone. Tutto ciò per cui un errore ha conseguenze rilevanti, come le credenziali o i comandi distruttivi, deve essere gestito tramite permessi o un hook. Tenere i secret fuori dalla portata di un agente applica lo stesso principio ai dati: non chiedere a un agente di non leggere un file; fai in modo che il file non sia leggibile.
In sintesi: dimostra che il file è stato caricato, rendi la regola verificabile, spostala accanto all'oggetto che governa e, quando la frequenza degli errori resta importante, rimuovila dalla prosa. Una regola che l'agente non può ignorare è una regola che non gli è mai stata affidata.
FAQ
Perché Claude Code ignora il mio CLAUDE.md?
Verificate che il file sia stato caricato prima di concludere che sia stato ignorato. Eseguite /context e controllate l'elenco Memory files; se un file non è presente nell'elenco, non è stato caricato all'avvio. I file di istruzioni vengono forniti come messaggio dell'utente dopo il prompt di sistema e vengono trattati come contesto, non come configurazione applicata in modo vincolante. Non esiste quindi alcuna garanzia di conformità rigorosa. Nella maggior parte dei casi reali, il problema rientra in una di quattro categorie: il file si trova in una sottodirectory che l'agente non ha mai letto, due file contengono istruzioni in conflitto e il modello ne ha scelto uno arbitrariamente, la regola è troppo vaga per verificare un'azione rispetto a essa oppure il codice circostante mostra un comportamento opposto a quello indicato dalla regola.
La modifica del file di istruzioni durante la sessione cambia qualcosa?
Non per la copia già presente nella conversazione. I file situati sopra la directory di lavoro vengono caricati completamente all'avvio, quindi il testo disponibile al modello è quello presente al momento dell'avvio. Per acquisire una modifica, avviate una nuova sessione oppure chiedete all'agente di leggere il file con i normali strumenti di accesso ai file. In questo modo la versione corrente viene inserita nella conversazione come nuovo messaggio. Dopo una compaction, il file nella radice del progetto viene letto nuovamente dal disco, quindi anche la nuova versione viene acquisita in quel momento.
Quale file prevale quando un CLAUDE.md nella radice e uno annidato sono in conflitto?
Nessuno dei due in modo affidabile. I file individuati vengono concatenati nel contesto invece di sovrascriversi a vicenda. L'ordine va dalla radice del filesystem alla directory di lavoro, quindi il file più vicino viene semplicemente letto per ultimo. Non esiste un motore di precedenza che risolva le contraddizioni e la documentazione di Claude Code specifica che le regole contraddittorie possono essere risolte arbitrariamente. Scrivete i file annidati come aggiunte e indicate il percorso a cui si applicano. Eliminate la contraddizione invece di cercare di dare priorità a una regola rispetto all'altra.
Le mie istruzioni sopravvivono a /compact?
Dipende da come sono state caricate. Il file CLAUDE.md nella radice del progetto, le regole senza ambito e la memoria automatica vengono reinseriti dal disco dopo una compaction. Le regole con frontmatter paths: e i file CLAUDE.md annidati nelle sottodirectory vengono persi finché non viene nuovamente letto un file corrispondente. Tutto ciò che avete digitato soltanto nella chat sopravvive solo se il summariser ha deciso di conservarlo. Se una regola deve rimanere valida per l'intera sessione, inseritela nel file nella radice del progetto senza frontmatter paths:.
Quando una regola dovrebbe diventare un hook invece di restare una descrizione testuale?
Quando il controllo è deterministico e il costo di un'omissione è superiore a quello della scrittura di uno script breve. Rientrano in questa categoria le restrizioni sui percorsi dei file, i comandi obbligatori prima di un commit e le chiamate agli strumenti vietate. Un hook PreToolUse che termina con lo stato 2 blocca direttamente la chiamata allo strumento e restituisce al modello il testo di stderr come motivazione. La regola viene quindi applicata indipendentemente dal fatto che sia ancora presente nel contesto. Qualsiasi controllo che un formatter o un linter può eseguire deve essere gestito da quello strumento e rimosso completamente dal file di istruzioni.