Claude Code Cheatsheet — André Costa

01

Instalação

Iniciante

Requisitos: terminal, Node.js 18+ (para npm), Git e uma conta Anthropic (assinatura Claude ou Console).

macOS / Linux (curl)

Método recomendado — instalação automática do binário nativo

curl -fsSL https://claude.ai/install.sh | bash

macOS (Homebrew)

Para quem já usa Homebrew

brew install --cask claude-code

Windows (PowerShell)

Instalação no Windows via PowerShell

irm https://claude.ai/install.ps1 | iex

npm (global)

Requer Node.js 18+. Útil em ambientes onde curl não está disponível.

npm install -g @anthropic-ai/claude-code

Iniciar, Atualizar e Verificar

cd seu-projeto && claude

claude update

claude auth status

claude install stable

O Claude Code atualiza automaticamente por padrão. Para desabilitar: claude config set autoUpdate false. Para instalar uma versão específica: claude install 2.1.118.

Problemas comuns de instalação: Se o comando claude não for encontrado após a instalação, adicione o diretório de instalação (geralmente ~/.local/bin no Linux ou ~/.claude/bin no macOS) ao seu PATH. No Windows, certifique-se de que o PowerShell ExecutionPolicy permite scripts.

02

Atalhos de Teclado

Iniciante

Atalhos universais do Claude Code CLI. No VS Code / Cursor / JetBrains, alguns atalhos são mapeados nativamente.

! Prefixo modo Bash — executa comando direto no shell sem passar pelo LLM

@ Mencionar arquivos, pastas ou recursos MCP no prompt (ex: @src/utils.js)

\ Quebra de linha no prompt (backslash + Enter) para prompts multi-linha

Esc Interrompe o Claude imediatamente (stop generation)

Esc + Esc Abre menu de rewind (desfazer alterações de código e/ou conversa)

Ctrl + R Mostra saída/contexto completo da resposta (expande conteúdo truncado)

Ctrl + V Cola imagem direto no chat (análise de screenshots, diagramas, mockups)

Shift + Tab Cicla modos de permissão: default → acceptEdits → plan (e auto, se habilitado)

Shift + Tab + Tab Modo Planejamento — Claude pensa e propõe antes de editar arquivos

Cmd + Esc / Ctrl + Esc Abre Claude Code dentro do IDE (VS Code, Cursor, JetBrains)

Cmd + Opt + K / Alt + Ctrl + K Insere referências de arquivo no prompt (equivalente a digitar @)

Ctrl + G Abre o plano proposto no modo plan no editor de texto padrão para edição manual

No VS Code, use Cmd/Ctrl + Shift + J para abrir o painel do Claude Code. No JetBrains, o atalho padrão é Alt + Shift + C. Verifique os keymaps do seu IDE se não funcionar.

03

Comandos Slash

Iniciante

Digite diretamente no chat do Claude Code durante uma sessão interativa. Todos os comandos abaixo funcionam em qualquer superfície (CLI, IDE, Web).

