# Modalità di esecuzione e permessi (/it/docs/verdent-for-vscode/execution-modes/overview)
> Comprendere le diverse modalità di esecuzione e quando usarle
***
Verdent for VS Code offre più modalità di esecuzione che controllano il modo in cui l'AI interagisce con i tuoi file ed esegue i comandi. Ogni modalità propone un diverso compromesso tra controllo, velocità e sicurezza.
### Cosa imparerai [#cosa-imparerai]
* Come funziona ogni modalità di esecuzione e quando usarla
* Modelli di permessi e considerazioni sulla sicurezza
* Confronto tra le modalità e strategie di passaggio
* Think Hard Mode per attività di ragionamento complesse
### Modalità principali disponibili [#modalità-principali-disponibili]
Modalità predefinita con richieste di permesso per ogni operazione protetta. Massimo controllo e supervisione.
Operazioni sui file automatiche, permesso richiesto per i comandi. Bilancia velocità e sicurezza.
Autonomia completa per ambienti isolati. Nessuna richiesta di permesso per nulla.
Modalità di pianificazione in sola lettura. Rivedi il piano completo prima che inizi l'esecuzione.
***
## Modalità di esecuzione [#modalità-di-esecuzione]
Manual Accept Mode è la modalità di esecuzione predefinita che offre il controllo sulle modifiche ai file e sull'esecuzione dei comandi.
**Operazioni automatiche:**
* Lettura dei file e analisi del codice
* Esplorazione delle directory
**Richiede permesso:**
* Modifica dei file (creazione, modifica, eliminazione)
* Esecuzione di comandi (comandi da terminale, test, build)
Quando Verdent deve eseguire un'operazione protetta, mostra quale azione intende compiere e quale file/comando è coinvolto. Puoi **accettare** o **rifiutare** ogni operazione.
**Importante:** ogni permesso vale solo per quella specifica operazione. Manual Accept Mode richiede l'approvazione per ogni operazione protetta durante l'intera sessione.
#### Quando usarla [#quando-usarla]
* Imparare le capacità di Verdent e i suoi schemi di flusso di lavoro
* Lavorare in codebase sconosciute che richiedono una supervisione attenta
* Modifiche critiche a codice di produzione o ad aree sensibili per la sicurezza
* Requisiti di conformità che necessitano di percorsi di approvazione espliciti
#### Attivazione [#attivazione]
Manual Accept Mode è attiva per impostazione predefinita. Per tornare indietro:
Seleziona il pulsante "Switch Permission" nella casella di input
Scegli "Manual Accept Mode" dal menu a tendina
Il pulsante mostra "Manual" per confermare che la modalità è attiva
#### Considerazioni sulla sicurezza [#considerazioni-sulla-sicurezza]
**Vantaggi:**
* Approvazione al primo utilizzo per tipo di strumento (modifiche ai file, comandi, strumenti)
* Visibilità completa prima di concedere l'accesso
* Massimo controllo e trasparenza
**Limitazioni:**
* Dopo la prima approvazione di un tipo di strumento, gli utilizzi successivi procedono senza richieste
* L'approvazione è per tipo di strumento, non per operazione
* Avvia nuove sessioni quando lavori su codice critico per reimpostare le approvazioni degli strumenti
Auto-Run Mode approva automaticamente le operazioni sui file richiedendo però il permesso per i comandi. Questo riduce le richieste di permesso per il lavoro ordinario sui file mantenendo la sicurezza per le operazioni rischiose.
**Automatico:**
* Lettura, modifica, creazione ed eliminazione dei file all'interno del workspace
* Spostamento, rinomina e organizzazione dei file all'interno del workspace
* Operazioni di ricerca e navigazione dei file
**Richiede permesso:**
* **Qualsiasi comando che coinvolge percorsi al di fuori del workspace corrente**
* **Comandi bash pericolosi:** `rm -rf`, `git commit`, `git push`, ecc.
* Esecuzione di comandi (terminale, script, build)
* Installazione di pacchetti e modifiche al sistema
#### Quando usarla [#quando-usarla-1]
| Usa Auto-Run per | Non usarla per |
| ------------------------------------------------------------ | --------------------------------------------------- |
| Codebase affidabili con controllo di versione | Codebase sconosciute |
| Prototipazione e sperimentazione rapida | Codice di produzione critico |
| Refactoring multi-file (15+ file = 15 richieste risparmiate) | Nessuna rete di sicurezza del controllo di versione |
| Sviluppo concentrato che minimizza le interruzioni | Requisiti di conformità |
#### Attivazione [#attivazione-1]
Seleziona il pulsante "Switch Permission" che mostra la modalità corrente
Scegli "Auto-Run Mode" dal menu a tendina
Il pulsante mostra "Auto" per confermare che la modalità è attiva
Persiste tra le sessioni e i riavvii di VS Code. Si applica globalmente a tutti i workspace.
#### Esempio di flusso di lavoro [#esempio-di-flusso-di-lavoro]
**Creazione di un endpoint POST /api/tasks:**
1. Attiva Auto-Run Mode
2. Invia: "Crea un endpoint POST /api/tasks che verifica l'esistenza della categoria e la salva nel database"
3. Verdent legge oltre 5 file e modifica automaticamente 3 file (senza richieste)
4. Rivedi le modifiche nel pannello Source Control
5. Richiedi i test: "Esegui i test per le attività API"
6. Richiesta di permesso per il comando `npm test` - Accetta
7. Aggiungi la validazione: "Aggiungi la validazione per i titoli vuoti"
8. Verdent modifica automaticamente (senza richiesta)
9. Richiedi di nuovo i test - Richiesta di permesso - Accetta
10. Rivedi i diff, esegui il commit delle modifiche
**Risultato:** 3 richieste per i comandi, 0 richieste per i file. Con l'accettazione manuale servirebbero 4 richieste aggiuntive per i file.
#### Considerazioni sulla sicurezza [#considerazioni-sulla-sicurezza-1]
**Vantaggi:**
* Le modifiche sono immediatamente visibili in VS Code
* Ambito limitato al workspace (non può interessare i file di sistema)
* Git fornisce la sicurezza del rollback
**Rischi:**
* Nessuna supervisione delle operazioni sui file
* Ambito inatteso ("Rinomina User in Account" potrebbe modificare decine di file)
* Possibile eliminazione di file durante la pulizia
* Potrebbe modificare file sensibili se richiesto
**Mitigazione:**
* Usa prompt chiari e specifici
* Rivedi il pannello Source Control al termine
* Esegui commit frequenti per checkpoint puliti
* Usa prima Plan Mode per le operazioni complesse
* Configura .gitignore per proteggere i file sensibili
Skip Permission Mode ignora tutte le richieste di permesso, consentendo un'autonomia completa. **Usala solo in ambienti isolati e usa e getta.**
**Tutte le operazioni automatiche:**
* Operazioni sui file
* Esecuzione di comandi
* Installazione di pacchetti
* Operazioni a livello di sistema
Questa modalità rimuove tutte le protezioni di sicurezza. Usala solo in ambienti completamente isolati e usa e getta, dove gli errori non hanno conseguenze. Non usarla mai in produzione o in qualsiasi codebase a cui tieni.
#### Quando usarla [#quando-usarla-2]
| Usa Skip Permission per | Non usarla MAI per |
| ---------------------------------------------------------------------------- | ------------------------------------------ |
| Pipeline CI/CD automatizzate in container isolati | Ambienti di produzione |
| Container di sviluppo usa e getta (eliminati dopo la sperimentazione) | Ambienti di sviluppo con codice importante |
| Ambienti sandbox senza connessioni alla produzione | Qualsiasi codebase a cui tieni |
| Flussi di lavoro con script in cui l'approvazione umana ne vanifica lo scopo | Repository condivisi |
| | Ambienti con dati sensibili |
#### Attivazione [#attivazione-2]
Seleziona il pulsante "Switch Permission"
Scegli "Skip Permission Mode" dal menu a tendina
Il pulsante mostra "Skip" per confermare che la modalità è attiva
**Controllo di sicurezza prima di attivare:**
* È un container o una VM usa e getta?
* Questo ambiente può essere eliminato senza conseguenze?
* C'è codice di produzione o importante qui?
Se rispondi "no" alle prime due o "sì" alla terza, NON attivarla.
#### Avvisi di sicurezza [#avvisi-di-sicurezza]
**TUTTE le protezioni di sicurezza rimosse:**
* I comandi vengono eseguiti immediatamente con i permessi di sistema
* I file possono essere modificati o eliminati senza avviso
* Le operazioni sul database e le operazioni Git (incluso il force push) procedono senza approvazione
* Potrebbe installare pacchetti dannosi o esporre le credenziali
**Sicura solo quando:**
* L'ambiente è completamente usa e getta
* Non esiste codice o dati importanti
* Non c'è connessione ai sistemi di produzione
* Accetti che qualsiasi cosa possa essere distrutta
***
## Plan Mode [#plan-mode]
Plan Mode è una modalità di interazione in sola lettura in cui Verdent analizza il codice, crea piani dettagliati e pone domande di chiarimento, ma non può modificare i file né eseguire comandi finché non approvi.
#### Come funziona [#come-funziona]
1. **Analisi** - Legge i file automaticamente
2. **Pianificazione** - Crea un piano strutturato con elenco di attività
3. **Chiarimento** - Pone domande per rimuovere l'incertezza
4. **Approvazione** - Rivedi e decidi se procedere
5. **Esecuzione** - Passa alla tua modalità di permesso per l'esecuzione
Il piano mostra i file da modificare, i passaggi di implementazione, le dipendenze e la strategia di verifica.
#### Quando usarla [#quando-usarla-3]
* Modifiche complesse multi-file (comprendere l'ambito prima di impegnarsi)
* Codebase sconosciute (esplorazione sicura senza rischi)
* Decisioni architetturali (rivedere l'approccio prima dell'implementazione)
* Evitare la stanchezza da accettazione manuale (rivedi una volta invece di 50 richieste individuali)
* Modifiche di produzione ad alto rischio (piena visibilità prima dell'esecuzione)
#### Attivazione [#attivazione-3]
Seleziona il pulsante "Switch Mode" nella casella di input
Scegli "Plan Mode" dal menu a tendina
L'indicatore della modalità cambia in "Plan" per confermare che la modalità è attiva
Quando è attiva, Verdent analizza e crea i piani ma non modifica i file né esegue comandi finché non approvi. Dopo l'approvazione, passa alla tua modalità di permesso predefinita (Manual Accept o Auto-Run).
#### Considerazioni sulla sicurezza [#considerazioni-sulla-sicurezza-2]
**Vantaggi:**
* Nessun rischio di esecuzione durante la pianificazione
* Piena visibilità prima di impegnarsi
* Il chiarimento interattivo rimuove l'incertezza
* Sicura per l'analisi in produzione
**Limitazioni:**
* L'approvazione non garantisce la correttezza (i piani possono contenere errori logici)
* La sicurezza dell'esecuzione dipende dalla modalità di permesso scelta dopo l'approvazione
* La qualità del piano dipende dalla chiarezza del prompt
**Buone pratiche:**
* Rivedi i piani alla ricerca di errori logici o incomprensioni
* Poni domande di approfondimento se qualcosa non è chiaro
* Perfeziona i prompt prima di approvare l'esecuzione
* Considera quale modalità di permesso eseguirà (Manual Accept per la supervisione, Auto-Run per la velocità)
***
## Think Hard Mode [#think-hard-mode]
Think Hard Mode alloca il massimo delle risorse computazionali per le attività di ragionamento complesse. Il modello esplora più approcci e fornisce soluzioni più approfondite.
**Caratteristiche:**
* Tempo di ragionamento esteso
* Analisi più approfondita di più approcci risolutivi
* Migliore gestione di logiche complesse, casi limite e decisioni architetturali
* Costo in crediti più elevato per richiesta
#### Quando usarla [#quando-usarla-4]
| Usa Think Hard Mode per | Non usarla per |
| ----------------------------------------------------------------- | ----------------------------------------- |
| Decisioni architetturali complesse con molteplici compromessi | Attività semplici e lineari |
| Debug sofisticato con molteplici cause potenziali | Richieste sensibili al tempo |
| Progettazione di algoritmi che richiede analisi di ottimizzazione | Budget di crediti limitato |
| Logica di business critica dove la correttezza è fondamentale | Quando la modalità standard è sufficiente |
| Ottimizzazione delle prestazioni di colli di bottiglia complessi | |
#### Attivazione [#attivazione-4]
Usa il pulsante dell'interfaccia per l'attivazione per singola richiesta:
Seleziona il pulsante/interruttore "Think Hard" nella casella di input
Digita e invia la tua richiesta
Si applica solo a quella specifica richiesta - non è persistente
Funziona con tutti i provider AI. Non è persistente - va attivato ogni volta per le richieste che necessitano di un ragionamento approfondito.
Includi parole chiave relative al pensiero nel tuo prompt:
```
Think: Design the optimal database schema for this multi-tenant SaaS application
```
Oppure per il massimo ragionamento:
```
Ultrathink: Analyze the trade-offs between different authentication approaches
```
"Think" e "ultrathink" sono capacità specifiche dei modelli Claude. Queste parole chiave attivano un ragionamento più profondo nei modelli Claude (Sonnet, Opus) ma potrebbero non funzionare con altri provider AI (GPT-5, MiniMax).
Attivazione solo per singola richiesta - non è persistente come Manual Accept o Auto-Run.
***
## Confronto tra le modalità [#confronto-tra-le-modalità]
| Modalità | Controllo | Velocità | Ideale per | Da evitare quando |
| ------------------- | --------------- | ------------- | ------------------------------------------------------ | ------------------------------------------------ |
| **Manual Accept** | Massimo | Il più lento | Apprendimento, codice sconosciuto, modifiche critiche | Progetti affidabili, iterazione rapida |
| **Auto-Run** | Moderato | Veloce | Codebase affidabili, prototipazione, lavoro multi-file | Codice sconosciuto, nessun controllo di versione |
| **Skip Permission** | Nessuno | Il più veloce | CI/CD, container usa e getta, sandbox | Produzione, codice importante |
| **Plan Mode** | Revisione prima | N/D | Modifiche complesse, decisioni architetturali | Attività semplici |
| **Think Hard** | Per richiesta | Più lento | Ragionamento complesso, algoritmi, logica critica | Attività semplici, richieste sensibili al tempo |
### Quando usare ogni modalità [#quando-usare-ogni-modalità]
| Scenario | Manual Accept | Auto-Run | Skip Permission | Plan Mode |
| --------------------------------------- | :-----------: | :------: | :-------------: | :-------: |
| Imparare Verdent | ✓ | | | |
| Codebase sconosciuta | ✓ | | | ✓ |
| Codebase affidabile con Git | | ✓ | | |
| Codice critico/di produzione | ✓ | | | ✓ |
| Prototipazione rapida | | ✓ | | |
| Refactoring multi-file | | ✓ | | |
| Pianificazione architetturale complessa | | | | ✓ |
| Pipeline CI/CD (isolate) | | | ✓ | |
| Container usa e getta | | | ✓ | |
| Requisiti di conformità | ✓ | | | |
***
## Buone pratiche di sicurezza [#buone-pratiche-di-sicurezza]
Comprendere la classifica di sicurezza di ogni modalità ti aiuta a scegliere quella adatta ai diversi livelli di rischio.
1. **Plan Mode** - Sola lettura fino all'approvazione. Nessun rischio di esecuzione durante la pianificazione.
2. **Manual Accept Mode** - Controllo per operazione con approvazione al primo utilizzo per tipo di strumento.
3. **Auto-Run Mode** - Autonomia sui file con approvazione dei comandi. Richiede la rete di sicurezza di Git.
4. **Skip Permission Mode** - Autonomia completa. Solo ambienti isolati.
Abbina la modalità al livello di rischio: il codice critico usa le modalità più sicure (Plan, Manual Accept), il codice affidabile usa le modalità più veloci (Auto-Run), gli ambienti usa e getta usano la modalità più veloce (Skip Permission).
Pratiche essenziali che si applicano indipendentemente dalla modalità di esecuzione che stai usando.
**Per tutte le modalità:**
1. **Usa il controllo di versione** - Inizializza Git prima di usare le modalità permissive, esegui commit frequenti, rivedi i diff prima del commit
2. **Scrivi prompt chiari** - Sii specifico sull'ambito, specifica esplicitamente i confini dei file, usa le @-menzioni per il contesto
3. **Rivedi prima del commit** - Controlla il pannello Source Control al termine, rivedi con attenzione tutti i diff, testa le modifiche
4. **Avvia sessioni pulite** - Cancella il contesto tra le attività importanti, reimposta le approvazioni degli strumenti per il lavoro sensibile, evita la contaminazione del contesto
5. **Abbina la modalità al rischio** - Codice critico → Manual Accept o Plan Mode, codice affidabile → Auto-Run, esperimenti → Auto-Run con Git, usa e getta → solo Skip Permission
**Promemoria di sicurezza:**
* Non eseguire mai il commit di file sensibili (.env, credenziali)
* Configura .gitignore prima di usare Auto-Run
* Rivedi con attenzione i permessi dei comandi
* Usa Plan Mode per le modifiche che influiscono sulla sicurezza
* Le sessioni pulite reimpostano le approvazioni degli strumenti in Manual Accept
Comprendere come funziona il sistema di permessi di Verdent ti aiuta a usarlo in modo efficace.
**Come funziona:**
1. **Primo utilizzo** - Il sistema richiede il permesso quando usi per la prima volta ogni tipo di strumento (modifiche ai file, esecuzioni di comandi, uso degli strumenti)
2. **Utilizzi successivi** - Dopo l'approvazione iniziale, quel tipo di strumento procede senza richieste per il resto della sessione
3. **Nuova sessione** - Avviare una nuova sessione reimposta tutte le approvazioni, permettendoti di ripartire da zero
**Principio chiave:** questo modello bilancia sicurezza e produttività. Rivedi e approvi i tipi di strumento una volta, poi lavori in modo efficiente all'interno di quel contesto di approvazione. Per il lavoro sensibile, avvia una nuova sessione per reimpostare le approvazioni.
**Per reimpostare le approvazioni:** avvia una nuova sessione
***
## Vedi anche [#vedi-anche]
Monitora l'uso dei token, i crediti e le prestazioni
Gestire le finestre di contesto tra le modalità