Un'ora di lavoro come tante in modalità Manual. L'agente legge il progetto, propone una modifica, chiede di eseguire i test, poi un'altra modifica e di nuovo i test. Alla ventesima richiesta preme "Yes" quasi senza guardare. E da qualche parte tra queste richieste passa inosservata una modifica nella cartella legacy/, che nessuno tocca da tempo e che dovrebbe restare così.

Questo articolo spiega come mantenere le richieste di conferma solo nei punti in cui la decisione spetta davvero a Lei. Per questo Claude Code offre le regole di autorizzazione: tre elenchi nel file di impostazioni che indicano cosa l'agente può fare subito, per cosa deve chiedere e cosa non deve fare affatto. Vediamo a cosa servono, come leggerle e come riordinare il file di regole che probabilmente ha già.

Un'unica impostazione per tutto

La modalità di autorizzazione è una manopola per l'intera sessione. Può girarla in una direzione o nell'altra, ma solo in blocco.

Nella rigorosa modalità Manual, l'agente chiede conferma prima di ogni modifica e quasi prima di ogni comando. La richiesta protegge solo finché Lei la legge. Quando diventano troppe, si smette di leggerle e la protezione resta solo sulla carta.

Nella più libera modalità acceptEdits, le modifiche passano senza richieste, così come alcuni comandi sui file, per esempio rm e mv. Per il codice su cui lavora Lei è comodo. Ma la modalità non distingue le cartelle: una modifica in legacy/ passerà in silenzio proprio come in qualsiasi altra parte del progetto.

Può scrivere in CLAUDE.md "non toccare legacy/". L'agente cercherà di rispettarlo, ma è una richiesta al modello, non un divieto. Claude Code verifica le regole di autorizzazione prima di eseguire un'azione, e il testo in CLAUDE.md o nella richiesta non influisce su di esse.

Insomma, azioni diverse hanno costi diversi in caso di errore, ma la modalità risponde sempre allo stesso modo. L'avvio dei test conviene lasciarlo passare senza interromperLa. Una modifica a un modulo di un altro team, invece, è meglio vederla. L'agente non dovrebbe proprio entrare nella cartella congelata. Tre azioni, tre risposte diverse: la modalità da sola non basta.

Tre elenchi

Le regole offrono proprio queste tre possibilità:

  • allow - eseguire senza chiedere. Riduce il rumore: le azioni frequenti e sicure non La interrompono più;
  • ask - chiedere sempre. Mantiene la richiesta nei punti in cui la decisione spetta a Lei, in qualsiasi modalità, anche nella più libera;
  • deny - non eseguire. L'agente riceve un rifiuto e a Lei non viene nemmeno mostrata una richiesta. Vale in qualsiasi modalità.

Le regole si registrano in un file di impostazioni, per esempio .claude/settings.json del progetto. Per il progetto dell'introduzione, potrebbe avere questo aspetto:

{
  "permissions": {
    "allow": [
      "Bash(npm test)"
    ],
    "ask": [
      "Edit(src/partner/**)"
    ],
    "deny": [
      "Edit(legacy/**)",
      "Bash(git push *)"
    ]
  }
}

Qui src/partner/ è un modulo di un altro team, su cui interviene con cautela; legacy/ è una parte congelata del progetto; npm test è un controllo che l'agente avvia una decina di volte per ogni attività. Due asterischi significano "tutto ciò che si trova nella cartella, a qualsiasi livello".

Vediamo ora cosa cambia nella sessione. Le stesse cinque azioni in tre scenari:

AzioneManual senza regoleacceptEdits senza regoleacceptEdits con regole
Modifica nel resto di src/chiede confermasenza richiestasenza richiesta
Modifica in src/partner/chiede confermasenza richiestachiede conferma
Modifica in legacy/chiede confermasenza richiestarifiuta
npm testchiede confermachiede confermasenza richiesta
git pushchiede confermachiede confermarifiuta