Comando	O que faz	Exemplo de uso
`/add-dir`	Adiciona diretórios de trabalho adicionais ao contexto	`/add-dir ../shared-lib`
`/agents`	Gerencia subagentes customizados (criar, editar, deletar)	`/agents` → abre interface tabbed
`/bug`	Reporta bug (envia conversa para a Anthropic)	`/bug "erro ao compactar contexto"`
`/clear`	Limpa o histórico da conversa atual (mantém arquivos)	`/clear`
`/compact [instruções]`	Compacta a conversa com instruções opcionais de foco	`/compact mantenha apenas decisões de arquitetura`
`/config`	Visualiza ou modifica configurações em tempo real	`/config` → lista todas as configurações
`/cost`	Mostra estatísticas de uso de tokens da sessão	`/cost`
`/exit`	Sai do Claude Code (salva sessão automaticamente)	`/exit`
`/feedback`	Envia feedback sobre respostas do Claude	`/feedback "classificador bloqueou ação legítima"`
`/help`	Lista todos os comandos e atalhos disponíveis	`/help`
`/init`	Inicializa configuração do projeto (cria .claude/)	`/init`
`/login`	Autentica com sua conta Anthropic	`/login --console` (para API billing)
`/logout`	Desconecta da conta	`/logout`
`/memory`	Gerencia memória persistente do projeto	`/memory add "use snake_case em Python"`
`/model`	Altera o modelo Claude em uso na sessão atual	`/model sonnet`
`/mcp`	Gerencia servidores MCP conectados	`/mcp` → lista, adiciona, remove
`/permissions`	Mostra e gerencia permissões da sessão	`/permissions` → aba Recently denied
`/plan`	Prefixa um prompt para forçar modo plan (pesquisa sem editar)	`/plan como refatorar o auth module?`
`/pr`	Cria ou gerencia Pull Requests	`/pr` → cria PR com gh pr create
`/rename`	Renomeia a sessão atual	`/rename auth-refactor`
`/resume`	Retoma uma sessão anterior por nome ou ID	`/resume` → mostra picker de sessões
`/review`	Solicita revisão de código do changeset atual	`/review`
`/rewind`	Abre menu de rewind via comando	`/rewind`
`/status`	Mostra status atual da sessão (modo, modelo, custo)	`/status`
`/terminal`	Abre terminal integrado (em IDEs e Desktop)	`/terminal`
`/token`	Mostra contagem de tokens da conversa	`/token`
`/web`	Busca informações na web	`/web "última versão do React"`

Use /plan como prefixo em qualquer prompt para forçar o modo de planejamento sem precisar ciclar com Shift+Tab. Útil quando você quer explorar antes de comprometer alterações.

04

Configuração

Intermediário

Arquivos de configuração por prioridade (do mais alto ao mais baixo). Quanto mais alto na lista, maior a prioridade — valores de baixo são sobrescritos.

1

/etc/claude-code/managed-settings.json Enterprise — maior prioridade, definido por admins

2

.claude/settings.local.json Pessoal do projeto (git-ignored, não commitado)

3

.claude/settings.json Compartilhado com o time (commitado no repo)

4

~/.claude/settings.json Global do usuário (aplica a todos os projetos)

Ver todas as configurações

claude config list

Ler valor específico

claude config get <chave>

Definir valor

claude config set <chave> <valor>

Adicionar a lista

claude config add <chave> <valor>

Remover da lista

claude config remove <chave> <valor>

Configurar via arquivo

~/.claude/settings.json

Edite o JSON diretamente para configurações complexas

Todas as chaves de configuração

Chave	Tipo	Descrição
`autoUpdate`	boolean	Atualiza o binário automaticamente ao iniciar
`theme`	string	Tema do terminal (dark, light, system)
`model`	string	Modelo padrão (sonnet, opus, haiku)
`permissions.defaultMode`	string	Modo de permissão padrão (default, acceptEdits, plan, auto, dontAsk, bypassPermissions)
`permissions.allow`	array	Regras de permissão allow (ferramentas pre-aprovadas)
`permissions.ask`	array	Regras ask (sempre perguntar antes)
`permissions.deny`	array	Regras deny (sempre bloquear)
`permissions.disableAutoMode`	string	"disable" para bloquear auto mode em enterprise
`permissions.disableBypassPermissionsMode`	string	"disable" para bloquear bypassPermissions em enterprise
`hooks`	object	Hooks configurados (pre-prompt, post-tool, etc.)
`env`	object	Variáveis de ambiente injetadas nas sessões
`additionalDirectories`	array	Diretórios adicionais fora do repo para contexto
`showClearContextOnPlanAccept`	boolean	Oferece limpar contexto de planejamento ao aprovar plano
`outputStyle`	string	Estilo de saída: "proactive" para comportamento mais autônomo

Em ambientes Enterprise, managed-settings.json pode bloquear certas configurações. Se uma configuração não surtir efeito, verifique se não está sendo sobrescrita por políticas administrativas.

05

Modelos Disponíveis

Iniciante

O Claude Code suporta múltiplos modelos Claude. Cada um tem trade-offs entre capacidade, velocidade e custo.

Mais Capaz

`claude-opus-4`

Maior capacidade de raciocínio. Ideal para arquitetura complexa, debugging difícil e grandes refatorações. Mais lento e caro.

Recomendado

`claude-sonnet-4`

Equilíbrio perfeito entre capacidade e velocidade. O padrão para maioria das tarefas. Suporta auto mode.

