# Claude Code --dangerously-skip-permissions com segurança

URL: https://agentvera.dev/pt/blog/claude-code-skip-permissions/ · Publicado: 2026-10-22

O que a flag --dangerously-skip-permissions do Claude Code pula, o que ainda a para, os riscos reais e jeitos mais seguros de cortar prompts: modos, regras, sandbox.

**Resumo:**

- A --dangerously-skip-permissions inicia o Claude Code no modo bypassPermissions; regras deny, regras ask explícitas, perguntas do próprio Claude e a remoção de caminhos críticos ainda o param.
- A documentação da Anthropic diz para usar a flag só em containers ou VMs isolados, porque ela não oferece proteção contra prompt injection nem contra ações não intencionais.
- Regras allow e deny no settings.json, o auto mode com seu classificador de segurança e o sandbox do Bash eliminam a maioria dos prompts sem tirar as proteções.

A `--dangerously-skip-permissions` inicia o Claude Code no modo `bypassPermissions`, então as chamadas de ferramentas rodam sem perguntar antes. É o jeito mais rápido de acabar com os prompts, e também o mais arriscado. A própria documentação da Anthropic diz para usá-la só em ambientes isolados, como containers ou VMs. Geralmente você não precisa dela. Algumas regras allow, o auto mode ou um sandbox eliminam a maioria dos prompts e mantêm as proteções.

Este post explica o que a flag pula, o que ela não pula, onde as coisas dão errado e as opções mais seguras. No fim, mostra como o AgentVera lida com o mesmo problema quando vários agentes rodam ao mesmo tempo.

## O que a flag realmente faz

O Claude Code tem modos de permissão. A flag é um atalho para um deles:

```bash
claude --dangerously-skip-permissions
# same as
claude --permission-mode bypassPermissions
```

