Claude Code Modes in pratica
Claude Code Modes in pratica
Claude Code può chiederti il permesso a ogni comando, lavorare in sola lettura, approvare in blocco le modifiche ai file oppure delegare i controlli a un classificatore di sicurezza. Questa guida spiega come funzionano le modalità di permesso (plan, acceptEdits, auto, dontAsk, bypassPermissions), come si configurano e come abbinarle al sandbox Bash, con due casi d’uso in JavaScript, pro e contro e il sentiment attuale della community.
Indice della guida Claude Code Modes in pratica:
1. Cosa sono le modalità di Claude Code e perché contano ora
2. Come si attivano e si configurano, passo dopo passo
3. Caso d’uso 1: refactoring di un modulo JavaScript con plan mode
4. Caso d’uso 2: test automatici in autonomia con sandbox e auto mode
5. Configurare la sandboxed Bash tool
6. Pro e contro delle modalità di Claude Code
7. Cosa ne pensano gli sviluppatori: il sentiment attuale
8. Conclusioni: l’AI non si può ignorare, la formazione sì che si può pianificare
1. Cosa sono le modalità di Claude Code e perché contano ora
Pensa alle modalità come alle marce di un’auto: il veicolo è lo stesso, ma decidi quanto controllo cedere. Una permission mode stabilisce quali azioni Claude può compiere in una sessione senza chiederti prima conferma. Sono sei, e la tabella riassume cosa parte senza prompt in ciascuna.
Tabella Claude Code Modes in pratica
| Modalità | Cosa parte senza chiedere | Ideale per |
| default (Manual) | Solo letture | Lavoro sensibile, codice che non conosci |
| acceptEdits | Letture, modifiche ai file e comandi comuni come mkdir, mv, cp | Iterare su codice che revisioni poi con git diff |
| plan | Solo esplorazione: nessuna modifica ai sorgenti finché non approvi il piano | Capire e pianificare prima di toccare il codice |
| auto | Tutto, con controlli di sicurezza in background | Task lunghi, meno interruzioni |
| dontAsk | Letture e strumenti pre-approvati; il resto viene negato | CI e script con allowlist esatta |
| bypassPermissions | Tutto, senza controlli | Solo container e VM isolati |
La novità più rilevante è l’auto mode. Con Claude Code v2.1.283 o successive è la modalità iniziale delle sessioni interattive da terminale e VS Code su tutti i piani e provider, a patto di usare un modello supportato. Prima di questa versione lo era sui piani Pro, Max e Team, dal 14 agosto 2026. In auto mode un secondo modello, il classificatore, esamina le azioni al posto tuo e blocca quelle irreversibili, distruttive o dirette fuori dal tuo ambiente.
Anthropic motiva la scelta con i propri dati: gli utenti approvano il 97% dei prompt di permesso e, in uno studio con 1.053 tester, le persone hanno fermato il 13,6% dei comandi pericolosi contro l’89% del classificatore. Sono numeri dichiarati dal produttore, quindi da leggere con spirito critico: la stessa Anthropic precisa che l’auto mode riduce il rischio ma non lo elimina.
Un punto da chiarire subito, perché genera confusione: le modalità decidono se Claude chiede prima di agire, il sandbox decide cosa può raggiungere un comando una volta partito. Il primo è il portiere, il secondo è la stanza chiusa. Sono livelli complementari e vanno combinati.
2. Come si attivano e si configurano, passo dopo passo
- Installa Claude Code. Il metodo raccomandato è l’installer nativo: curl -fsSL https://claude.ai/install.sh | bash su macOS, Linux e WSL; irm https://claude.ai/install.ps1 | iex da PowerShell su Windows; in alternativa brew install –cask claude-code. Serve un account con accesso a Claude Code: il piano gratuito di Claude.ai non lo include.
- Avvia la sessione. Entra nella cartella del progetto e lancia claude.
- Cambia modalità durante la sessione. Premi Shift+Tab per scorrere le modalità. Da auto il primo tasto porta a default, poi il ciclo prosegue con acceptEdits e plan. Puoi anche anteporre /plan a un singolo prompt. La barra di stato mostra la modalità attiva, per esempio ⏸ plan mode on.
- Scegli la modalità all’avvio con un flag:
claude --permission-mode plan
claude --permission-mode acceptEdits
claude --permission-mode default # alias: manual
- Imposta un default in ~/.claude/settings.json:
{
"permissions": {
"defaultMode": "plan"
}
}
Attenzione: i valori auto e bypassPermissions non vengono applicati se scritti nei file di progetto .claude/settings.json o .claude/settings.local.json, così un repository non può autoconcedersi più autonomia. Mettili nelle impostazioni utente o gestite. dontAsk, invece, non compare mai nel ciclo di Shift+Tab e si imposta solo con il flag.
- Aggiungi regole di permesso sopra le modalità. Le modalità fissano la base; le regole allow, ask e deny la affinano. Le regole deny valgono in ogni modalità, bypassPermissions incluso:
{
"permissions": {
"allow": ["Bash(npm test)"],
"ask": ["Bash(git push *)"],
"deny": ["Bash(curl *)"]
}
}
Nota utile: quando entri in auto mode, le regole allow troppo ampie (come Bash(*) o Bash(python*)) vengono messe da parte, perché farebbero saltare il classificatore. I file non vengono modificati e le regole tornano attive appena cambi modalità.
3. Caso d’uso 1: refactoring di un modulo JavaScript con plan mode
Entriamo nel vivo della guida Claude Code Modes in pratica.
Scenario. Hai un modulo ordini.js in cui la logica dello sconto è copiata in due funzioni. Vuoi ripulirlo senza rompere nulla. Il plan mode funziona come il sopralluogo del geometra prima di abbattere un muro: Claude legge il codice, ragiona e propone, ma non tocca i sorgenti finché non approvi il piano.
Il codice di partenza:
// ordini.js - PRIMA del refactoring
function totaleOrdine(righe) {
let totale = 0;
for (const r of righe) {
let prezzo = r.prezzo * r.quantita;
if (r.categoria === "libri") prezzo = prezzo * 0.9; // sconto 10%
totale += prezzo;
}
return totale;
}
function totaleCarrello(righe) {
let totale = 0;
for (const r of righe) {
let prezzo = r.prezzo * r.quantita;
if (r.categoria === "libri") prezzo = prezzo * 0.9; // logica duplicata
totale += prezzo;
}
return totale + 5; // spedizione
}
module.exports = { totaleOrdine, totaleCarrello };
I passaggi:
- Avvia in plan mode: claude –permission-mode plan.
- Scrivi un prompt con vincoli chiari: «Analizza ordini.js. Proponi un refactoring che elimini la duplicazione del calcolo sconto senza cambiare il comportamento. Non modificare nulla.»
- Leggi il piano. Con Ctrl+G lo apri nel tuo editor e puoi correggerlo prima di procedere.
- Approva scegliendo una delle opzioni proposte: usare l’auto mode, approvare manualmente ogni modifica oppure continuare a pianificare. Per un refactoring conviene l’approvazione manuale delle modifiche.
- A modifiche fatte passa ad acceptEdits con Shift+Tab per iterare velocemente e rivedi tutto con git diff.
Il risultato atteso, con la logica dello sconto in un solo punto:
// ordini.js - DOPO il refactoring
const SCONTO_LIBRI = 0.9; // sconto del 10% sulla categoria "libri"
// Calcola il prezzo di una singola riga d'ordine
function prezzoRiga({ prezzo, quantita, categoria }) {
const base = prezzo * quantita;
return categoria === "libri" ? base * SCONTO_LIBRI : base;
}
// Somma le righe applicando gli sconti
function totaleOrdine(righe) {
return righe.reduce((somma, riga) => somma + prezzoRiga(riga), 0);
}
// Totale del carrello: ordine + spedizione (5 euro di default)
function totaleCarrello(righe, spedizione = 5) {
return totaleOrdine(righe) + spedizione;
}
module.exports = { totaleOrdine, totaleCarrello };
Il vantaggio non è solo estetico: separare l’analisi dall’esecuzione ti dà un punto di controllo umano sul *cosa* prima che parta il *come*. Un dato dello stesso studio Anthropic lo conferma: davanti a un piano gli utenti lo rifiutano nel 39% dei casi, contro il 3% dei singoli prompt di permesso. Il piano è il momento in cui l’attenzione è davvero alta.
4. Caso d’uso 2: test automatici in autonomia con sandbox e auto mode
Proseguiamo la nostra Claude Code Modes in pratica .
Scenario. Dopo il refactoring vuoi che Claude scriva i test, li esegua e corregga finché passano, mentre tu lavori ad altro. Qui i prompt continui sono il problema, ma lasciare un agente libero sul tuo computer non è un’opzione. La soluzione è dare confini all’esecuzione: sandbox per limitare l’accesso, modalità per ridurre le interruzioni.
I passaggi:
- Prepara lo script di test in package.json usando il runner nativo di Node.js:
{
"scripts": { "test": "node --test" }
}
- Attiva il sandbox con /sandbox e scegli auto-allow (dettagli nella sezione 5).
- Scegli come gestire i permessi. Hai due strade: Manual più sandbox in auto-allow, senza classificatore, oppure auto mode, dove il classificatore valuta le azioni. Le due opzioni sono indipendenti e si possono combinare.
- Dai l’incarico: «Scrivi i test per ordini.js in ordini.test.js con node:test, eseguili con npm test e correggi finché passano.»
I test che Claude dovrebbe produrre sono di questo tipo:
// ordini.test.js - test con il runner nativo di Node.js
const test = require("node:test");
const assert = require("node:assert");
const { totaleOrdine, totaleCarrello } = require("./ordini");
test("applica lo sconto del 10% ai libri", () => {
const righe = [{ prezzo: 20, quantita: 2, categoria: "libri" }];
assert.strictEqual(totaleOrdine(righe), 36);
});
test("non scontare le altre categorie", () => {
const righe = [{ prezzo: 10, quantita: 3, categoria: "audio" }];
assert.strictEqual(totaleOrdine(righe), 30);
});
test("aggiunge la spedizione al carrello", () => {
const righe = [{ prezzo: 10, quantita: 1, categoria: "audio" }];
assert.strictEqual(totaleCarrello(righe), 15);
});
Se un comando tenta di raggiungere un dominio non ammesso, in Manual ricevi un prompt per approvare l’host; in auto mode Claude indica sul comando stesso gli host necessari e il classificatore li valuta insieme al comando.
Variante per la pipeline CI
Nella CI nessuno può rispondere ai prompt, quindi serve una allowlist esatta. La modalità dontAsk nega tutto ciò che richiederebbe conferma e lascia passare solo gli strumenti pre-approvati. Il comando seguente è tratto dalla documentazione ufficiale:
claude -p "run the test suite" --permission-mode dontAsk --allowedTools "Bash(npm test)" "Read"
Per esecuzioni totalmente non presidiate esiste anche –dangerously-skip-permissions, ma la documentazione richiede un contenitore, una VM o il sandbox runtime, e su Linux e macOS di non lanciarlo come root.
5. Configurare la sandboxed Bash tool – Claude Code Modes in pratica
Il sandbox Bash è un recinto che il sistema operativo fa rispettare attorno ai comandi shell eseguiti da Claude. Dentro il cortile si muove liberamente, ma non può uscire. I limiti valgono per Bash, PowerShell e Monitor e per i processi che avviano, ed essendo applicati dall’OS reggono anche se il modello sceglie un comando inatteso.
Cosa limita di default
- Scritture: solo la cartella di lavoro, una directory temporanea per utente e le directory che aggiungi tu. I percorsi protetti restano in sola lettura.
- Letture: gran parte della macchina, comprese credenziali come ~/.ssh e ~/.aws/credentials. Va quindi protetta esplicitamente.
- Rete: nessuna uscita diretta. Le connessioni passano da un proxy locale che controlla ogni host rispetto ai domini consentiti, inizialmente vuoti.
- Variabili d’ambiente: ereditate da Claude Code, segreti inclusi.
Requisiti per sistema operativo
Su macOS usa Seatbelt ed è già pronto. Su Linux e WSL2 servono bubblewrap e socat. Su Windows nativo il sandbox non è disponibile e i comandi girano senza isolamento: per usarlo lavora dentro WSL2.
# Ubuntu / Debian
sudo apt-get install bubblewrap socat
# Fedora
sudo dnf install bubblewrap socat
Su Ubuntu 24.04 e successive la policy AppArmor di default può impedire a bubblewrap di creare i namespace utente. Controlla con sysctl kernel.apparmor_restrict_unprivileged_userns: se restituisce 1, la documentazione indica di aggiungere un profilo AppArmor dedicato a bwrap.
I passaggi
- Apri il pannello: in sessione lancia /sandbox. Ha le schede Mode, Overrides e Config. Se compare solo la scheda Dependencies, manca un pacchetto: installalo, riavvia Claude Code e rilancia il comando.
- Scegli la modalità. *Auto-allow* esegue senza prompt i comandi che girano dentro il sandbox; *regular permissions* mantiene i prompt consueti anche per i comandi isolati. Anche in auto-allow le regole deny restano valide e le regole ask su comandi specifici, come Bash(git push *), continuano a chiedere conferma.
- Verifica che funzioni. Chiedi a Claude di eseguire touch ~/sandbox-probe: deve fallire. Poi curl –noproxy ‘*’ https://example.com: deve fallire con host non risolto. I comandi digitati a mano col prefisso ! girano di solito fuori dal sandbox, quindi non testano nulla.
- Rendilo permanente: imposta sandbox.enabled a true in ~/.claude/settings.json. Il pannello /sandbox salva invece la scelta solo nel progetto corrente, in .claude/settings.local.json.
- Affina i confini con le impostazioni qui sotto.
{
"sandbox": {
"enabled": true,
"failIfUnavailable": true,
"allowUnsandboxedCommands": false,
"filesystem": {
"allowWrite": ["~/.kube"]
},
"network": {
"allowedDomains": ["registry.npmjs.org"]
},
"credentials": {
"files": [
{ "path": "~/.ssh", "mode": "deny" },
{ "path": "~/.aws/credentials", "mode": "deny" }
],
"envVars": [
{ "name": "GITHUB_TOKEN", "mode": "deny" }
]
}
}
}
Cosa fanno le chiavi principali: failIfUnavailable fa uscire Claude Code se il sandbox non parte, invece di eseguire senza isolamento (comportamento di default). allowUnsandboxedCommands: false disattiva la via di fuga con cui Claude può riprovare fuori dal sandbox un comando fallito. allowWrite concede scritture a percorsi specifici, ed è preferibile a escludere un intero strumento dal sandbox. Le voci credentials con modalità deny negano la lettura dei file e rimuovono le variabili dall’ambiente dei comandi isolati.
Eccezioni e limiti da conoscere
- `excludedCommands`: i comandi elencati girano fuori dal sandbox, con i tuoi pieni poteri. Serve per strumenti incompatibili, come docker, ma un pattern troppo largo annulla la protezione.
- Cosa non copre: gli strumenti file di Claude (Read, Edit, Write), WebFetch, i server MCP e gli hook girano fuori dal sandbox e seguono le regole di permesso.
- Rete: il proxy decide in base al nome host e di default non ispeziona il traffico TLS. Consentire domini ampi come github.com può aprire strade all’esfiltrazione di dati: elenca solo ciò che serve.
- Compatibilità: jest richiede –no-watchman, docker va escluso, e su macOS git via SSH non funziona nel sandbox (meglio usare HTTPS).
- Organizzazioni: con le impostazioni gestite puoi imporre il sandbox a tutto il team e impedire che i file di un repository allentino i limiti.
La conclusione della documentazione è onesta: il sandbox riduce il rischio ma non è un confine di isolamento completo. Per isolare l’intero processo servono container, VM o dev container.
6. Pro e contro delle modalità di Claude Code – Claude Code Modes in pratica
I vantaggi
- Meno interruzioni, più flusso. Contro la «stanchezza da approvazione», che porta ad approvare tutto per riflesso, auto mode e sandbox lasciano Claude lavorare per ore.
- Controllo graduale. Dal plan mode in sola lettura fino a dontAsk per la CI, scegli il livello giusto per ogni attività.
- Alternativa più sicura al bypass. Il classificatore blocca di default azioni come curl | bash, force push, invio di dati sensibili a endpoint esterni e deploy in produzione.
- Governance aziendale. Gli amministratori possono fissare il default con defaultMode, disattivare l’auto mode con disableAutoMode e bloccare bypassPermissions.
- Difesa a più livelli. Regole di permesso, classificatore e sandbox a livello di sistema operativo si sommano.
Gli svantaggi
- Il rischio non è zero. Anthropic stessa raccomanda di rivedere di persona le modifiche all’infrastruttura di produzione.
- Falsi positivi e dipendenza da un modello. Il classificatore può bloccare azioni legittime. Dopo 3 blocchi consecutivi o 20 totali la sessione torna ai prompt manuali.
- Costi e latenza. Ogni controllo aggiunge un passaggio. Su Enterprise e con API o cloud provider le chiamate del classificatore contano nell’uso di token.
- Requisiti. L’auto mode richiede modelli supportati (con Bedrock, Agent Platform e Foundry solo Sonnet 5 o successivi, Opus 4.7 o successivi e i modelli Fable) e può essere disattivato dall’organizzazione.
- Default permissivi da conoscere. In auto mode i push su qualunque branch del repository, default incluso, e la creazione di PR sono consentiti; nel sandbox la lettura di ~/.ssh è aperta finché non la neghi.
- Complessità. Modalità, regole, sandbox e impostazioni gestite interagiscono tra loro, e le eccezioni (plan mode, file di progetto ignorati per alcuni valori) richiedono di leggere bene la documentazione.
- Copertura del sandbox. Non protegge strumenti file, MCP e hook, e su Windows nativo non è disponibile.
7. Cosa ne pensano gli sviluppatori: il sentiment attuale – Claude Code Modes in pratica
Nota: Il quadro che segue si basa sulle discussioni pubbliche accessibili: issue tracker ufficiale su GitHub, commenti sui social, stampa tecnica e blog di sviluppatori. Per il polso aggiornato di r/ClaudeAI e r/ClaudeCode ti invitiamo a leggere anche i thread più recenti.
Entusiasmo di chi lo usa ogni giorno. Al debutto in research preview, il 24 marzo 2026, la reazione prevalente è stata di sollievo: l’auto mode è stato visto come la via di mezzo tra i prompt continui e –dangerously-skip-permissions. Boris Cherny, responsabile di Claude Code, ha raccontato che il suo team lo usa in via esclusiva da mesi e non tornerebbe indietro, e altri utenti lo descrivono come un cambio di passo nel proprio modo di lavorare. Sono però voci vicine al prodotto, da pesare di conseguenza.
Ironia e pragmatismo sui social. Al lancio c’è stato chi ha scherzato sul passaggio da un «umano nel ciclo» a una «AI nel ciclo», e chi ha ammesso di continuare a tenere tutto in modalità bypass. Segno che per una parte degli sviluppatori l’attrito dei prompt era già un problema da aggirare, non da risolvere.
Scetticismo sul giudice che è anche parte in causa. La critica più netta arriva dalla stampa tecnica. Tom’s Hardware Italia osserva che Anthropic ha costruito il classificatore, condotto lo studio che lo promuove e ora lo rende predefinito, senza un arbitro comune tra i prodotti concorrenti. Per correttezza, Anthropic dichiara di aver coinvolto anche terze parti, come Apollo Research e Trajectory Labs, per i test di red-teaming e prompt injection. Resta il fatto che i numeri più citati provengono dal produttore.
Frizioni pratiche nell’issue tracker. Chi lo usa in produzione segnala problemi concreti: commit con il trailer Co-Authored-By negati dal classificatore, benché sia lo stesso prodotto a suggerirlo; richieste di conferma comparse dopo un aggiornamento su semplici scritture di file; un caso in cui, con il classificatore non disponibile, la sessione non è tornata ai prompt manuali come documentato; un default auto letto ma non applicato. Sono segnalazioni di singoli utenti, alcune probabilmente già risolte nelle versioni successive, ma raccontano la fase di assestamento di una funzione diventata predefinita molto in fretta.
Un limite strutturale sottolineato dalla community. Un test di stress indipendente, riportato da AgentPatterns, indica che la maggior parte dei mancati blocchi riguarda le modifiche ai file dentro il progetto, che per progettazione non passano dal classificatore. È coerente con la documentazione e spiega perché Git, le revisioni dei diff e il sandbox restano indispensabili.
Il sandbox come risposta alla paura. Il tema dell’isolamento è esploso dopo la storia di un utente che, in un post su Reddit di dicembre 2025, raccontava di aver perso l’intero contenuto del proprio Mac per un comando di Claude Code, episodio ricostruito dal blog di Develeap (qui di seconda mano, non verificato direttamente). Da allora il sandbox è visto come la risposta pratica: ridurre l’attrito senza esporre la macchina. Molti ricordano però che per l’isolamento massimo container e macchine virtuali restano più robusti del sandbox integrato.
Lettura d’insieme. Dal materiale consultato emerge un sentiment pragmatico e favorevole alla direzione intrapresa, accompagnato da richieste precise: più trasparenza sul classificatore, più controllo con regole deny e ask, e la consapevolezza che nessuna modalità sostituisce la revisione umana sulle operazioni critiche.
8. Conclusioni: l’AI non si può ignorare, la formazione sì che si può pianificare
Tiriamo le somme sulla Claude Code Modes in pratica.
Le modalità di Claude Code raccontano bene dove sta andando lo sviluppo software: gli agenti lavorano sempre più a lungo e con più autonomia, e il compito degli ingegneri si sposta dal premere «approva» al progettare i confini entro cui un agente può operare. Sapere quando usare plan, quando affidarsi all’auto mode, come scrivere regole deny sensate e come configurare un sandbox non è un dettaglio: è la differenza tra un acceleratore e un rischio.
Per questo l’AI oggi non può essere messa da parte dai team IT. Gli strumenti cambiano ogni settimana, i default si ribaltano in pochi mesi, e l’unico modo per restare aggiornati è seguire una formazione tecnica continua. È quello che facciamo con i Corsi AI Generativa di Innovaformazione.
Tra questi segnaliamo il Corso Claude Code per sviluppatori, rivolto alle aziende:
- Modalità: online, in classe virtuale
- Calendario: da concordare con l’azienda
- Finanziamento: possibilità di finanziare i corsi con Fondimpresa o altri canali dedicati alla formazione dei dipendenti
Vuoi portare Claude Code nel tuo team in modo sicuro e produttivo? Richiedi informazioni e preventivo scrivendo a info@innovaformazione.net oppure chiamando il 3471012275 (Dario Carrassi).
Per altri articoli di settore consigliamo di navigare sul nostro blog al seguente LINK.
Articoli correlati
Claude Code con Arduino
Novità .Net 11
Backdoor nei modelli AI open-weight
Opportunità di lavoro Bari
Spieghiamo il Weight space programming
