Dominar o Claude Code — Do zero ao 10x — 2. As configurações que mudam tudo

17 min read min de lecture
Capítulo 02

As configurações que mudam tudo

Capítulo 2 de 10 · 20%

Objetivos deste capítulo

  • Configurar as permissões para deixares de validar 100 vezes os mesmos comandos
  • Usar os modos Plan e Auto-Edit no momento certo
  • Gerir o contexto para sessões limpas e eficazes

Permissões: para de aprovar sem parar

Por defeito, o Claude pede permissão antes de cada comando shell e de cada modificação de ficheiro. É a configuração certa para começar: enquanto não souberes o que a ferramenta faz, cada ação merece um olhar. Mas ao fim de uma hora, terás aprovado trinta vezes ls, cat e git status — comandos de leitura que não podem estragar nada. Esta fricção tem um custo real: interrompe a tua concentração e, pior, treina-te a clicar «sim» mecanicamente, o que arruína o próprio interesse do controlo.

A solução: autorizar de uma vez por todas os comandos não destrutivos, e manter a validação manual para aqueles que modificam o estado do teu sistema ou tocam na rede de forma sensível. O sistema de permissões do Claude Code assenta em listas de autorização por ferramenta e por padrão de comando, guardadas em ficheiros de configuração. Podes consultá-las e modificá-las a qualquer momento com o comando /permissions.

O mais simples para começar: cola este prompt no Claude Code — ele atualizará o teu ficheiro .claude/settings.local.json, onde vivem as tuas permissões locais:

PROMPT
adiciona permissões a este projeto claude code para autorizar os comandos bash não destrutivos: WebSearch, WebFetch, source, export, curl, jq, cat, ls, grep, echo, which, wc, file, pwd, mkdir, touch, head, tail, find, sort, tree, diff, node, npm, npx, git status, git diff, git log
Estes são comandos só de leitura ou de baixo risco. O Claude continuará a perguntar-te para os comandos que executam código arbitrário (python, scripts), apagam ficheiros (rm) ou modificam o histórico (git commit, git push) — manténs o controlo onde ele conta.

Anatomia dos ficheiros de configuração

O Claude Code lê as suas configurações a três níveis, do mais geral ao mais específico: ~/.claude/settings.json (as tuas configurações pessoais, válidas em todo o lado), .claude/settings.json (as configurações do projeto, a versionar no Git para partilhar com uma equipa), e .claude/settings.local.json (as tuas configurações locais para este projeto, ignoradas pelo Git). As permissões concedidas «para este projeto» aterram neste último.

json
{
  "permissions": {
    "allow": [
      "Bash(ls:*)",
      "Bash(cat:*)",
      "Bash(git status)",
      "Bash(git diff:*)",
      "WebSearch",
      "WebFetch(domain:docs.anthropic.com)"
    ],
    "deny": [
      "Bash(rm -rf:*)"
    ]
  }
}

Lê este ficheiro uma vez para compreenderes a lógica: cada entrada combina uma ferramenta (Bash, WebFetch…) e um padrão. Bash(git diff:*) autoriza git diff com quaisquer argumentos, mas não git push. A lista deny prevalece sempre sobre allow: é o teu cinto de segurança, mesmo que uma regra de autorização seja demasiado ampla.

Modos: Plan vs Auto-Edit

Para além das permissões comando a comando, o Claude Code tem modos de permissão que controlam o seu grau de autonomia global. No terminal, passas de um para o outro com Shift+Tab; na extensão, um seletor faz a mesma coisa. A prática dos utilizadores experientes: passar a maior parte do tempo em Plan Mode ou Ask Before Edits durante a fase de reflexão.

Em Plan Mode, o Claude não toca em nada: lê, analisa e apresenta-te um plano de ação detalhado. É aí que tudo se joga. Lês o que ele propõe, debates, pedes revisões: «porquê esta abordagem em vez daquela?», «adiciona uma etapa de verificação aqui». Enquanto o plano não estiver validado, ficas em modo restritivo. Uma vez o plano fechado, passas para Auto-Edit (aceitação automática das modificações) e deixa-lo executar depressa, sem te interromper a cada ficheiro.

  • Plan Mode → fase de conceção: o Claude lê e planeia, não modifica nada. Ideal para as tarefas complexas ou novas.
  • Ask Before Edits (por defeito) → o Claude propõe cada modificação e espera pelo teu acordo. Bom compromisso no dia a dia.
  • Auto-Edit → fase de execução: o plano está validado, o Claude avança sem te interromper nas edições de ficheiros.
flowchart LR
  A["Plan Mode: o Claude propõe"] --> B{"Plano validado?"}
  B -->|"Não: debate-se, revê-se"| A
  B -->|"Sim"| C["Auto-Edit: execução rápida"]
  C --> D["Releitura do resultado"]
  D --> E["/clear e depois tarefa seguinte"]
O ciclo de trabalho: conceber em modo restritivo, executar em modo permissivo, recomeçar limpo.
A qualidade joga-se no planeamento. Dez minutos a desafiar um plano poupam-te uma hora a depurar uma execução que correu mal. Investe a tua atenção aí, não na releitura de código depois do facto.

O modo YOLO: a manusear com precaução

Existe um nível acima: lançar o Claude Code com claude --dangerously-skip-permissions, que desativa todos os pedidos de permissão. O nome é explícito — é voluntariamente intimidante. Este modo tem usos legítimos: tarefas longas e bem delimitadas (corrigir erros de lint em 50 ficheiros, gerar boilerplate) em que cada interrupção arruína o interesse da automatização.