Nesse modo, o Claude edita arquivos, roda comandos de shell e chama ferramentas sem parar. Segundo a [documentação de modos de permissão](https://code.claude.com/docs/en/permission-modes "Modos de permissão do Claude Code"), algumas coisas ainda o param:

- **Regras deny.** Uma regra deny nas suas configurações bloqueia uma ferramenta em qualquer modo, inclusive no bypass.
- **Regras ask explícitas.** Se você escreveu uma regra `ask`, ela continua perguntando.
- **Perguntas que o Claude faz a você.** O Claude ainda pode pausar para fazer uma pergunta.
- **Remoção de caminhos críticos.** `rm` ou `rmdir` na raiz do sistema de arquivos, em pastas de nível superior, na sua pasta home ou no diretório de trabalho e seus pais ainda pede confirmação.

Regras allow não têm efeito no modo bypass, porque tudo já está permitido. Gravações em caminhos protegidos como `.git` e `.claude` também são permitidas.

Mais alguns detalhes importam na prática:

- Na primeira vez que você usa a flag de forma interativa, o Claude Code mostra uma caixa de aviso. Aceitar grava `skipDangerousModePermissionPrompt: true` em `~/.claude/settings.json`.
- Numa execução não interativa (`claude -p`), não há caixa de aviso.
- No Linux e no macOS, a flag se recusa a rodar como root ou com sudo. A verificação é pulada dentro de um sandbox reconhecido.
- Você não consegue entrar no bypass numa sessão que não começou com ele. A `--allow-dangerously-skip-permissions` adiciona o modo ao ciclo do Shift+Tab sem ativá-lo.
- Admins podem desativar o modo para todo mundo com `permissions.disableBypassPermissionsMode: "disable"` nas configurações gerenciadas.

## Os riscos

A documentação é direta: o modo bypass “não oferece proteção contra prompt injection nem contra ações não intencionais”. Veja o que isso significa no dia a dia.

### Prompt injection

O Claude lê arquivos, páginas web, textos de issues e saídas de ferramentas. Se algo disso contiver instruções, o modelo pode segui-las. Com os prompts ligados, você vê aquele `curl` estranho para um host desconhecido antes de ele rodar. No modo bypass, você descobre depois.

### Comandos destrutivos que não estão na lista crítica

A verificação de caminhos críticos cobre o `rm` da sua pasta home ou da raiz do projeto. Ela não cobre `git reset --hard`, `git clean -fd`, uma tabela de banco de dados apagada, um force push ou uma migration rodada no ambiente errado. Tudo isso roda sem prompt.

### Segredos e o resto da sua máquina

No seu notebook, o Claude roda como você. Ele pode ler suas chaves SSH, credenciais de nuvem e arquivos `.env`, e pode acessar a rede. Um erro ou uma instrução injetada tem a sua conta inteira à disposição.

### Checkpoints não cobrem tudo

O Claude Code cria um checkpoint antes de cada prompt, e o `/rewind` (ou Esc duas vezes) restaura o código, a conversa ou os dois. Mas a [documentação de checkpoints](https://code.claude.com/docs/en/checkpointing "Checkpoints do Claude Code") diz que mudanças feitas por comandos Bash como `rm`, `mv` e `cp` não são rastreadas, nem mudanças de fora da sessão. O rewind não substitui o git.

## Jeitos mais seguros de cortar prompts de permissão

A maioria das pessoas recorre à flag porque os prompts estão atrasando o trabalho. Estas opções resolvem os prompts e mantêm as proteções.

### 1. Escolha o modo de permissão certo

| Modo | Roda sem perguntar | Bom para |
| --- | --- | --- |
| `default` (Manual) | Só leituras | Código desconhecido, repositórios sensíveis |
| `acceptEdits` | Leituras, edições de arquivos, comandos de arquivo comuns como `mkdir`, `mv`, `cp` | Programação do dia a dia em que você revisa o diff |
| `plan` | Só leituras, sem editar o código-fonte | Explorar e planejar antes de uma mudança |
| `auto` | Tudo, com um classificador verificando cada ação antes | Tarefas longas em que você confia na direção |
| `dontAsk` | Só ferramentas pré-aprovadas; o resto é negado | CI e scripts |
| `bypassPermissions` | Tudo, exceto os casos acima | Só containers e VMs isolados |

O Shift+Tab alterna entre os modos numa sessão. A `--permission-mode` escolhe um na inicialização, e o `permissions.defaultMode` nas configurações define o seu padrão.

**O auto mode** é o meio-termo que a maioria quer. Um modelo classificador revisa cada ação antes de ela rodar. Ele bloqueia ações que vão além do seu pedido, miram infraestrutura que ele não reconhece ou parecem guiadas por conteúdo hostil. Se ele bloquear três vezes seguidas ou 20 vezes no total, o auto mode pausa e os prompts normais voltam. Há dois limites: ele precisa de um modelo compatível, e a documentação diz que ele “reduz os prompts de permissão, mas não garante segurança”. Versões recentes do Claude Code iniciam sessões interativas no auto mode por padrão. Confira o `/permissions` para ver em qual modo você está.

### 2. Escreva regras allow e deny

As regras de permissão ficam no `settings.json` e são aplicadas pelo Claude Code, não pelo modelo. Elas são verificadas em ordem: deny, depois ask, depois allow. A primeira que casar vence, então uma regra allow nunca sobrepõe uma deny.

```json
{
  "permissions": {
    "allow": ["Bash(npm run test *)", "Bash(npm run lint)", "Bash(git diff *)"],
    "ask": ["Bash(git commit *)"],
    "deny": ["Bash(git push *)", "Read(./.env)"]
  }
}
```

Use o `/permissions` para ver e editar regras numa sessão. Permita os comandos que você roda cinquenta vezes por dia, como testes, lint e git somente leitura. Negue os que você nunca quer que um agente rode. O CLAUDE.md é orientação para o modelo. Ele não muda as permissões.

Para scripts, `dontAsk` com uma lista allow curta é mais restrito que o bypass:

```bash
claude -p "run the test suite and fix failures" \
  --permission-mode dontAsk --allowedTools "Bash(npm test)" "Read" "Edit"
```

### 3. Ative o sandbox do Bash

A [documentação de sandbox](https://code.claude.com/docs/en/sandboxing "Sandbox do Claude Code") descreve um sandbox no nível do sistema operacional que limita quais arquivos e domínios de rede os comandos de shell conseguem acessar. Ative com `/sandbox` ou `sandbox.enabled: true`. Funciona no macOS, no Linux e no WSL2. Vale só para comandos de shell. Ferramentas de arquivo, servidores MCP e hooks rodam fora dele.

### 4. Se for pular as permissões, isole antes

Às vezes o bypass é a escolha certa, como numa execução longa e sem supervisão em código descartável. Nesse caso, siga a configuração da documentação: um container, VM ou dev container, um usuário não root, nenhum segredo montado e, de preferência, sem acesso à internet. A forma comum sem supervisão é:

```bash
claude -p "<task>" --dangerously-skip-permissions
```

Rode dentro do container, não no seu notebook.

### 5. Trabalhe num worktree e faça commits com frequência

Um [git worktree](/pt/blog/git-worktree-parallel-agents/ "Git worktrees para agentes em paralelo") dá ao agente sua própria pasta e branch. Se ele estragar a branch, você apaga o worktree e a main nem fica sabendo. Commits frequentes dão pontos de restauração que também cobrem o que o Bash mudou, algo que os checkpoints não conseguem.

## Uma tabela rápida de decisão

| Situação | O que usar |
| --- | --- |
| Você aprova sempre os mesmos comandos de teste e lint | Regras allow |
| Você quer menos prompts, mas ainda quer uma verificação de segurança | Auto mode |
| Job de CI ou script com um conjunto conhecido de ferramentas | `dontAsk` com `--allowedTools` |
| Comandos de shell não devem acessar a rede nem a sua pasta home | Sandbox do Bash |
| Execução longa sem supervisão em código descartável | Bypass dentro de um container, como não root |
| Credenciais de produção na máquina | Nunca usar bypass |

## Como o AgentVera lida com isso

Quando você roda vários agentes, os prompts se multiplicam. Cinco agentes são cinco lugares que podem estar esperando um sim. O AgentVera dá as mesmas opções por agente, além de jeitos de responder aos prompts de qualquer lugar.

### Um nível de permissão para cada agente

Na caixa de diálogo do agente e no seletor de modelo há um campo **Permissions** (permissões) com três opções:

- **Ask**: a CLI pergunta como de costume.
- **Auto**: o próprio auto mode da CLI. Edições e comandos seguros seguem adiante, os arriscados ainda param. No Claude Code, isso inicia o agente com `--permission-mode auto`.
- **Full access**: nunca pergunta. No Claude Code, isso é `--dangerously-skip-permissions`. A dica do app diz com todas as letras: “Best in a worktree or container”.

O cabeçalho do agente mostra um selo como “Permissions: Auto”. O Codex e outras CLIs recebem os equivalentes deles. Mudar o nível reinicia o agente, e a conversa continua. Se uma política da equipe limitar as aprovações, os agentes continuam perguntando.

### Auto-approve safe requests (Pro e Team)

A [aprovação automática](/pt/features/auto-approval/ "Aprovação automática") é um caminho do meio para agentes Claude Code. Com o **Auto-approve safe requests** ligado, o AgentVera responde só aos pedidos sobre os quais o Claude perguntaria de qualquer forma, e só aos seguros:

- ferramentas de leitura como Read, Glob, Grep e LS,
- comandos de shell e git somente leitura,
- comandos de teste, lint, typecheck e build para npm, pnpm, yarn, bun, pytest, cargo, go e outros.

Comandos com `>`, `$()` ou crases nunca são aprovados automaticamente. As suas próprias regras allow e deny do Claude continuam valendo. O **Also approve file edits inside the project** vem desligado por padrão. Quando ligado, cobre edições dentro do projeto ou do worktree e nunca mexe em `.git` ou `.env`. A lista **Never auto-approve** começa com `git push`, `npm publish`, `rm`, `git reset --hard` e `git clean`, e você pode adicionar os seus. O **Recent auto-approvals** mostra o que passou na sessão atual.

A opção vem ligada por padrão, mas só tem efeito nos planos Pro e Team. No plano gratuito, os pedidos continuam chegando a você.

### Responda aos prompts da mesa, do celular ou do Telegram

Os prompts que restam chegam a você onde estiver. No desktop há uma fila de aprovações na barra de status, o ⇧⌘A pula para o agente que está esperando há mais tempo, e o Dock mostra um selo. Se você deixar uma aprovação esperando, chega um lembrete depois de cinco minutos. Veja [notificações e aprovações](/pt/features/notifications-and-approvals/ "Notificações e aprovações").

Longe da mesa:

- O [Telegram](/pt/features/telegram-control/ "Controle pelo Telegram") envia pedidos de aprovação com os botões Approve e Deny.
- A [visualização no celular](/pt/features/review-from-phone/ "Revisão pelo celular") em app.agentvera.dev mostra as aprovações com Approve e Reject.
- O [app para celular](/pt/blog/claude-code-mobile-app/ "App do Claude Code para celular") envia notificações push para elas.

Como responder a um prompt leva segundos, você tem menos motivo para recorrer ao Full access.

### Agentes no Docker para isolamento de verdade

Para execuções em que você quer mesmo o Full access, inicie o agente com **Run in a Docker container**. Funciona para agentes locais do Claude Code e do Codex, e está em todos os planos. Veja [agentes no Docker](/pt/features/agents-in-docker/ "Agentes no Docker").

- O container enxerga só a pasta do projeto, não suas chaves SSH nem o resto do seu computador.
- Quando o agente para, o container é removido. Só ficam as mudanças na pasta do projeto.
- Você pode definir limites de CPU e memória.
- Hooks e MCP continuam funcionando.

Precisa do Docker Desktop, do Colima ou do OrbStack. Esse é o ambiente isolado que a documentação do Claude Code pede, sem você escrever um Dockerfile.

### Checkpoints a cada turno

Os [checkpoints](/pt/features/checkpoints-and-replay/ "Checkpoints e replay") do AgentVera tiram um snapshot da pasta de trabalho numa ref git oculta no início de cada turno, guardando os últimos 60 turnos por agente. Como eles fotografam a própria pasta, também pegam arquivos que um comando de shell mudou. Você pode ver quais arquivos um turno mexeu, desfazer o turno e desfazer o desfazer. Suas branches, o index e o stash ficam intactos.

## Checklist antes de pular as permissões

- [ ] Regras allow ou o auto mode poderiam eliminar os prompts no lugar disso?
- [ ] O agente está num container ou VM, e não na sua máquina principal?
- [ ] Ele está rodando como usuário não root?
- [ ] Segredos, chaves SSH e credenciais de produção estão fora de alcance?
- [ ] O acesso à rede está limitado ou desligado?
- [ ] O trabalho está na própria branch ou worktree, com um commit recente para voltar?
- [ ] As regras deny cobrem `git push` e qualquer outra coisa que você nunca quer?

## Conclusão

A `--dangerously-skip-permissions` é uma ferramenta real com um uso restrito: ambientes isolados e descartáveis. No trabalho do dia a dia, regras allow e deny, o auto mode e o sandbox eliminam a maioria dos prompts e deixam o controle nas suas mãos. Se você roda muitos agentes, dê a cada um o nível de que precisa. Deixe os pedidos seguros passarem sozinhos, responda ao resto pelo celular e coloque num container os agentes que precisam de Full access.

Leia mais:

- [Aprovação automática](/pt/features/auto-approval/ "Aprovação automática")
- [Agentes no Docker](/pt/features/agents-in-docker/ "Agentes no Docker")
- [Checkpoints e replay](/pt/features/checkpoints-and-replay/ "Checkpoints e replay")
- [Rode vários agentes Claude Code](/pt/blog/run-multiple-claude-code-agents/ "Rode vários agentes Claude Code")
- [Agente Claude Code](/pt/agents/claude-code/ "Claude Code no AgentVera")

Para experimentar o AgentVera, comece pela [página inicial](/pt/ "AgentVera").

## Perguntas frequentes

**O que a --dangerously-skip-permissions faz no Claude Code?** Ela inicia a sessão no modo bypassPermissions, o mesmo que --permission-mode bypassPermissions. As chamadas de ferramentas rodam sem prompt, exceto regras ask explícitas, regras deny, perguntas que o Claude faz a você e remoções de caminhos críticos, como a sua pasta home.

**É seguro usar a --dangerously-skip-permissions?** Só num ambiente isolado. A documentação da Anthropic diz para usá-la em containers, VMs ou dev containers sem acesso à internet, e observa que ela não oferece proteção contra prompt injection nem contra ações não intencionais.

**Por que o Claude Code se recusa a pular permissões como root?** No Linux e no macOS, a flag se recusa a rodar com privilégios de root ou sudo, por motivos de segurança. A verificação é pulada dentro de um sandbox reconhecido. Rode o Claude Code como usuário comum, ou como usuário não root dentro de um container.

**Qual é uma alternativa mais segura a pular as permissões?** Regras allow no settings.json para os comandos em que você confia, regras deny para os que você nunca quer, o auto mode com seu classificador de segurança e o sandbox do Bash. Juntos, eles eliminam a maioria dos prompts sem você abrir mão do controle.

**Como o AgentVera lida com as permissões do Claude Code?** Cada agente tem uma configuração Permissions: Ask, Auto ou Full access. Nos planos Pro e Team, o Auto-approve safe requests responde por você a comandos somente leitura e de teste. Os agentes também podem rodar num container Docker, e cada turno ganha um checkpoint que você pode desfazer.

---

**Sobre o AgentVera.** AgentVera é um app desktop para macOS, Windows e Linux, desenvolvido pela Solviera Teknoloji. Ele roda 18 agentes de programação com IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) lado a lado, por projeto, em terminais reais com as instalações e logins de CLI do próprio usuário. O plano gratuito tem agentes ilimitados. Baixar: https://agentvera.dev/pt/download/ · Preços: https://agentvera.dev/pt/pricing/