# Modos de execução e permissões (/pt/docs/verdent-for-vscode/execution-modes/overview)
> Entenda os diferentes modos de execução e quando usá-los
***
O Verdent for VS Code oferece múltiplos modos de execução que controlam como a IA interage com seus arquivos e executa comandos. Cada modo oferece diferentes compensações entre controle, velocidade e segurança.
### O que você vai aprender [#o-que-você-vai-aprender]
* Como cada modo de execução funciona e quando usá-lo
* Modelos de permissão e considerações de segurança
* Comparação de modos e estratégias para alternar entre eles
* Think Hard Mode para tarefas de raciocínio complexo
### Principais modos disponíveis [#principais-modos-disponíveis]
Modo padrão com solicitações de permissão para cada operação protegida. Máximo controle e supervisão.
Operações de arquivo automáticas, permissão necessária para comandos. Equilibra velocidade e segurança.
Autonomia total para ambientes isolados. Sem prompts de permissão para nada.
Modo de planejamento somente leitura. Revise o plano completo antes de a execução começar.
***
## Modos de execução [#modos-de-execução]
O Manual Accept Mode é o modo de execução padrão que oferece controle sobre modificações de arquivos e execução de comandos.
**Operações automáticas:**
* Leitura de arquivos e análise de código
* Navegação por diretórios
**Requer permissão:**
* Edição de arquivos (criar, modificar, excluir)
* Execução de comandos (comandos de terminal, testes, builds)
Quando o Verdent precisa realizar uma operação protegida, ele mostra qual ação deseja executar e qual arquivo/comando está envolvido. Você pode **aceitar** ou **rejeitar** cada operação.
**Importante:** Cada permissão é apenas para aquela operação específica. O Manual Accept Mode requer aprovação para cada operação protegida ao longo da sessão.
#### Quando usar [#quando-usar]
* Aprendendo as capacidades e os padrões de fluxo de trabalho do Verdent
* Trabalhando em bases de código desconhecidas que exigem supervisão cuidadosa
* Mudanças críticas em código de produção ou áreas sensíveis à segurança
* Requisitos de conformidade que precisam de trilhas de aprovação explícitas
#### Ativação [#ativação]
O Manual Accept Mode está ativo por padrão. Para voltar a ele:
Clique no botão "Switch Permission" na caixa de entrada
Escolha "Manual Accept Mode" no menu suspenso
O botão exibe "Manual" para confirmar que o modo está ativo
#### Considerações de segurança [#considerações-de-segurança]
**Vantagens:**
* Aprovação no primeiro uso por tipo de ferramenta (edições de arquivo, comandos, ferramentas)
* Visibilidade completa antes de conceder acesso
* Máximo controle e transparência
**Limitações:**
* Após a primeira aprovação de um tipo de ferramenta, os usos seguintes prosseguem sem prompts
* A aprovação é por tipo de ferramenta, não por operação
* Inicie novas sessões ao trabalhar em código crítico para redefinir as aprovações de ferramentas
O Auto-Run Mode aprova automaticamente operações de arquivo e exige permissão para comandos. Isso reduz os prompts de permissão para o trabalho rotineiro com arquivos, mantendo a segurança em operações arriscadas.
**Automático:**
* Leitura, edição, criação e exclusão de arquivos dentro do espaço de trabalho
* Mover, renomear e organizar arquivos dentro do espaço de trabalho
* Operações de busca e navegação em arquivos
**Requer permissão:**
* **Qualquer comando que envolva caminhos fora do espaço de trabalho atual**
* **Comandos bash perigosos:** `rm -rf`, `git commit`, `git push`, etc.
* Execução de comandos (terminal, scripts, builds)
* Instalação de pacotes e modificações no sistema
#### Quando usar [#quando-usar-1]
| Use Auto-Run para | Não use para |
| -------------------------------------------------------------------------- | ------------------------------------------- |
| Bases de código confiáveis com controle de versão | Bases de código desconhecidas |
| Prototipagem e experimentação rápidas | Código crítico de produção |
| Refatoração de múltiplos arquivos (15+ arquivos = 15 prompts economizados) | Sem rede de segurança de controle de versão |
| Desenvolvimento focado minimizando interrupções | Requisitos de conformidade |
#### Ativação [#ativação-1]
Clique no botão "Switch Permission" que mostra o modo atual
Escolha "Auto-Run Mode" no menu suspenso
O botão exibe "Auto" para confirmar que o modo está ativo
Persiste entre sessões e reinicializações do VS Code. Aplica-se globalmente a todos os espaços de trabalho.
#### Exemplo de fluxo de trabalho [#exemplo-de-fluxo-de-trabalho]
**Construindo um endpoint POST /api/tasks:**
1. Ative o Auto-Run Mode
2. Envie: "Crie um endpoint POST /api/tasks que valide se a categoria existe e salve no banco de dados"
3. O Verdent lê 5+ arquivos e modifica 3 arquivos automaticamente (sem prompts)
4. Revise as mudanças no painel Source Control
5. Solicite testes: "Execute os testes para o API de tarefas"
6. Prompt de permissão para o comando `npm test` - Aceite
7. Adicione validação: "Adicione validação para títulos vazios"
8. O Verdent edita automaticamente (sem prompt)
9. Solicite os testes novamente - Prompt de permissão - Aceite
10. Revise os diffs, faça commit das mudanças
**Resultado:** 3 prompts de comando, 0 prompts de arquivo. O Manual Accept exigiria 4 prompts de arquivo adicionais.
#### Considerações de segurança [#considerações-de-segurança-1]
**Vantagens:**
* Mudanças imediatamente visíveis no VS Code
* Limitadas ao espaço de trabalho (não podem afetar arquivos do sistema)
* O Git oferece segurança de reversão
**Riscos:**
* Nenhuma supervisão das operações de arquivo
* Escopo inesperado ("Renomear User para Account" pode modificar dezenas de arquivos)
* Exclusão de arquivos possível durante limpezas
* Pode modificar arquivos sensíveis se solicitado
**Mitigação:**
* Use prompts claros e específicos
* Revise o painel Source Control após as conclusões
* Faça commits com frequência para criar checkpoints limpos
* Use o Plan Mode primeiro para operações complexas
* Configure o .gitignore para proteger arquivos sensíveis
O Skip Permission Mode ignora todos os prompts de permissão, permitindo autonomia completa. **Use somente em ambientes isolados e descartáveis.**
**Todas as operações automáticas:**
* Operações de arquivo
* Execução de comandos
* Instalação de pacotes
* Operações em nível de sistema
Este modo remove todas as proteções de segurança. Use somente em ambientes completamente isolados e descartáveis, onde os erros não tenham consequências. Nunca use em produção ou em qualquer base de código com a qual você se importe.
#### Quando usar [#quando-usar-2]
| Use Skip Permission para | NUNCA use para |
| ---------------------------------------------------------------------------- | -------------------------------------------------- |
| Pipelines de CI/CD automatizados em containers isolados | Ambientes de produção |
| Containers de desenvolvimento descartáveis (excluídos após a experimentação) | Ambientes de desenvolvimento com código importante |
| Ambientes sandbox sem conexões de produção | Qualquer base de código com a qual você se importe |
| Fluxos de trabalho scriptados onde a aprovação humana anula o propósito | Repositórios compartilhados |
| | Ambientes com dados sensíveis |
#### Ativação [#ativação-2]
Clique no botão "Switch Permission"
Escolha "Skip Permission Mode" no menu suspenso
O botão exibe "Skip" para confirmar que o modo está ativo
**Verificação de segurança antes de ativar:**
* Este é um container ou VM descartável?
* Este ambiente pode ser excluído sem consequências?
* Existe algum código de produção ou importante aqui?
Se a resposta for "não" para as duas primeiras ou "sim" para a terceira, NÃO ative.
#### Avisos de segurança [#avisos-de-segurança]
**TODAS as proteções de segurança removidas:**
* Comandos executam imediatamente com permissões de sistema
* Arquivos podem ser modificados ou excluídos sem aviso
* Operações de banco de dados e operações Git (incluindo force push) prosseguem sem aprovação
* Pode instalar pacotes maliciosos ou expor credenciais
**Seguro somente quando:**
* O ambiente é completamente descartável
* Não existe código ou dado importante
* Não há conexão com sistemas de produção
* Você aceita que tudo pode ser destruído
***
## Plan Mode [#plan-mode]
O Plan Mode é um modo de interação somente leitura no qual o Verdent analisa o código, cria planos detalhados e faz perguntas de esclarecimento, mas não pode modificar arquivos nem executar comandos até que você aprove.
#### Como funciona [#como-funciona]
1. **Análise** - Lê os arquivos automaticamente
2. **Planejamento** - Cria um plano estruturado com lista de tarefas
3. **Esclarecimento** - Faz perguntas para eliminar incertezas
4. **Aprovação** - Você revisa e decide prosseguir
5. **Execução** - Alterna para o seu modo de permissão para executar
O plano mostra os arquivos a modificar, as etapas de implementação, as dependências e a estratégia de verificação.
#### Quando usar [#quando-usar-3]
* Mudanças complexas em múltiplos arquivos (entender o escopo antes de se comprometer)
* Bases de código desconhecidas (exploração segura sem risco)
* Decisões arquiteturais (revisar a abordagem antes da implementação)
* Evitar a fadiga do Manual Accept (revisar uma vez em vez de 50 prompts individuais)
* Mudanças de produção de alto risco (visibilidade completa antes da execução)
#### Ativação [#ativação-3]
Clique no botão "Switch Mode" na caixa de entrada
Escolha "Plan Mode" no menu suspenso
O indicador de modo muda para "Plan" para confirmar que o modo está ativo
Quando ativo, o Verdent analisa e cria planos, mas não modifica arquivos nem executa comandos até que você aprove. Após a aprovação, alterna para o seu modo de permissão padrão (Manual Accept ou Auto-Run).
#### Considerações de segurança [#considerações-de-segurança-2]
**Vantagens:**
* Risco zero de execução durante o planejamento
* Visibilidade completa antes de se comprometer
* O esclarecimento interativo elimina incertezas
* Seguro para análise de produção
**Limitações:**
* A aprovação não garante a correção (planos podem ter erros lógicos)
* A segurança da execução depende do modo de permissão escolhido após a aprovação
* A qualidade do plano depende da clareza do prompt
**Boas práticas:**
* Revise os planos em busca de erros lógicos ou mal-entendidos
* Faça perguntas de acompanhamento se algo não estiver claro
* Refine os prompts antes de aprovar a execução
* Considere qual modo de permissão executará (Manual Accept para supervisão, Auto-Run para velocidade)
***
## Think Hard Mode [#think-hard-mode]
O Think Hard Mode aloca o máximo de recursos computacionais para tarefas de raciocínio complexo. O modelo explora múltiplas abordagens e oferece soluções mais completas.
**Características:**
* Tempo de raciocínio estendido
* Análise mais profunda de múltiplas abordagens de solução
* Melhor tratamento de lógica complexa, casos extremos e decisões arquiteturais
* Maior custo em créditos por solicitação
#### Quando usar [#quando-usar-4]
| Use o Think Hard Mode para | Não use para |
| ----------------------------------------------------------- | --------------------------------- |
| Decisões arquiteturais complexas com múltiplas compensações | Tarefas simples e diretas |
| Depuração sofisticada com múltiplas causas potenciais | Solicitações sensíveis ao tempo |
| Design de algoritmos que exigem análise de otimização | Orçamento de créditos limitado |
| Lógica de negócios crítica em que a correção é primordial | Quando o modo padrão é suficiente |
| Otimização de desempenho de gargalos complexos | |
#### Ativação [#ativação-4]
Use o botão da interface para ativação por solicitação:
Clique no botão/alternância "Think Hard" na caixa de entrada
Digite e envie sua solicitação
Aplica-se somente àquela solicitação específica - não é persistente
Funciona com todos os provedores de IA. Não é persistente - você deve ativar a cada vez para solicitações que exijam raciocínio profundo.
Inclua palavras-chave de raciocínio no seu prompt:
```
Think: Design the optimal database schema for this multi-tenant SaaS application
```
Ou para o máximo de raciocínio:
```
Ultrathink: Analyze the trade-offs between different authentication approaches
```
"Think" e "ultrathink" são capacidades específicas do modelo Claude. Essas palavras-chave ativam um raciocínio mais profundo nos modelos Claude (Sonnet, Opus), mas podem não funcionar com outros provedores de IA (GPT-5, MiniMax).
Ativação apenas por solicitação - não é persistente como o Manual Accept ou o Auto-Run.
***
## Comparação de modos [#comparação-de-modos]
| Modo | Controle | Velocidade | Melhor para | Evite quando |
| ------------------- | ---------------- | ----------- | ------------------------------------------------------------------------- | ------------------------------------------- |
| **Manual Accept** | Máximo | Mais lento | Aprendizado, código desconhecido, mudanças críticas | Projetos confiáveis, iteração rápida |
| **Auto-Run** | Moderado | Rápido | Bases de código confiáveis, prototipagem, trabalho com múltiplos arquivos | Código desconhecido, sem controle de versão |
| **Skip Permission** | Nenhum | Mais rápido | CI/CD, containers descartáveis, sandboxes | Produção, código importante |
| **Plan Mode** | Revisão primeiro | N/A | Mudanças complexas, decisões arquiteturais | Tarefas simples |
| **Think Hard** | Por solicitação | Mais lento | Raciocínio complexo, algoritmos, lógica crítica | Tarefas simples, sensíveis ao tempo |
### Quando usar cada modo [#quando-usar-cada-modo]
| Cenário | Manual Accept | Auto-Run | Skip Permission | Plan Mode |
| ---------------------------------- | :-----------: | :------: | :-------------: | :-------: |
| Aprendendo o Verdent | ✓ | | | |
| Base de código desconhecida | ✓ | | | ✓ |
| Base de código confiável com Git | | ✓ | | |
| Código crítico/de produção | ✓ | | | ✓ |
| Prototipagem rápida | | ✓ | | |
| Refatoração de múltiplos arquivos | | ✓ | | |
| Planejamento arquitetural complexo | | | | ✓ |
| Pipelines de CI/CD (isolados) | | | ✓ | |
| Containers descartáveis | | | ✓ | |
| Requisitos de conformidade | ✓ | | | |
***
## Boas práticas de segurança [#boas-práticas-de-segurança]
Entender a classificação de segurança de cada modo ajuda você a escolher de forma adequada para diferentes níveis de risco.
1. **Plan Mode** - Somente leitura até a aprovação. Risco zero de execução durante o planejamento.
2. **Manual Accept Mode** - Controle por operação com aprovação no primeiro uso por tipo de ferramenta.
3. **Auto-Run Mode** - Autonomia de arquivos com aprovação de comandos. Rede de segurança do Git necessária.
4. **Skip Permission Mode** - Autonomia total. Apenas para ambientes isolados.
Combine seu modo ao nível de risco: código crítico usa os modos mais seguros (Plan, Manual Accept), código confiável usa modos mais rápidos (Auto-Run), ambientes descartáveis usam o modo mais rápido (Skip Permission).
Práticas essenciais que se aplicam independentemente do modo de execução que você estiver usando.
**Para todos os modos:**
1. **Use controle de versão** - Inicialize o Git antes de usar modos permissivos, faça commits com frequência, revise os diffs antes de fazer commit
2. **Escreva prompts claros** - Seja específico quanto ao escopo, especifique os limites de arquivos explicitamente, use @-menções para contexto
3. **Revise antes de fazer commit** - Verifique o painel Source Control após as conclusões, revise todos os diffs com cuidado, teste as mudanças
4. **Inicie sessões novas** - Limpe o contexto entre tarefas importantes, redefina as aprovações de ferramentas para trabalhos sensíveis, evite contaminação de contexto
5. **Combine o modo ao risco** - Código crítico → Manual Accept ou Plan Mode, código confiável → Auto-Run, experimentos → Auto-Run com Git, descartável → apenas Skip Permission
**Lembretes de segurança:**
* Nunca faça commit de arquivos sensíveis (.env, credenciais)
* Configure o .gitignore antes de usar o Auto-Run
* Revise as permissões de comando com cuidado
* Use o Plan Mode para mudanças que afetem a segurança
* Sessões novas redefinem as aprovações de ferramentas no Manual Accept
Entender como o sistema de permissões do Verdent funciona ajuda você a usá-lo de forma eficaz.
**Como funciona:**
1. **Primeiro uso** - O sistema solicita permissão quando você usa pela primeira vez cada tipo de ferramenta (edições de arquivo, execuções de comando, uso de ferramentas)
2. **Usos seguintes** - Após a aprovação inicial, aquele tipo de ferramenta prossegue sem prompts pelo restante da sessão
3. **Nova sessão** - Iniciar uma nova sessão redefine todas as aprovações, permitindo que você comece do zero
**Princípio principal:** Este modelo equilibra segurança com produtividade. Você revisa e aprova os tipos de ferramenta uma vez e, então, trabalha com eficiência dentro desse contexto de aprovação. Para trabalhos sensíveis, inicie uma nova sessão para redefinir as aprovações.
**Para redefinir as aprovações:** Inicie uma nova sessão
***
## Veja também [#veja-também]
Monitore o uso de tokens, créditos e desempenho
Gerenciando janelas de contexto entre os modos