Rápido

`claude-haiku-3`

Extremamente rápido e barato. Ideal para buscas simples, exploração de código e tarefas repetitivas.

Alternar modelo

/model sonnet

claude --model opus

claude config set model sonnet

Você pode alternar modelos mid-session com /model. Subagentes podem usar modelos diferentes do agente principal — útil para delegar tarefas simples ao Haiku enquanto o main thread usa Sonnet.

Requisitos de auto mode: Sonnet 4.6+ ou Opus 4.6+ na Anthropic API. No Bedrock, Vertex AI e Foundry, apenas Opus 4.7 e 4.8 são suportados. Haiku e modelos claude-3 não suportam auto mode.

06

Contexto e Janela

Intermediário

O Claude Code gerencia automaticamente o context window, mas entender os limites ajuda a evitar perda de informação em sessões longas.

Limites de contexto

Claude Opus 4: ~200K tokens
Claude Sonnet 4: ~200K tokens
Claude Haiku 3: ~200K tokens
Cada arquivo lido, comando executado e mensagem consome tokens
O Claude lê arquivos sob demanda — não carrega o repo inteiro

Quando compactar

Sessões com >50 mensagens de back-and-forth
Muitos arquivos grandes foram lidos
O Claude parece "esquecer" instruções anteriores
Respostas ficam mais lentas
Use /compact com instruções de foco

Gerenciamento de contexto

/token

/compact mantenha apenas as decisões de arquitetura

/clear

/compact resume a conversa mantendo apenas o essencial. /clear apaga todo o histórico de mensagens (mantém arquivos editados). Subagentes ajudam a preservar contexto delegando pesquisas para janelas separadas.

Use subagentes para pesquisas extensas. Em vez de encher seu contexto principal com 20 arquivos lidos, delegue: use a subagent to investigate how our auth system handles token refresh. O subagente retorna apenas o resumo.

07

Checkpoint — Undo & Rewind

Iniciante

Rede de segurança automática. O Claude Code rastreia todas as edições de arquivo, permitindo voltar a estados anteriores rapidamente.

Abrir menu de rewind

Esc + Esc

/rewind

Tipos de rewind

Conversation Rewind — volta a mensagem anterior, mantém código
Code Rewind — reverte arquivos, mantém conversa
Full Rewind — volta código e conversa juntos

Fluxo de rewind (conceitual)

Estado Atual

←

Última Edição

←

Mensagem Anterior

←

Início da Sessão

O checkpoint cria snapshots automáticos a cada ação. Você pode navegar para trás em qualquer ponto. O histórico é linear — não há branches de checkpoints.

Limitações: Alterações feitas por comandos bash (rm, mv, cp) e edições manuais fora do Claude Code não são rastreadas. Use checkpoints para recuperação rápida e Git para histórico permanente. Checkpoints são locais e não sincronizam entre máquinas.

08

MCP Servers

Intermediário

Model Context Protocol — conecte ferramentas externas (bancos de dados, APIs, navegador) ao Claude Code via servidores MCP.

Gerenciar MCPs

/mcp

Lista, adiciona, remove ou configura servidores MCP interativamente

Configurar via arquivo

.claude/mcp.json

Arquivo de configuração de MCPs do projeto (commitado com o time)

MCPs populares

Servidor	Instalação	Uso
`filesystem`	`npx -y @modelcontextprotocol/server-filesystem /path`	Acesso a arquivos fora do working directory
`fetch`	`uvx mcp-server-fetch`	Requisições HTTP genéricas (GET, POST, etc.)
`git`	`npx -y @modelcontextprotocol/server-git`	Operações git avançadas (blame, log, diff)
`postgres`	`npx -y @modelcontextprotocol/server-postgres`	Consultas SQL em bancos PostgreSQL
`sqlite`	`npx -y @modelcontextprotocol/server-sqlite`	Consultas em bancos SQLite locais
`puppeteer`	`npx -y @modelcontextprotocol/server-puppeteer`	Automação de browser (screenshots, scraping)
`github`	`npx -y @modelcontextprotocol/server-github`	API do GitHub (issues, PRs, repos)

Exemplo de configuração MCP

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/caminho/do/projeto"]
    },
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/db"]
    }
  }
}

