> ## Documentation Index > Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt > Use this file to discover all available pages before exploring further. # Scegli una modalità di autorizzazione > Controlla se Claude chiede prima di modificare i file o eseguire comandi. Cicla le modalità con Shift+Tab nella CLI o utilizza il selettore di modalità in VS Code, Desktop e claude.ai. Quando Claude vuole modificare un file, eseguire un comando shell o effettuare una richiesta di rete, si ferma e ti chiede di approvare l'azione. Le modalità di autorizzazione controllano con quale frequenza questa pausa si verifica. La modalità che scegli modella il flusso di una sessione: la modalità predefinita ti consente di revisionare ogni azione mentre arriva, mentre le modalità più permissive consentono a Claude di lavorare in lunghi tratti ininterrotti e riferire quando ha finito. Scegli una maggiore supervisione per il lavoro sensibile, o meno interruzioni quando ti fidi della direzione.

Modalità disponibili

Ogni modalità fa un diverso compromesso tra comodità e supervisione. La tabella seguente mostra cosa Claude può fare senza un prompt di autorizzazione in ogni modalità. | Modalità | Cosa viene eseguito senza chiedere | Migliore per | | :------------------------------------------------------------------ | :------------------------------------------------------------------------------------------ | :------------------------------------------------- | | `default` | Solo letture | Iniziare, lavoro sensibile | | [`acceptEdits`](#auto-approve-file-edits-with-acceptedits-mode) | Letture, modifiche ai file e comandi filesystem comuni (`mkdir`, `touch`, `mv`, `cp`, ecc.) | Iterare su codice che stai revisionando | | [`plan`](#analyze-before-you-edit-with-plan-mode) | Solo letture | Esplorare una codebase prima di modificarla | | [`auto`](#eliminate-prompts-with-auto-mode) | Tutto, con controlli di sicurezza in background | Compiti lunghi, ridurre l'affaticamento dei prompt | | [`dontAsk`](#allow-only-pre-approved-tools-with-dontask-mode) | Solo strumenti pre-approvati | CI bloccato e script | | [`bypassPermissions`](#skip-all-checks-with-bypasspermissions-mode) | Tutto | Solo container e VM isolati | In ogni modalità tranne `bypassPermissions`, le scritture su [percorsi protetti](#protected-paths) non vengono mai auto-approvate, proteggendo lo stato del repository e la configurazione di Claude da corruzione accidentale. Le modalità impostano la linea di base. Stratificate [regole di autorizzazione](/it/permissions#manage-permissions) sopra per pre-approvare o bloccare strumenti specifici. Le regole di negazione e le regole di richiesta esplicita si applicano in ogni modalità, inclusa `bypassPermissions`. Le regole di autorizzazione non hanno effetto in quella modalità perché tutto il resto è già approvato.

Cambia modalità di autorizzazione

Puoi cambiare modalità durante una sessione, all'avvio o come impostazione predefinita persistente. La modalità viene impostata attraverso questi controlli, non chiedendo a Claude in chat. Seleziona la tua interfaccia di seguito per vedere come cambiarla. **Durante una sessione**: premi `Shift+Tab` per cicla `default` → `acceptEdits` → `plan`. La modalità corrente appare nella barra di stato. Non ogni modalità è nel ciclo predefinito: * `auto`: appare quando il tuo account soddisfa i [requisiti della modalità auto](#eliminate-prompts-with-auto-mode); il ciclo verso auto commuta le modalità senza un prompt di conferma * `bypassPermissions`: appare dopo che hai avviato con `--permission-mode bypassPermissions`, `--dangerously-skip-permissions`, o `--allow-dangerously-skip-permissions`; la variante `--allow-` aggiunge la modalità al ciclo senza attivarla * `dontAsk`: non appare mai nel ciclo; impostala con `--permission-mode dontAsk` Le modalità opzionali abilitate si inseriscono dopo `plan`, con `bypassPermissions` per primo e `auto` per ultimo. Se hai entrambi abilitati, ciclerai attraverso `bypassPermissions` sulla strada verso `auto`. **All'avvio**: passa la modalità come flag. ```bash theme={null} claude --permission-mode plan ``` **Come impostazione predefinita**: imposta `defaultMode` in [settings](/it/settings#settings-files). ```json theme={null} { "permissions": { "defaultMode": "acceptEdits" } } ``` Lo stesso flag `--permission-mode` funziona con `-p` per [esecuzioni non interattive](/it/headless). **Durante una sessione**: fai clic sull'indicatore di modalità in fondo alla casella del prompt. **Come impostazione predefinita**: imposta `claudeCode.initialPermissionMode` nelle impostazioni di VS Code, o utilizza il pannello delle impostazioni dell'estensione Claude Code. L'indicatore di modalità mostra queste etichette, mappate alla modalità a cui ognuna si applica: | Etichetta UI | Modalità | | :----------------- | :------------------ | | Ask before edits | `default` | | Edit automatically | `acceptEdits` | | Plan mode | `plan` | | Auto mode | `auto` | | Bypass permissions | `bypassPermissions` | Auto mode appare nell'indicatore di modalità quando il tuo account soddisfa ogni requisito elencato nella [sezione della modalità auto](#eliminate-prompts-with-auto-mode). L'impostazione `claudeCode.initialPermissionMode` non accetta `auto`. Per avviare in modalità auto per impostazione predefinita, imposta `defaultMode` nelle tue [impostazioni utente](/it/settings#settings-files) invece. Claude Code ignora `defaultMode: "auto"` nelle impostazioni di progetto e locali. Bypass permissions richiede l'interruttore **Allow dangerously skip permissions** nelle impostazioni dell'estensione prima che appaia nell'indicatore di modalità. Vedi la [guida di VS Code](/it/vs-code) per i dettagli specifici dell'estensione. Il plugin JetBrains esegue Claude Code nel terminale IDE, quindi il cambio di modalità funziona come nella CLI: premi `Shift+Tab` per cicla, o passa `--permission-mode` quando avvii. Utilizza il selettore di modalità accanto al pulsante di invio. Auto e Bypass permissions appaiono solo dopo che li hai abilitati nelle impostazioni di Desktop. Vedi la [guida di Desktop](/it/desktop#choose-a-permission-mode). Utilizza il menu a discesa della modalità accanto alla casella del prompt su [claude.ai/code](https://claude.ai/code) o nell'app mobile. I prompt di autorizzazione appaiono in claude.ai per l'approvazione. Quali modalità appaiono dipende da dove viene eseguita la sessione: * **Sessioni cloud** su [Claude Code sul web](/it/claude-code-on-the-web): Accept edits, Plan mode e Auto mode. Accept edits corrisponde alla modalità `default`: l'ambiente cloud pre-approva le modifiche ai file indipendentemente dalla modalità, quindi il menu a discesa mostra Accept edits invece di Ask permissions. `defaultMode: "acceptEdits"` dalle impostazioni è ancora rispettato. Auto mode appare solo quando la tua organizzazione lo consente e il modello selezionato lo supporta. Bypass permissions non è disponibile. * **Sessioni [Remote Control](/it/remote-control)** sulla tua macchina locale: Ask permissions, Auto accept edits e Plan mode. Auto e Bypass permissions non sono disponibili. Per Remote Control, puoi anche impostare la modalità di avvio quando avvii l'host: ```bash theme={null} claude remote-control --permission-mode acceptEdits ```

Auto-approva le modifiche ai file con la modalità acceptEdits

La modalità `acceptEdits` consente a Claude di creare e modificare file nella tua directory di lavoro senza chiedere conferma. La barra di stato mostra `⏵⏵ accept edits on` mentre questa modalità è attiva. Oltre alle modifiche ai file, la modalità `acceptEdits` auto-approva i comandi Bash filesystem comuni: `mkdir`, `touch`, `rm`, `rmdir`, `mv`, `cp` e `sed`. Questi comandi vengono anche auto-approvati quando prefissati con variabili di ambiente sicure come `LANG=C` o `NO_COLOR=1`, o wrapper di processo come `timeout`, `nice` o `nohup`. Come le modifiche ai file, l'auto-approvazione si applica solo ai percorsi all'interno della tua directory di lavoro o `additionalDirectories`. I percorsi al di fuori di tale ambito, le scritture su [percorsi protetti](#protected-paths) e tutti gli altri comandi Bash richiedono ancora conferma. Quando lo [strumento PowerShell](/it/tools-reference#powershell-tool) è abilitato, la modalità `acceptEdits` auto-approva anche `Set-Content`, `Add-Content`, `Clear-Content` e `Remove-Item` su percorsi nell'ambito, insieme ai loro alias comuni. Le stesse regole di ambito e percorsi protetti si applicano. Utilizza `acceptEdits` quando vuoi revisionare le modifiche nel tuo editor o tramite `git diff` dopo il fatto piuttosto che approvare ogni modifica inline. Premi `Shift+Tab` una volta dalla modalità predefinita per entrarvi, o avvia direttamente con essa: ```bash theme={null} claude --permission-mode acceptEdits ```

Analizza prima di modificare con plan mode

Plan mode dice a Claude di ricercare e proporre modifiche senza farle. Claude legge file, esegue comandi shell per esplorare e scrive un piano, ma non modifica il tuo codice sorgente. I prompt di autorizzazione si applicano ancora come nella modalità predefinita. Entra in plan mode premendo `Shift+Tab` o prefissando un singolo prompt con `/plan`. Puoi anche avviare in plan mode dalla CLI: ```bash theme={null} claude --permission-mode plan ``` Premi `Shift+Tab` di nuovo per uscire da plan mode senza approvare un piano.

Rivedi e approva un piano

Quando il piano è pronto, Claude lo presenta e ti chiede come procedere. Da quel prompt puoi: * Approvare e avviare in modalità auto * Approvare e accettare le modifiche * Approvare e revisionare manualmente ogni modifica * Continuare a pianificare con feedback * Perfezionare con [Ultraplan](/it/ultraplan) per la revisione basata su browser Approvare un piano esce da plan mode e cambia la sessione alla modalità di autorizzazione che ogni opzione di approvazione descrive, quindi Claude inizia a modificare. Per pianificare di nuovo, torna a plan mode con `Shift+Tab`, o prefissa il tuo prossimo prompt con `/plan`. Premi `Ctrl+G` per aprire il piano proposto nel tuo editor di testo predefinito e modificarlo direttamente prima che Claude proceda. Quando [`showClearContextOnPlanAccept`](/it/settings#available-settings) è abilitato, ogni opzione di approvazione offre anche di cancellare il contesto di pianificazione per primo. Accettare un piano nomina anche la sessione automaticamente dal contenuto del piano, a meno che tu non abbia già impostato un nome con `--name` o `/rename`.

Imposta plan mode come predefinito

Per rendere plan mode il predefinito per un progetto, imposta `defaultMode` in `.claude/settings.json`: ```json theme={null} { "permissions": { "defaultMode": "plan" } } ```

Elimina i prompt di autorizzazione con auto mode

Auto mode richiede Claude Code v2.1.83 o successivo. Auto mode consente a Claude di eseguire senza prompt di autorizzazione di routine. Un modello classificatore separato esamina le azioni prima che vengano eseguite, bloccando qualsiasi cosa che si escalation oltre la tua richiesta, mira a infrastruttura non riconosciuta o sembra guidata da contenuto ostile che Claude ha letto. Le [regole di richiesta](/it/permissions#manage-permissions) esplicite forzano comunque un prompt. Auto mode inoltre istruisce Claude a continuare a lavorare senza fermarsi per domande di chiarimento, anche se Claude chiede ancora quando il tuo prompt o una skill si affida esplicitamente a questo. Per un comportamento autonomo più forte mantenendo i prompt di autorizzazione, imposta lo [stile di output proattivo](/it/output-styles) invece. Auto mode è un'anteprima di ricerca. Riduce i prompt di autorizzazione ma non garantisce la sicurezza. Usalo per compiti in cui ti fidi della direzione generale, non come sostituto della revisione su operazioni sensibili. Auto mode è disponibile solo quando il tuo account soddisfa tutti questi requisiti: * **Piano**: Tutti i piani. * **Owner**: su Team ed Enterprise, un Owner deve abilitarlo nelle [impostazioni di amministrazione di Claude Code](https://claude.ai/admin-settings/claude-code) prima che gli utenti possano attivarlo. Gli amministratori possono anche bloccarlo impostando `permissions.disableAutoMode` su `"disable"` nelle [impostazioni gestite](/it/permissions#managed-settings). * **Modello**: sull'API Anthropic, Claude Opus 4.6 o successivo, o Sonnet 4.6 o successivo. Su Amazon Bedrock, Google Cloud Vertex AI, Microsoft Foundry e sessioni [gateway app Claude](/it/claude-apps-gateway) con accesso, solo Claude Sonnet 5, Opus 4.7 e Opus 4.8. I modelli più vecchi, inclusi Sonnet 4.5, Opus 4.5, Haiku e modelli claude-3, non sono supportati su nessun provider. * **Provider**: disponibile per impostazione predefinita sull'API Anthropic. Su Amazon Bedrock, Google Cloud Vertex AI, Microsoft Foundry e sessioni gateway app Claude con accesso, auto mode è disattivato fino a quando non [imposti `CLAUDE_CODE_ENABLE_AUTO_MODE`](#enable-auto-mode-on-bedrock-vertex-ai-or-foundry). Se Claude Code segnala auto mode come non disponibile, uno di questi requisiti non è soddisfatto; questo non è un'interruzione transitoria. Un messaggio separato che nomina un modello e dice che auto mode "non può determinare la sicurezza" di un'azione è un'interruzione transitoria del classificatore; vedi il [riferimento degli errori](/it/errors#auto-mode-cannot-determine-the-safety-of-an-action). Se imposti `defaultMode: "auto"` nelle [impostazioni](/it/settings#available-settings) e la sessione inizia in modalità `default` senza errore, l'impostazione è probabilmente in `.claude/settings.json` o `.claude/settings.local.json`. Claude Code v2.1.142 e successivo ignorano `auto` da questi file quindi un repository non può concedere a se stesso auto mode. Spostalo in `~/.claude/settings.json`.

Abilita auto mode su Bedrock, Vertex AI o Foundry

Su [Amazon Bedrock](/it/amazon-bedrock), [Google Cloud Vertex AI](/it/google-vertex-ai), [Microsoft Foundry](/it/microsoft-foundry) e sessioni [gateway app Claude](/it/claude-apps-gateway) con accesso, auto mode non appare nel ciclo `Shift+Tab` fino a quando `CLAUDE_CODE_ENABLE_AUTO_MODE` non è impostato su `1`. La variabile funziona in Claude Code v2.1.158 e successivo. Solo Claude Sonnet 5, Opus 4.7 e Opus 4.8 sono supportati su questi provider. Per abilitarlo per uno sviluppatore, aggiungi la variabile al blocco `env` in `~/.claude/settings.json`: ```json theme={null} { "env": { "CLAUDE_CODE_ENABLE_AUTO_MODE": "1" } } ``` Per abilitarlo per la tua organizzazione, aggiungi lo stesso blocco `env` alle [impostazioni gestite](/it/settings#settings-files). Una volta impostata la variabile, auto mode appare nel ciclo `Shift+Tab` per ogni sessione. Per renderlo la modalità di avvio predefinita, imposta anche `"permissions": {"defaultMode": "auto"}` nelle impostazioni utente o gestite. Su questi provider, Claude Code ignora `defaultMode: "auto"` a meno che `CLAUDE_CODE_ENABLE_AUTO_MODE` non sia anche impostato. Per impedire agli sviluppatori di abilitare auto mode, imposta `disableAutoMode` su `"disable"` nelle impostazioni gestite. Questo sostituisce la variabile di abilitazione. Se ti connetti attraverso un [gateway LLM](/it/llm-gateway) configurato con `ANTHROPIC_BASE_URL`, auto mode potrebbe essere già raggiungibile senza la variabile di abilitazione, perché il gateway instrada le richieste attraverso l'API Anthropic. Questo non si applica a una sessione [gateway app Claude](/it/claude-apps-gateway) con accesso, che è la sua stessa classe di provider e richiede la variabile di abilitazione. L'impostazione `disableAutoMode` si applica allo stesso modo in entrambe le configurazioni.

Cosa blocca il classificatore per impostazione predefinita

Il classificatore si fida della tua directory di lavoro e dei remoti configurati del tuo repo. Tutto il resto è trattato come esterno fino a quando non [configuri l'infrastruttura attendibile](/it/auto-mode-config). **Bloccato per impostazione predefinita**: * Scaricare ed eseguire codice, come `curl | bash` * Inviare dati sensibili a endpoint esterni * Deploy e migrazioni di produzione * Eliminazione di massa su cloud storage * Concessione di autorizzazioni IAM o repo * Modifica dell'infrastruttura condivisa * Distruzione irreversibile di file che esistevano prima della sessione * Force push o push diretto a `main` * {/* min-version: 2.1.182 */}`git reset --hard`, `git checkout -- .`, `git restore .`, `git clean -fd`, `git stash drop`, o `git stash clear`, che il classificatore presume scarterebbero le modifiche non sottoposte a commit * `git commit --amend` quando il commit in HEAD non è stato creato in questa sessione * `terraform destroy`, `pulumi destroy`, `cdk destroy`, o `terragrunt destroy`, e applicare un piano che distrugge risorse Claude Code v2.1.195 e successivo bloccano più categorie per impostazione predefinita. Diversi dipendono da voci di [ambiente](/it/auto-mode-config#define-trusted-infrastructure), come target remoti sensibili e ambiti IaC protetti, che puoi restringere a nomi concreti. * Scrittura in un gestore di segreti, o modifica di record DNS o certificati TLS * Unione di una pull request che nessun umano ha approvato, approvazione della propria pull request di Claude, o disabilitazione dei controlli CI * Pubblicazione di un commento che è esso stesso un comando per l'automazione, come `atlantis apply` o il `/deploy` o `/merge` di un bot * Attivazione, ramping o eliminazione di un feature flag di produzione * Applicazione di modifiche all'infrastruttura a un ambito IaC protetto, o drenaggio e rimozione di nodi del cluster * Scritture in un cluster di calcolo condiviso che vanno oltre la risorsa che hai nominato, come un selettore di etichette o `--all` che cattura i lavori di altri utenti * Creazione di risorse Kubernetes che vengono eseguite su ogni nodo o intercettano il traffico del cluster, come DaemonSets e webhook di ammissione * Shell interattive o port-forward in un target remoto sensibile * Apertura di un tunnel o reverse shell che rende un servizio locale raggiungibile da internet pubblico * Stampa di una credenziale o token live nella trascrizione o in un file * Accesso a una posizione PII o dati regolamentati, o copia di dati da una * Instradamento di un'installazione di pacchetto intorno al tuo registro di pacchetti interno a un registro pubblico * Esecuzione di un comando con un flag che disarma una guardia di sicurezza, come `--insecure` * Azioni del browser [Claude in Chrome](/it/chrome) che potrebbero inviare contenuto della pagina, cookie o credenziali off-origin **Consentito per impostazione predefinita**: * Operazioni su file locali nella tua directory di lavoro * Installazione di dipendenze dichiarate nei tuoi file di blocco o manifesti * Lettura di `.env` e invio di credenziali al loro API corrispondente * Richieste HTTP di sola lettura * Push al ramo su cui hai iniziato o uno che Claude ha creato Claude Code v2.1.195 e successivo consentono anche questi per impostazione predefinita: * Eliminazione dei lavori esatti che Claude ha creato in precedenza nella stessa sessione * Lettura, revisione o scrittura di codice, configurazioni e modelli di minaccia relativi alla sicurezza come parte del tuo compito * Messaggi tra agenti che lavorano insieme nella stessa sessione multi-agente * Invio di dati ai domini attendibili, bucket e servizi che elenchi in [`environment`](/it/auto-mode-config#define-trusted-infrastructure). Questo copre solo il flusso di dati, non operazioni distruttive o di credenziali sulla stessa infrastruttura * Navigazione [Claude in Chrome](/it/chrome) a un dominio interno attendibile, localhost, o un URL che hai nominato Le richieste di accesso alla rete sandbox vengono instradate attraverso il classificatore piuttosto che essere consentite per impostazione predefinita. Esegui `claude auto-mode defaults` per vedere gli elenchi di regole completi. Se le azioni di routine vengono bloccate, un amministratore può aggiungere repo attendibili, bucket e servizi tramite l'impostazione `autoMode.environment`: vedi [Configura auto mode](/it/auto-mode-config).

Confini che dichiari nella conversazione

Il classificatore tratta i confini che dichiari nella conversazione come un segnale di blocco. Se dici a Claude "non fare il push" o "aspetta che io riveda prima di fare il deploy", il classificatore blocca le azioni corrispondenti anche quando le regole predefinite le consentirebbero. Un confine rimane in vigore fino a quando non lo sollevi in un messaggio successivo. Il giudizio di Claude che una condizione è stata soddisfatta non lo solleva. I confini non vengono archiviati come regole. Il classificatore li rilegge dalla trascrizione ad ogni controllo, quindi un confine può andare perso se la [compattazione del contesto](/it/costs#reduce-token-usage) rimuove il messaggio che lo ha dichiarato. Per una garanzia assoluta, aggiungi una [regola di negazione](/it/permissions#permission-rule-syntax).

Quando auto mode ritorna indietro

Ogni azione negata mostra una notifica e appare in `/permissions` sotto la scheda Recently denied, dove puoi premere `r` per ritentarla con un'approvazione manuale. Se il classificatore blocca un'azione 3 volte di fila o 20 volte totali, auto mode si mette in pausa e Claude Code riprende a richiedere. Approvare l'azione richiesta riprende auto mode. Queste soglie non sono configurabili. Qualsiasi azione consentita ripristina il contatore consecutivo, mentre il contatore totale persiste per la sessione e si ripristina solo quando il suo limite attiva un fallback. In [modalità non interattiva](/it/headless) con il flag `-p`, i blocchi ripetuti interrompono la sessione poiché non c'è un utente a cui richiedere. I blocchi ripetuti di solito significano che il classificatore manca di contesto sulla tua infrastruttura. Utilizza `/feedback` per segnalare falsi positivi, o fai in modo che un amministratore [configuri l'infrastruttura attendibile](/it/auto-mode-config). Ogni azione passa attraverso un ordine di decisione fisso. Il primo step corrispondente vince: 1. Le azioni che corrispondono alle tue [regole allow o deny](/it/permissions#manage-permissions) si risolvono immediatamente, ad eccezione delle scritture su [percorsi protetti](#protected-paths), che vengono instradate al classificatore anche quando una regola allow corrisponde 2. Le azioni di sola lettura e le modifiche ai file nella tua directory di lavoro vengono auto-approvate, ad eccezione delle scritture su [percorsi protetti](#protected-paths) 3. Tutto il resto va al classificatore 4. Se il classificatore blocca, Claude riceve il motivo e tenta un'alternativa All'ingresso in auto mode, le regole allow ampie che concedono l'esecuzione arbitraria di codice vengono eliminate: * Blanket `Bash(*)` o `PowerShell(*)` * Interpreti con wildcard come `Bash(python*)` * Comandi di esecuzione del gestore di pacchetti * Regole `Agent` allow Le regole strette come `Bash(npm test)` vengono trasferite. Le regole eliminate vengono ripristinate quando esci da auto mode. Il classificatore vede messaggi utente, chiamate di strumenti e il tuo contenuto CLAUDE.md. I risultati degli strumenti vengono rimossi, quindi il contenuto ostile in un file o pagina web non può manipolarlo direttamente. Una sonda lato server separata scansiona i risultati degli strumenti in arrivo e contrassegna il contenuto sospetto prima che Claude lo legga. Per ulteriori informazioni su come questi livelli lavorano insieme, vedi l'[annuncio di auto mode](https://claude.com/blog/auto-mode) e il [deep dive tecnico](https://www.anthropic.com/engineering/claude-code-auto-mode). Il classificatore controlla il lavoro dei [subagent](/it/sub-agents) in tre punti: 1. Prima che un subagent inizi, la descrizione del compito delegato viene valutata, quindi un compito che sembra pericoloso viene bloccato al momento dello spawn. 2. Mentre il subagent viene eseguito, ognuna delle sue azioni passa attraverso il classificatore con le stesse regole della sessione padre, e qualsiasi `permissionMode` nel frontmatter del subagent viene ignorato. 3. Quando il subagent finisce, il classificatore esamina la sua intera cronologia di azioni; se quel controllo di ritorno segnala una preoccupazione, un avviso di sicurezza viene anteposto ai risultati del subagent. Il passaggio 1 richiede Claude Code v2.1.178 o successivo. Le versioni precedenti applicavano il classificatore ai passaggi 2 e 3, ma non valutavano la descrizione del compito prima che il subagent iniziasse. Il classificatore viene eseguito su un modello configurato dal server che è indipendente dalla tua selezione `/model`, quindi il cambio di modelli non cambia la disponibilità del classificatore. Le chiamate del classificatore contano verso il tuo utilizzo di token. Ogni controllo invia una parte della trascrizione più l'azione in sospeso, aggiungendo un round-trip prima dell'esecuzione. Le letture e le modifiche della directory di lavoro al di fuori dei percorsi protetti saltano il classificatore, quindi l'overhead proviene principalmente da comandi shell e operazioni di rete.

Consenti solo strumenti pre-approvati con la modalità dontAsk

La modalità `dontAsk` auto-nega ogni chiamata di strumento che altrimenti richiederebbe. Solo le azioni che corrispondono alle tue regole `permissions.allow` e ai [comandi Bash di sola lettura](/it/permissions#read-only-commands) possono essere eseguite; le regole [`ask` esplicite](/it/permissions#manage-permissions) vengono negate piuttosto che richiedere. Questo rende la modalità completamente non interattiva per pipeline CI o ambienti ristretti in cui pre-definisci esattamente cosa Claude può fare. Le sessioni cloud su [Claude Code sul web](/it/claude-code-on-the-web) ignorano `defaultMode: "dontAsk"`; vedi [bypassPermissions](#skip-all-checks-with-bypasspermissions-mode) per i dettagli. Impostala all'avvio con il flag: ```bash theme={null} claude --permission-mode dontAsk ```

Salta tutti i controlli con la modalità bypassPermissions

La modalità `bypassPermissions` disabilita i prompt di autorizzazione e i controlli di sicurezza in modo che le chiamate di strumenti vengono eseguite immediatamente. A partire dalla v2.1.126 questo include le scritture su [percorsi protetti](#protected-paths), che le versioni precedenti ancora richiedevano. Le [regole ask](/it/permissions#manage-permissions) esplicite forzano comunque un prompt in questa modalità, e le rimozioni che interessano la radice del filesystem o la directory home, come `rm -rf /` e `rm -rf ~`, ancora richiedono un prompt come protezione contro gli errori del modello. Utilizza questa modalità solo in ambienti isolati come container, VM o dev container senza accesso a Internet, dove Claude Code non può danneggiare il tuo sistema host. Non puoi entrare in `bypassPermissions` da una sessione che è stata avviata senza uno dei flag di abilitazione; riavvia con uno per abilitarlo: ```bash theme={null} claude --permission-mode bypassPermissions ``` Il flag `--dangerously-skip-permissions` è equivalente. Su Linux e macOS, Claude Code rifiuta di avviarsi in questa modalità quando viene eseguito come root o sotto `sudo`: ```text theme={null} --dangerously-skip-permissions cannot be used with root/sudo privileges for security reasons ``` Il controllo viene saltato automaticamente all'interno di una sandbox riconosciuta. Per eseguire autonomamente in un container, utilizza la configurazione [dev container](/it/devcontainer), che esegue Claude Code come utente non root. [Claude Code sul web](/it/claude-code-on-the-web) non rispetta `defaultMode: "bypassPermissions"` o `"dontAsk"` dai tuoi file di impostazioni, quindi le impostazioni archiviate di un repository non possono avviare una sessione cloud in modalità bypass-permissions. L'impostazione viene ignorata silenziosamente e la sessione si avvia nella modalità mostrata nel menu a discesa della modalità. Vedi [Cambia modalità di autorizzazione](#switch-permission-modes) per quali modalità offrono le sessioni cloud. `bypassPermissions` non offre protezione contro l'iniezione di prompt o azioni indesiderate. Per i controlli di sicurezza in background con molti meno prompt, utilizza [auto mode](#eliminate-prompts-with-auto-mode) invece. Gli amministratori possono bloccare questa modalità impostando `permissions.disableBypassPermissionsMode` su `"disable"` nelle [impostazioni gestite](/it/permissions#managed-settings).

Percorsi protetti

Le scritture su un piccolo insieme di percorsi non vengono mai auto-approvate, in ogni modalità eccetto `bypassPermissions`. Questo previene la corruzione accidentale dello stato del repository e della configurazione di Claude. | Modalità | Scritture su percorsi protetti | | :------------------------------- | :----------------------------- | | `default`, `acceptEdits`, `plan` | Richieste di conferma | | `auto` | Instradate al classificatore | | `dontAsk` | Negate | | `bypassPermissions` | Consentite | Le regole [`permissions.allow`](/it/permissions#manage-permissions) nei file di impostazioni non pre-approvano le scritture su percorsi protetti. Il controllo di sicurezza viene eseguito prima che Claude Code valuti le regole allow dalle impostazioni, quindi una voce come `Edit(.claude/**)` in `~/.claude/settings.json` o `.claude/settings.json` non cambia il risultato per modalità nella tabella sopra. Nelle modalità che richiedono conferma, il prompt per una scrittura `.claude/` offre **Sì, e consenti a Claude di modificare le proprie impostazioni per questa sessione**, che approva le successive scritture `.claude/` in quella sessione senza richiedere di nuovo la conferma. Directory protette: * `.git` * `.config/git` * `.vscode` * `.idea` * `.husky` * `.cargo` * `.devcontainer` * `.yarn` * `.mvn` * `.claude`, ad eccezione di `.claude/worktrees` dove Claude archivia i propri git worktrees File protetti: * `.gitconfig`, `.gitmodules` * `.bashrc`, `.bash_profile`, `.bash_login`, `.bash_aliases`, `.bash_logout`, `.zshrc`, `.zprofile`, `.zshenv`, `.zlogin`, `.zlogout`, `.profile`, `.envrc` * `.npmrc`, `.yarnrc`, `.yarnrc.yml`, `.pnp.cjs`, `.pnp.loader.mjs`, `.pnpmfile.cjs`, `bunfig.toml`, `.bunfig.toml` * `.bazelrc`, `.bazelversion`, `.bazeliskrc` * `.pre-commit-config.yaml`, `lefthook.yml`, `lefthook.yaml`, `.lefthook.yml`, `.lefthook.yaml` * `gradle-wrapper.properties`, `maven-wrapper.properties` * `.devcontainer.json` * `.ripgreprc`, `pyrightconfig.json` * `.mcp.json`, `.claude.json`

Vedi anche

* [Permissions](/it/permissions): regole allow, ask e deny; politiche gestite * [Configure auto mode](/it/auto-mode-config): dì al classificatore quale infrastruttura la tua organizzazione si fida * [Hooks](/it/hooks): logica di autorizzazione personalizzata tramite hook `PreToolUse` e `PermissionRequest` * [Ultraplan](/it/ultraplan): esegui plan mode in una sessione Claude Code sul web con revisione basata su browser * [Security](/it/security): salvaguardie e best practice * [Sandboxing](/it/sandboxing): isolamento del filesystem e della rete per i comandi Bash * [Non-interactive mode](/it/headless): esegui Claude Code con il flag `-p`