Mas compreende o que estás a assinar: o Claude pode então executar qualquer comando sem te consultar. A recomendação da Anthropic é reservar este modo a ambientes isolados — um contentor Docker, uma máquina virtual, uma pasta sem dados sensíveis. No teu posto de trabalho principal, com os teus verdadeiros ficheiros de clientes, fica pelas listas de autorização: obténs 95% da fluidez com 5% do risco.

Contexto: recomeçar limpo com /clear e /compact

Cada conversa com o Claude vive numa janela de contexto: a memória de trabalho do modelo. Tudo entra nela — as tuas mensagens, as respostas dele, o conteúdo dos ficheiros lidos, as saídas dos comandos. Esta janela é grande mas finita, e sobretudo: quanto mais se enche de coisas sem relação com a tua tarefa atual, mais as respostas se degradam. O modelo começa a misturar os assuntos, a repescar decisões de uma tarefa anterior, a perder o fio.

Quando começas uma nova tarefa (nova funcionalidade, correção, assunto diferente), limpa a conversa para recomeçares com um contexto limpo. Existem dois comandos, e não fazem a mesma coisa:

/clearApaga todo o histórico da conversa. Recomeça do zero. A usar entre duas tarefas sem relação: é o reflexo mais importante do capítulo.
/compactResume a conversa em curso para libertar espaço mantendo o essencial. A usar a meio de uma tarefa longa quando o contexto satura mas precisas da continuidade.

O bom reflexo: /clear por defeito entre as tarefas, /compact apenas quando estás a meio de algo longo e o Claude te avisa que o contexto se está a encher. Nota que o Claude Code também dispara uma compactação automática quando a janela se aproxima da saturação — mas uma compactação escolhida no momento certo (depois de uma etapa terminada, não a meio de um raciocínio) preserva melhor a qualidade.

O atalho que recarrega o teu contexto

«Mas se fizer /clear, o Claude esquece todo o meu projeto!» Exato — e é por isso que o capítulo 8 existe. O ficheiro CLAUDE.md, lido automaticamente no arranque de cada sessão, contém o contexto permanente do teu projeto. /clear apaga o ruído conversacional; CLAUDE.md garante que o essencial volta sempre.

Dica de especialista entretanto: cria um atalho (por exemplo um pequeno comando qnew) que pede ao Claude para reler o teu CLAUDE.md e resumir o ponto de situação do projeto. Assim cada sessão recomeça com todo o contexto do projeto, sem o ruído das conversas passadas. Verás no capítulo 8 como construir este ficheiro como deve ser.

🛠️ É a tua vez

Contexto

O projeto da Lea vai encadear muitos comandos de leitura: listar ficheiros, ler registos de publicação, verificar estados Git. Antes de construir o mínimo skill, queres um ambiente fluido em que o Claude só te interrompe para as verdadeiras decisões. Vais configurar as permissões e depois experimentar o ciclo Plan → Auto-Edit numa tarefa real.

Instruções

  1. Pede ao Claude para adicionar as permissões não destrutivas (usa o prompt do capítulo).
  2. Abre o ficheiro .claude/settings.local.json gerado e lê a lista: identifica a sintaxe Bash(comando:*).
  3. Escreve /permissions para veres a mesma lista a partir da interface do Claude Code.
  4. Passa para Plan Mode (Shift+Tab) e pede um plano para «preparar a estrutura do projeto: uma pasta para os skills, uma para os registos, um ficheiro de configuração» — observa que ele planeia em vez de executar.
  5. Desafia o plano: pede-lhe para justificar uma escolha ou adicionar uma etapa.
  6. Passa para Auto-Edit e deixa-o executar o plano validado sem interrupção.
  7. Termina com /clear para recomeçares limpo antes do capítulo seguinte.
Dica — Podes mudar de modo a qualquer momento com Shift+Tab; começa restritivo, termina permissivo. E se hesitares numa permissão, não a concedas globalmente: aceita apenas «só desta vez».

Em resumo

  • Autoriza os comandos não destrutivos uma vez para deixares de os revalidar: a fricção mecânica mata a vigilância.
  • As permissões vivem em .claude/settings.local.json (local), .claude/settings.json (projeto) e ~/.claude/settings.json (global); deny prevalece sempre.
  • Fica em Plan Mode para conceber e debater, passa para Auto-Edit para executar depressa (Shift+Tab).
  • --dangerously-skip-permissions existe para as tarefas longas em ambiente isolado — nunca com dados sensíveis.
  • /clear entre duas tarefas sem relação; /compact a meio de uma tarefa longa que satura.
  • O ruído das tarefas anteriores degrada as respostas: um contexto limpo é uma alavanca de qualidade gratuita.
  • O CLAUDE.md (capítulo 8) garante que o essencial do projeto sobrevive aos /clear.

Quiz — verifica a tua compreensão

1. Quando deves ficar em Plan Mode?

O modo restritivo serve para a conceção; passa-se para Auto-Edit quando o plano está fechado.

2. Porquê limpar o contexto entre duas tarefas?

Um contexto limpo dá respostas mais pertinentes; o CLAUDE.md permite recarregar o essencial.

3. Qual é a diferença entre /clear e /compact?

/clear recomeça do zero (entre duas tarefas); /compact condensa a conversa em curso para libertar espaço sem perder o fio.

4. Em que ficheiro aterram as permissões concedidas localmente para um projeto?

O settings.local.json contém as tuas permissões locais do projeto, não versionadas no Git. O settings.json (projeto) serve para as regras partilhadas em equipa.

5. Qual é o bom uso de --dangerously-skip-permissions?

Este modo desativa todas as validações: só faz sentido em tarefas bem definidas, num ambiente em que um erro não custa nada.

Auteur(s)

R

REHOUMA Haythem

Haythem Rehouma est un ingénieur et architecte IA et cloud, formateur et enseignant technique, avec un profil orienté IA médicale, AWS, MLOps, LLM/RAG et vision par ordinateur.