Debug de conexão MCP: Se um MCP não conectar, verifique: (1) o comando está no PATH, (2) as dependências estão instaladas (Node, uv, etc.), (3) o arquivo .claude/mcp.json é JSON válido. Use /mcp para ver logs de erro de cada servidor.

09

Agent Skills

Intermediário

Skills são instruções customizadas que ensinam o Claude a executar tarefas específicas do seu projeto ou workflow. O Claude invoca skills automaticamente baseado no contexto.

Criar uma skill

/agents

Gerencia subagentes e skills customizadas via interface interativa

Diretório de skills

.claude/skills/

Salve arquivos .md com instruções de skills. O nome do arquivo vira o comando slash.

Exemplo de skill completa

---
name: code-review
description: Reviews code for quality and best practices. Use when reviewing code, checking PRs, or analyzing code quality.
disable-model-invocation: true
---

Ao revisar código, verifique:
1. Segurança (injeção SQL, XSS, CSRF, etc.)
2. Performance (N+1, loops desnecessários, queries pesadas)
3. Legibilidade (nomes claros, funções pequenas, comentários úteis)
4. Testes (cobertura mínima 80%, edge cases)
5. Convenções do projeto (lint, formatação, padrões)

Sempre sugira melhorias com exemplos de código.
Se encontrar um bug crítico, pare e reporte imediatamente.

Skills com disable-model-invocation: true não são invocadas automaticamente pelo modelo — você as chama explicitamente com /nome-da-skill. Útil para skills que só fazem sentido em momentos específicos.

10

Subagentes

Avançado

Subagentes são assistentes de IA especializados que trabalham em janelas de contexto independentes. Use-os para preservar seu contexto principal enquanto delega pesquisas, análises ou tarefas paralelas.

Subagentes built-in

Explore — agente read-only rápido (Haiku) para busca e exploração de código
Plan — pesquisa e propõe mudanças sem editar arquivos
General-purpose — subagente genérico para tarefas diversas

Criar subagente customizado

/agents

claude --agents '{"code-reviewer": {...}}'

Arquivo de subagente

---
name: code-reviewer
description: Expert code reviewer. Use proactively after code changes.
tools: Read, Glob, Grep, Bash
disallowedTools: Write, Edit
model: sonnet
permissionMode: acceptEdits
memory: user
color: "#3B7AB8"
---

You are a senior code reviewer. Focus on:
- Code quality and maintainability
- Security vulnerabilities
- Performance bottlenecks
- Test coverage gaps

Always provide specific line references and suggest concrete improvements.

Escopos de subagente (prioridade)

Local	Escopo	Prioridade
`managed settings`	Organização (enterprise)	1 (mais alta)
`--agents CLI flag`	Sessão atual apenas	2
`.claude/agents/`	Projeto atual	3
`~/.claude/agents/`	Todos os projetos (pessoal)	4
`plugin agents/`	Onde o plugin está ativo	5 (mais baixa)

Subagentes podem rodar em foreground (você vê o progresso em tempo real) ou background (você continua trabalhando enquanto eles processam). Use background para tarefas longas como análise de codebase completa.

11

Plugins

Avançado

Plugins empacotam skills, subagentes, hooks, MCPs e LSPs em unidades distribuíveis. Compartilhe com seu time ou publique na marketplace da comunidade.

Quando usar plugins

Compartilhar funcionalidade entre múltiplos projetos
Distribuir para a comunidade
Versionar e atualizar extensions
Empacotar LSP servers customizados

Quando NÃO usar plugins

Customizações pessoais de um único projeto
Experimentos rápidos (use .claude/ direto)
Quando você quer nomes curtos de skill (plugins usam namespace)

Estrutura de um plugin

my-plugin/
├── .claude-plugin/
│   └── plugin.json          # manifesto (nome, descrição, versão, autor)
├── skills/
│   └── code-review/
│       └── SKILL.md         # skills com namespace /my-plugin:code-review
├── agents/
│   └── security-reviewer.md # subagentes do plugin
├── hooks/
│   └── hooks.json           # event handlers
├── .mcp.json                # MCP servers do plugin
├── .lsp.json                # Language servers
├── monitors/
│   └── monitors.json        # background monitors
├── settings.json            # configurações padrão quando ativo
└── bin/                     # executáveis adicionados ao PATH