Guardi l'ultima colonna. La sessione procede in modalità rapida: il Suo codice si modifica senza interruzioni e i test partono da soli. Resta una sola richiesta, proprio sul punto in cui vuole davvero controllare la modifica. E le due azioni non consentite non dipendono più da quanto è stanco a fine giornata.

È proprio per questo che servono le regole. Non si tratta di dare più autorizzazioni all'agente, ma di distribuirle in base al costo di un errore. Così può lavorare in una modalità più libera senza perdere il controllo nei punti importanti.

Una stessa azione può corrispondere a più regole, perciò Claude Code controlla gli elenchi in un ordine preciso:

Ordine di verifica delle regole. L'azione dell'agente viene confrontata prima con l'elenco deny: se corrisponde, viene rifiutata. Altrimenti si passa ad ask: se corrisponde, viene chiesta conferma in qualsiasi modalità. Poi si controlla allow: se corrisponde, l'azione viene eseguita senza richiesta. Se non corrisponde a nulla, decide la modalità: in Manual l'agente chiede conferma, in acceptEdits la modifica passa automaticamente.Azione dell'agentecomando, modifica, letturaCorrisponde a deny?Corrisponde a ask?Corrisponde a allow?Rifiutol'azione non verrà eseguitaConfermain qualsiasi modalitàSenza richiestaeseguita subitoNessuna corrispondenza: decide la modalitàin Manual l'agente chiede, in acceptEdits la modifica passa da solasìsìsìnonono
Vale la prima corrispondenza, partendo dall'alto

Lo schema si legge dall'alto verso il basso e ogni azione dell'agente lo attraversa da capo. Non appena una regola corrisponde, il controllo finisce: una regola più specifica non ha la precedenza. Se in deny compare Bash(git push *), nessuna regola in allow potrà autorizzare il push. Non si può scavalcare un divieto per sbaglio, ed è un bene.

Vale la pena ricordare a parte il rettangolo in basso. Se un'azione non compare in nessun elenco, non significa che sia "consentita". Decide la modalità: in Manual l'agente chiede conferma, in acceptEdits la modifica passa automaticamente. In altre parole, le regole non sostituiscono la modalità: la precisano nei punti che ha indicato.

Come si legge una regola

Una regola scritta quasi correttamente è peggio di nessuna regola. Senza regola sa che il limite non c'è. Con una regola imprecisa, invece, è convinto che ci sia, ma blocca qualcosa di diverso da ciò che pensa.

Il formato è lo stesso per tutte le regole: il nome dello strumento e, tra parentesi, il dettaglio a cui si applica. Senza parentesi la regola riguarda tutte le chiamate dello strumento: Bash in deny, per esempio, toglie all'agente l'accesso all'intero terminale.

File

Per i file servono due strumenti: Edit per qualsiasi modifica e Read per la lettura. Il percorso si scrive con un pattern, come in .gitignore: un asterisco corrisponde a qualsiasi nome all'interno di una cartella, due asterischi a qualsiasi profondità. Un percorso senza slash iniziale parte dalla cartella in cui è stata avviata la sessione, quindi avvii Claude Code dalla radice del progetto.

Un errore frequente è scrivere Write(legacy/**). L'agente dispone di uno strumento con questo nome, ma per i file Claude Code verifica le regole solo con Edit e Read. Accetterà la regola con Write, ma all'avvio avviserà del problema e poi non la controllerà. Edit, invece, copre tutti i modi integrati per modificare i file, compresa la creazione di nuovi file.

C'è anche una coincidenza utile: un divieto di lettura, per esempio Read(./.env) in deny, impedisce all'agente anche di modificare quel file.

Comandi

La regola Bash(...) confronta il testo del comando. L'asterisco sostituisce qualsiasi testo, spazi compresi. Tre dettagli determinano se la regola corrisponde:

  • senza asterisco, la regola corrisponde a un solo comando, carattere per carattere;
  • l'asterisco si mette dopo il sottocomando. Bash(git log *) consente solo git log con qualsiasi flag, mentre Bash(git *) consente qualsiasi comando git, incluso push;
  • anche lo spazio prima dell'asterisco fa parte della regola: Bash(ls *) non corrisponde a lsof, mentre Bash(ls*) sì.
Come una regola per i comandi corrisponde al testo. Regola Bash(git log *): git log viene confrontato carattere per carattere, mentre l'asterisco copre --oneline main, quindi la regola consente solo git log con qualsiasi flag. Regola Bash(git *): solo git viene confrontato carattere per carattere, mentre l'asterisco copre push origin main, quindi la regola consente qualsiasi comando git, incluso push.Bash(git log *)Bash(git *)solo git log, con qualsiasi flagqualsiasi comando git, incluso pushgit log--oneline maingitpush origin mainprima dell'asterisco: alla letteraal posto dell'asterisco: qualsiasi testo
Il limite della regola è definito dal testo prima dell'asterisco

La parte azzurra viene confrontata con il comando carattere per carattere; l'asterisco copre interamente quella arancione, qualunque cosa contenga. Perciò l'ampiezza della regola dipende da ciò che precede l'asterisco. Nella prima è git log, quindi non consente altro che consultare la cronologia. Nella seconda c'è solo git, e dopo l'asterisco potrebbe esserci push, l'eliminazione di un branch o l'annullamento delle modifiche. Quando legge una regola scritta da altri, cominci da questa domanda: cosa c'è prima dell'asterisco?

RegolaCorrispondeNon corrisponde
Bash(npm test)npm testnpm test --watch
Bash(npm run *)npm run build, npm run lint --fixnpm install
Bash(git log *)git log, git log --onelinegit push
Bash(git *)qualsiasi comando git, incluso git push-
Edit(src/partner/**)modifica di qualsiasi file in src/partner/modifica di src/app.js
Read(./.env)lettura di .env nella radice del progettolettura di .env.example

Claude Code suddivide un comando composto come a && b nelle sue parti. allow lo consente solo se ogni parte corrisponde alla propria autorizzazione. ask e deny si attivano se ne corrisponde anche solo una. Perciò l'autorizzazione per npm test non si trascina dietro npm test && git push.

Esistono regole anche per altri strumenti, per esempio mcp__github__* per tutti gli strumenti di un server MCP oppure WebFetch(domain:example.com) per scaricare pagine da un singolo sito. La logica è la stessa, ma qui non le esamineremo separatamente.

In quale file tenere le regole

Una regola nel file sbagliato può compromettere il lavoro senza che se ne accorga. Se mette un divieto in un file personale, i colleghi non lo avranno e il loro agente entrerà in legacy/ come se nulla fosse. Se invece aggiunge un'autorizzazione utile solo a Lei nel file condiviso, arriverà a chiunque scarichi il progetto.

FileDi chi sono le regoleFinisce in Git
~/.claude/settings.jsonle Sue, in tutti i progetti su questo computerno, si trova nella cartella home
.claude/settings.jsoncondivise con chiunque lavori al progettosì, viene incluso nei commit
.claude/settings.local.jsonle Sue, solo in questo progettono

Oltre a questi tre file, un'organizzazione può distribuire un proprio file di impostazioni, le cui regole non si possono sovrascrivere. Nei progetti didattici, di solito, non succede.

Gli elenchi dei diversi file non entrano in conflitto: si sommano. allow dal Suo file si aggiunge a allow del file condiviso. L'ordine di controllo resta uguale per tutti, e deny in un qualsiasi file prevale su allow in un altro. Da qui una semplice divisione. Metta i limiti del progetto, come legacy/, .env o push, nel file condiviso, così viaggiano insieme al repository. Le comodità legate al Suo modo di lavorare, invece, nel file locale.

Il file condiviso ha una protezione in più. Le sue regole allow entrano in vigore solo dopo che Lei ha dichiarato attendibile la cartella: al primo avvio di Claude Code nel progetto, il programma chiede conferma e mostra cosa il file autorizzerebbe. ask e deny si applicano subito, perché impongono solo dei limiti. Un repository di terzi che autorizza l'intero terminale non ottiene nulla finché Lei non dà il Suo consenso.

Può verificare cosa si applica davvero con due comandi. /permissions mostra tutte le regole e il file di provenienza di ciascuna; dalla stessa schermata può aggiungerle o rimuoverle. Nella riga Setting sources di /status sono elencati i file caricati. Claude Code recepisce le modifiche ai file senza riavvio. Il file di impostazioni deve contenere JSON valido: un commento con // o una virgola dopo l'ultimo elemento lo rende non valido, e Claude Code La avviserà all'avvio.

Il file che si compila da solo

Quando l'agente chiede conferma per un comando e Lei sceglie "Yes, and don't ask again", Claude Code registra una regola allow in .claude/settings.local.json. Se il file non esiste ancora, lo crea e fa in modo che non finisca nei commit. Per le modifiche ai file funziona diversamente: il consenso vale fino alla fine della sessione e non viene registrato nel file.

Analizziamo un vero settings.local.json

Probabilmente ha già questo file, anche se non l'ha scritto Lei. Ogni scelta "non chiedere più" vi aggiunge una riga e, dopo qualche settimana, potrebbe autorizzare l'agente a fare più di quanto immagini. Ecco un blocco reale, accumulato in alcune settimane di lavoro su un progetto Python:

{
  "permissions": {
    "allow": [
      "Bash(python3 *)",
      "Bash(PYTHONIOENCODING=utf-8 python3 *)",
      "Bash(git status *)",
      "Bash(git log *)",
      "Bash(git diff *)",
      "Bash(git show *)",
      "Bash(git branch *)",
      "Bash(git add *)",
      "Bash(git commit *)",
      "Bash(git fetch *)"
    ]
  }
}

Prima di leggere l'analisi, provi a farla da sé. Quali righe manterrebbe, quali restringerebbe e quali eliminerebbe?

Bash(python3 *)
È la riga più ampia del file. Autorizza l'esecuzione di qualsiasi script e di qualsiasi codice tramite python3 -c. E Python sa fare tutto: eliminare file, accedere alla rete, avviare altri programmi. In pratica, permette di eseguire qualsiasi cosa senza chiedere. Conviene restringere la regola allo script per cui è stata creata, per esempio Bash(python3 scripts/build.py *).

Bash(PYTHONIOENCODING=utf-8 python3 *)
Lo stesso comando, con una variabile d'ambiente davanti. La regola allow consente questa forma solo se la variabile appartiene a un breve elenco di variabili considerate sicure. Se non c'è, Bash(python3 *) non copre il comando, l'agente chiederà conferma e il pulsante salverà un'altra regola. Probabilmente è così che è comparsa questa riga. Anche questa va ristretta a uno script specifico.

git status, git log, git diff, git show
Nella forma usuale, questi comandi si limitano a leggere. Claude Code esegue i comandi di sola lettura senza chiedere e senza regole. Le righe non fanno danni, ma aggiungono ben poco. Le tolga e il file sarà più breve e chiaro.

Bash(git branch *)
Sembra innocua: serve a vedere l'elenco dei branch. Ma la regola confronta il testo, e anche git branch -D feature inizia con git branch. Il branch verrebbe eliminato senza chiedere. Meglio rimuovere la riga. Se la richiesta di conferma per l'elenco dei branch comincia a darLe fastidio, autorizzi il comando esatto Bash(git branch), senza asterisco.

git add e git fetch
Il primo aggiunge le modifiche a un futuro commit; il secondo scarica la cronologia aggiornata dal server senza toccare i file di lavoro. Entrambi si possono annullare facilmente, quindi può lasciarli.

Bash(git commit *)
L'agente crea un commit senza chiedere, quindi prima che Lei abbia letto il diff. È proprio qui che serve una conferma: il commit è il momento in cui accetta la modifica. Conviene spostare la riga in ask. Non basta semplicemente eliminarla. In Manual l'agente chiederebbe comunque, ma ask mantiene la richiesta in qualsiasi modalità, anche nella più libera.

Cosa manca nel file
git push. Bene, però dipende solo dal fatto che nessuno ha mai scelto "non chiedere più" su un push. È più sicuro inserire esplicitamente un divieto.

Ecco il risultato dell'analisi:

{
  "permissions": {
    "allow": [
      "Bash(python3 scripts/build.py *)",
      "Bash(PYTHONIOENCODING=utf-8 python3 scripts/build.py *)",
      "Bash(git add *)",
      "Bash(git fetch *)"
    ],
    "ask": [
      "Bash(git commit *)"
    ],
    "deny": [
      "Bash(git push *)"
    ]
  }
}

Da dieci righe siamo scesi a sei, e ognuna fa ciò per cui è stata pensata. Le richieste di conferma non sono quasi aumentate: la build parte da sola e l'agente chiede solo prima del commit. Se il divieto di push riguarda tutto il team, è meglio spostarlo nel file condiviso .claude/settings.json, seguendo la regola della sezione precedente.

Autorizzazione per un intero programma

Regole come Bash(python3 *), Bash(node *), Bash(npm *) o Bash(npx *) sembrano autorizzare un singolo strumento. In realtà consentono qualsiasi codice che lo strumento è in grado di eseguire. Autorizzi uno script o un comando specifico, non l'intero programma.

Cosa non intercetta una regola

L'agente ha ricevuto un rifiuto. Per lui è una normale risposta dello strumento e il lavoro continua. A volte cerca un altro modo per fare la stessa cosa: per questo è importante capire cosa controlla davvero la regola.

La regola Bash(...) confronta il testo del comando, non il programma che verrà avviato. Perciò il divieto intercetta la forma usuale del comando, ma non tutte le varianti:

  • Bash(git push *) in deny non blocca git -C . push. Il comando è lo stesso, ma scritto diversamente;
  • Bash(rm *) non blocca /bin/rm o bash -c 'rm ...';
  • un divieto su Read(...) non impedisce a uno script Python di aprire il file autonomamente.

Questo non significa che debba rinunciare alle regole. Quasi sempre l'agente scrive il comando nella forma usuale, ed è proprio quella che deny intercetta. Ma una regola non è un muro, come dice chiaramente anche la documentazione di Claude Code. Per evitare che l'agente cerchi una scappatoia, spieghi il divieto in CLAUDE.md: "legacy/ è congelata; se l'attività richiede una modifica lì, fermati e chiedi". La regola impone il limite, CLAUDE.md lo spiega: insieme funzionano meglio che separatamente.

Se il limite deve essere davvero solido, esistono altri meccanismi: un hook che controlla ogni comando prima dell'esecuzione e una sandbox che limita l'accesso a livello di sistema. Sono argomenti a parte.

Regole per tutti i giorni

Se dovessimo ridurre tutto a poche abitudini:

  • in deny metta ciò che in questo progetto non è consentito in nessun caso: una cartella congelata, .env, push;
  • in ask metta solo i casi limite, in cui la decisione spetta a Lei. Se usa ask per tutto, tornerà a stancarsi delle continue richieste;
  • in allow metta regole circoscritte per ciò che si ripete: un controllo specifico, uno script specifico;
  • metta i limiti del progetto in .claude/settings.json, condiviso, e le comodità personali in .claude/settings.local.json;
  • ogni tanto apra /permissions e rimuova ciò che si è accumulato con il pulsante "non chiedere più";
  • dopo aver aggiunto una regola, la verifichi: chieda all'agente di fare qualcosa di vietato e si assicuri che arrivi un rifiuto.
Può chiedere all'agente di proporre le regole

Descriva all'agente le diverse aree del progetto: cosa si può modificare liberamente, cosa richiede conferma e dove non deve entrare. Gli chieda di proporre un blocco permissions e, prima di salvarlo, legga il JSON ponendosi le stesse domande dell'analisi qui sopra. La regola è più ampia del necessario? Finirà nel file giusto?

La modalità definisce il ritmo generale del lavoro, le regole stabiliscono dove rallentare. Insieme fanno ciò che nessuna modalità può fare da sola: velocizzano il lavoro quando un errore costa poco e chiedono conferma o rifiutano quando il costo è alto.