Criar plugin

claude plugin init my-tool

Scaffold automático em ~/.claude/skills/my-tool/

Testar plugin local

claude --plugin-dir ./my-plugin

Carrega o plugin sem precisar instalar. Aceita também .zip

Namespace: Skills de plugins sempre usam namespace. Uma skill hello no plugin my-first-plugin é invocada como /my-first-plugin:hello. Isso previne conflitos entre plugins.

12

Permissões

Intermediário

Controle quais ações o Claude pode executar automaticamente sem pedir confirmação. O modo de permissão define o nível de supervisão da sessão.

Modo	O que executa sem perguntar	Ideal para
`default`	Apenas leitura de arquivos	Começando, trabalho sensível
`acceptEdits`	Leitura + edição de arquivos + comandos filesystem comuns	Iterando em código que você revisa
`plan`	Apenas leitura (pesquisa sem editar)	Explorar codebase antes de mudar
`auto`	Tudo, com verificação de segurança por classifier	Tarefas longas, reduzir fadiga de prompts
`dontAsk`	Apenas ferramentas pre-aprovadas (allow rules)	CI/CD pipelines, ambientes restritos
`bypassPermissions`	Tudo sem verificação	Containers isolados e VMs apenas

Ciclar modos (CLI)

Shift + Tab

Cicla: default → acceptEdits → plan. Auto aparece se sua conta atender os requisitos. BypassPermissions aparece se iniciado com a flag.

Iniciar em modo específico

claude --permission-mode plan

claude --permission-mode acceptEdits

Configurar modo padrão

{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

Salve em ~/.claude/settings.json ou .claude/settings.json

Resetar permissões

/permissions

Mostra a aba "Recently denied" onde você pode revisar e re-aprovar ações bloqueadas.

Protected paths: Em todo modo exceto bypassPermissions, escritas em .git, .claude (exceto worktrees), .vscode, .bashrc, .envrc e outros arquivos críticos nunca são auto-aprovadas. Isso protege contra corrupção acidental.

13

Git Worktrees

Intermediário

Trabalhe em múltiplas branches simultaneamente sem conflitos de arquivos. Cada worktree é um checkout isolado em seu próprio diretório.

Iniciar sessão em worktree

claude --worktree feature-auth

Cria um worktree git isolado na branch feature-auth e inicia o Claude Code lá

Sessões paralelas

claude --worktree fix-bug

Em outro terminal, inicie uma sessão paralela em outra branch. As edições não colidem.

Como funciona

Terminal 1 main branch

⇄

Terminal 2 feature-auth (worktree)

⇄

Terminal 3 fix-bug (worktree)

Cada worktree tem seu próprio diretório de trabalho, staging area e sessão do Claude Code. O Claude armazena seus próprios worktrees em .claude/worktrees/ para não poluir seu repo.

Para monitorar múltiplas sessões paralelas de uma única tela em vez de terminais separados, use background agents (agentes em background). Eles aparecem na interface do /agents com status em tempo real.

14

Hooks

Avançado

Automatize ações antes ou depois de eventos do Claude Code. Hooks rodam comandos shell em momentos específicos do ciclo de vida da sessão.

Hooks disponíveis

pre-prompt — antes de cada prompt ser enviado ao modelo
post-prompt — depois de cada resposta ser recebida
pre-tool — antes de executar uma ferramenta (pode bloquear)
post-tool — depois de executar uma ferramenta
pre-exit — antes de sair do Claude
PermissionRequest — quando uma permissão é solicitada
PreToolUse — hook avançado para lógica customizada de permissão

Arquivo de hooks

.claude/hooks.json

Configure hooks por projeto. Também podem ser definidos em ~/.claude/hooks.json para todos os projetos.

Exemplo de hooks

{
  "pre-prompt": [
    "echo 'Iniciando sessão Claude Code'"
  ],
  "post-tool": [
    "git diff --stat"
  ],
  "pre-exit": [
    "echo 'Sessão encerrada. Commits pendentes:'",
    "git status --short"
  ]
}

Hooks em subagentes: Você pode definir hooks específicos para subagentes no frontmatter do arquivo do agente. Hooks de subagente têm escopo local — não afetam o agente principal.

15

Variáveis de Ambiente

Intermediário

O Claude Code respeita e utiliza diversas variáveis de ambiente para configuração, autenticação e comportamento.

Variável	Descrição	Exemplo
`ANTHROPIC_API_KEY`	Chave da API Anthropic (alternativa ao login web)	`sk-ant-...`
`ANTHROPIC_BASE_URL`	URL base customizada (LLM gateways, proxies)	`https://gateway.company.com`
`CLAUDE_CODE_ENABLE_AUTO_MODE`	Habilita auto mode no Bedrock/Vertex/Foundry	`1`
`CLAUDE_CODE_DEBUG`	Ativa logs de debug detalhados	`1`
`CLAUDE_CODE_NO_TELEMETRY`	Desabilita telemetria (crash reports, usage)	`1`
`HOME`	Diretório home do usuário (onde .claude/ fica)	`/home/usuario`
`PATH`	Binários disponíveis para o tool Bash	`/usr/local/bin:...`
`EDITOR`	Editor padrão para abrir planos (Ctrl+G)	`code --wait`
`GIT_EDITOR`	Editor para commits gerados pelo Claude	`vim`
`NO_COLOR`	Desabilita cores na saída do terminal	`1`

Defina env vars permanentes no bloco env de ~/.claude/settings.json. Elas serão injetadas em todas as sessões: {"env": {"CLAUDE_CODE_ENABLE_AUTO_MODE": "1"}}.

16

Modo Auto & Non-Interactive

Avançado

Execute o Claude Code sem interação humana — ideal para CI/CD, scripts, automações e tarefas longas.

Executar em modo headless

claude -p "descreva o que fazer"

Flag -p (ou --prompt) executa via SDK e sai. Ideal para pipes e scripts.

Aprovar tudo automaticamente

claude -p "refatore o código" --yes

--yes aprova todas as ações. Equivalente a --permission-mode acceptEdits em non-interactive.

Usar arquivo de instruções

claude -p-file instrucoes.md --yes

Lê o prompt de um arquivo. Útil para prompts longos que não cabem na linha de comando.

Pipe de stdin

git log --oneline -20 | claude -p "resuma commits"

O Claude processa stdin como contexto. Funciona como qualquer ferramenta Unix.

Flags úteis para automação

Flag	Descrição	Exemplo
`-p, --prompt`	Prompt não-interativo (SDK mode)	`claude -p "fix tests"`
`--prompt-file`	Lê prompt de arquivo	`claude --prompt-file prompt.md`
`--yes`	Aprova todas as ações	`claude -p "refactor" --yes`
`--output`	Salva resposta em arquivo	`claude -p "summarize" --output out.txt`
`--model`	Define modelo específico	`claude -p "review" --model opus`
`--cwd`	Define diretório de trabalho	`claude -p "test" --cwd ./backend`
`--permission-mode`	Modo de permissão (plan, auto, dontAsk, etc.)	`claude -p "deploy" --permission-mode dontAsk`
`-c, --continue`	Continua sessão mais recente	`claude -c -p "continue task"`
`-r, --resume`	Retoma sessão por nome ou ID	`claude -r "auth-refactor"`
`--worktree`	Executa em git worktree isolado	`claude -p "fix" --worktree bugfix`

Limitações do modo auto: O classifier pode bloquear ações que ele julgue arriscadas (downloads, deploys, deleções em massa). Se 3 ações seguidas ou 20 no total forem bloqueadas, o auto mode pausa e volta a pedir confirmação. Em non-interactive (-p), sessões abortam se não houver usuário para aprovar.

17

Workflows Práticos

Iniciante Intermediário

Exemplos reais de uso do Claude Code no dia a dia. Copie, adapte e execute.

🔍 Como fazer code review

Revise código de forma estruturada, identificando bugs, problemas de performance e violações de padrões.

Entre no diretório do projeto: cd meu-projeto && claude
Peça uma revisão do changeset atual: /review
Ou revise arquivos específicos: review @src/auth.js @src/users.js
Para revisão profunda, use um subagente: use a subagent to do a security review of the auth module
Peça correções: fix the SQL injection vulnerability you found

claude -p "review the auth module for security issues" --model opus

🔧 Como refatorar um módulo

Refatore código legado com segurança, mantendo comportamento e melhorando qualidade.

Entre em modo plan: Shift + Tab até plan (ou claude --permission-mode plan)
Pesquise antes de mudar: /plan como refatorar utils.js para usar ES2024?
Revise o plano proposto. Edite com Ctrl + G se necessário.
Aprove o plano — o Claude sai do plan mode e começa a editar.
Verifique: run the tests to make sure nothing broke

claude --permission-mode plan -p "refactor utils.js to use modern JavaScript features while maintaining the same behavior"

🐛 Como debugar com Claude

Use o Claude para investigar erros, analisar stack traces e encontrar root causes.

Compartilhe o erro: I'm seeing an error when I run npm test
Forneça o stack trace (cole ou use ! para rodar o comando)
Peça análise de root cause: what's the root cause of this error?
Solicite fix: fix the null pointer exception in user.ts
Verifique o fix: run the tests again

!npm test 2>&1 | claude -p "find and fix the bug causing these test failures"

📦 Como criar uma skill do zero

Crie uma skill customizada para automatizar tarefas recorrentes do seu time.

Crie o diretório: mkdir -p .claude/skills/deploy-check
Crie o arquivo .claude/skills/deploy-check/SKILL.md:

---
name: deploy-check
description: Runs pre-deploy checks. Use before deploying to production.
---

Before any deployment, verify:
1. All tests pass (run test suite)
2. No console.log left in production code
3. Environment variables are documented in .env.example
4. Database migrations are reversible
5. No secrets committed to git

Report any blockers and refuse to proceed if critical issues are found.

Recarregue: /reload-plugins (ou reinicie o Claude)
Use: /deploy-check

🚀 Como criar um PR completo

Do código ao PR, com descrição, review e merge.

Faça as mudanças com o Claude interativamente
Summarize: summarize the changes I've made
Crie o PR: /pr (ou create a pr for my changes)
O Claude usa gh pr create e linka a sessão ao PR
Retome depois: claude --from-pr 123

claude -p "create a PR for the auth refactor with a detailed description" --yes

18

Troubleshooting

Iniciante Intermediário

Erros comuns e como resolver. Se nada funcionar, /bug reporta direto para a Anthropic.

`claude: command not found`

O binário não está no PATH. Adicione o diretório de instalação:

export PATH="$HOME/.local/bin:$PATH"

No macOS geralmente é ~/.claude/bin. No Windows, verifique se o PowerShell ExecutionPolicy permite scripts.

Auth falha / sessão expirada

Reautentique com sua conta Anthropic:

claude auth login

claude auth status

Use --console se estiver usando Anthropic Console em vez de assinatura Claude.

MCP não conecta

Verifique passo a passo:

O comando do MCP está no PATH? Teste no terminal.
As dependências estão instaladas? (Node.js, uv, Python, etc.)
O .claude/mcp.json é JSON válido? Valide com jq.
Use /mcp para ver logs de erro específicos de cada servidor.

Permissão negada em arquivos protegidos

Arquivos em protected paths (como .git/, .bashrc, .envrc) nunca são auto-aprovados. Isso é por design. Edite manualmente ou use bypassPermissions em containers isolados.

Auto mode não aparece no ciclo

Requisitos não atendidos. Verifique:

Modelo: Sonnet 4.6+ ou Opus 4.6+ (Anthropic API)
Em Bedrock/Vertex/Foundry: apenas Opus 4.7/4.8 e CLAUDE_CODE_ENABLE_AUTO_MODE=1
Enterprise: admin deve habilitar auto mode nas configurações
defaultMode: "auto" em .claude/settings.json é ignorado (use ~/.claude/settings.json)

Contexto muito grande / respostas lentas

Compacte ou limpe o contexto:

/compact mantenha apenas decisões de arquitetura

/clear

Use subagentes para pesquisas extensas. Eles trabalham em janelas de contexto separadas.

Sessão travou / não responde

Interrompa com Esc ou Ctrl+C. Se persistir, saia e retome:

claude --continue

Se o problema for recorrente, reporte com /bug ou atualize: claude update.