50 Dicas do Claude Code: Melhores Práticas para Usar Todo Dia

Você já usa o Claude Code há tempo suficiente para saber que ele funciona, e agora está em busca de cada vantagem que puder encontrar. Reuní 50 melhores práticas e dicas do Claude Code que ajudam tanto quem está na primeira semana quanto quem já usa há vários meses — extraídas da documentação oficial da Anthropic, de Boris Cherny (a pessoa que o criou), da experiência da comunidade e de um ano de uso diário pessoal.

1. Configure o alias cc

É assim que começo cada sessão do Claude Code. Adicione isso ao seu ~/.zshrc (ou ~/.bashrc):

alias cc='claude --dangerously-skip-permissions'

Execute source ~/.zshrc para carregar. Agora você digita cc em vez de claude e pula todos os prompts de permissão. O nome da flag é intencionalmente assustador. Use-a apenas depois de entender completamente o que o Claude Code pode e irá fazer na sua base de código. Leia também: personalizando o Claude Code.

2. Prefixe ! para executar comandos bash diretamente

Digite !git status ou !npm test e o comando é executado imediatamente. O comando e sua saída ficam no contexto, então o Claude pode ver o resultado e agir com base nele. É mais rápido do que pedir ao Claude para executar um comando.

3. Pressione Esc para parar o Claude. Pressione Esc+Esc para desfazer qualquer coisa.

Esc interrompe o Claude no meio de uma ação sem perder o contexto. Você pode redirecionar imediatamente.

Esc+Esc (ou /rewind) abre um menu rolável com todos os checkpoints que o Claude criou. Você pode restaurar o código, a conversa, ou ambos. “Desfaça isso” também funciona. Quatro opções de restauração: código e conversa, somente conversa, somente código, ou resumir a partir de um checkpoint.

Isso significa que você pode tentar a abordagem da qual está apenas 40% confiante. Se funcionar, ótimo. Se não, dê o rewind. Nenhum dano causado. Uma ressalva: checkpoints rastreiam apenas edições de arquivos. Alterações feitas por comandos bash (migrações, operações de banco de dados) não são capturadas.

Para continuar de onde parou, claude –continue retoma sua conversa mais recente e claude –resume abre um seletor de sessões.

4. Dê ao Claude uma forma de verificar o próprio trabalho

Ofereça um ciclo de feedback para que ele encontre seus próprios erros. Inclua comandos de teste, verificações de linter ou saídas esperadas no seu prompt.

Refatore o middleware de auth para usar JWT em vez de tokens de sessão.
Execute a suite de testes existente após as alterações.
Corrija qualquer falha antes de considerar concluído.

O Claude executa os testes, vê as falhas e as corrige sem você precisar intervir. Boris Cherny diz que isso sozinho representa uma melhoria de qualidade de 2-3x. Para mudanças de UI, configure o servidor MCP do Playwright para que o Claude possa abrir um navegador, interagir com a página e verificar se a UI funciona conforme o esperado. Esse ciclo de feedback detecta problemas que testes unitários perdem.

5. Instale um plugin de inteligência de código para sua linguagem

Plugins LSP fornecem ao Claude diagnósticos automáticos após cada edição de arquivo. Erros de tipo, imports não utilizados, tipos de retorno ausentes. O Claude vê e corrige os problemas antes mesmo de você notá-los. Este é o plugin de maior impacto que você pode instalar.

Escolha o seu e execute o comando de instalação:

/plugin install typescript-lsp@claude-plugins-official
/plugin install pyright-lsp@claude-plugins-official
/plugin install rust-analyzer-lsp@claude-plugins-official
/plugin install gopls-lsp@claude-plugins-official

Plugins para C#, Java, Kotlin, Swift, PHP, Lua e C/C++ também estão disponíveis. Execute /plugin e vá para a aba Discover para ver a lista completa. Você precisará do binário do servidor de linguagem correspondente instalado no sistema (o plugin informará se estiver faltando).

6. Use a CLI do gh e ensine o Claude qualquer ferramenta de linha de comando

A CLI do gh gerencia PRs, issues e comentários sem um servidor MCP separado. Ferramentas CLI são mais eficientes em contexto do que servidores MCP porque não carregam esquemas de ferramentas na sua janela de contexto. O mesmo vale para jq, curl e outras ferramentas CLI padrão.

Para ferramentas que o Claude ainda não conhece: “Use ‘sentry-cli –help’ para aprender sobre ela, depois use-a para encontrar o erro mais recente em produção.” O Claude lê a saída de ajuda, descobre a sintaxe e executa os comandos. Até CLIs internas de nicho funcionam.

7. Adicione “ultrathink” para raciocínio complexo

É uma palavra-chave que define o esforço como alto e aciona o raciocínio adaptativo no Opus 4.6. O Claude aloca dinamicamente o pensamento com base no problema. Use para decisões de arquitetura, depuração difícil, raciocínio em múltiplas etapas ou qualquer situação em que você queira que o Claude pense antes de agir.

Você também pode definir o esforço permanentemente com /effort. Para tarefas menos complexas, níveis de esforço mais baixos mantêm tudo rápido e barato. Combine o esforço ao problema. Não há sentido em queimar tokens de pensamento em uma simples renomeação de variável.

8. Use skills para conhecimento sob demanda

Skills são arquivos markdown que estendem o conhecimento do Claude sob demanda. Ao contrário do CLAUDE.md que carrega a cada sessão, as skills carregam apenas quando relevantes para a tarefa atual. Isso mantém seu contexto enxuto.

Crie skills em .claude/skills/ ou instale plugins que agrupam skills pré-construídas (execute /plugin para navegar pelo que está disponível). Use skills para conhecimento especializado de domínio (convenções de API, procedimentos de deploy, padrões de código) que o Claude precisa às vezes, mas não sempre.

9. Controle o Claude Code pelo celular

Execute claude remote-control para iniciar uma sessão, depois conecte-se a ela em claude.ai/code ou no app Claude para iOS/Android. A sessão roda localmente na sua máquina. O celular ou navegador é apenas uma janela para ela. Você pode enviar mensagens, aprovar chamadas de ferramentas e monitorar o progresso de qualquer lugar.

Se você estiver usando o alias cc da dica #1, o Claude já tem permissões completas e não precisará de aprovação para cada ação. Isso torna o controle remoto ainda mais fluido: inicie uma tarefa, afaste-se e volte pelo celular apenas quando o Claude terminar ou encontrar algo inesperado.

10. Expanda sua janela de contexto para 1M de tokens

Tanto o Sonnet 4.6 quanto o Opus 4.6 suportam janelas de contexto de 1M de tokens. Nos planos Max, Team e Enterprise, o Opus é automaticamente atualizado para contexto de 1M. Você também pode trocar de modelo durante a sessão com /model opus[1m] ou /model sonnet[1m].

Se você estiver preocupado com a qualidade em contextos maiores, comece em 500k e vá aumentando gradualmente. Contexto maior significa mais espaço antes da compactação, mas a qualidade das respostas pode variar dependendo da tarefa. Use CLAUDE_CODE_AUTO_COMPACT_WINDOW para controlar quando a compactação é acionada e CLAUDE_AUTOCOMPACT_PCT_OVERRIDE para definir o limite percentual. Encontre o ponto ideal para o seu fluxo de trabalho.

11. Use o Modo de Planejamento quando não sabe como abordar algo

Use o Modo de Planejamento para mudanças em múltiplos arquivos, código desconhecido e decisões arquiteturais. O custo extra é real (alguns minutos a mais no início), mas evita que o Claude passe 20 minutos resolvendo com confiança o problema errado por completo.

Pule-o para tarefas pequenas e de escopo claro. Se você consegue descrever o diff em uma frase, faça diretamente. Você pode entrar no Modo de Planejamento a qualquer momento com Shift+Tab para alternar entre os modos de permissão Normal, Auto-Aceitar e Planejamento sem sair da conversa.

12. Execute /clear entre tarefas não relacionadas

Uma sessão limpa com um prompt preciso supera uma sessão bagunçada de três horas. Tarefa diferente? /clear primeiro.

Eu sei que parece jogar fora o progresso, mas você obterá resultados melhores começando do zero. Sessões se degradam porque o contexto acumulado de trabalho anterior afoga suas instruções atuais. Os cinco segundos que leva para fazer /clear e escrever um prompt inicial focado economiza 30 minutos de retornos decrescentes.

13. Pare de interpretar bugs para o Claude. Cole os dados brutos.

Descrever um bug em palavras é lento. Você assiste o Claude adivinhar, corrige, e repete.

Cole o log de erro, a saída do CI ou a thread do Slack diretamente e diga “corrija”. O Claude lê logs de sistemas distribuídos e rastreia onde as coisas quebram. Sua interpretação adiciona uma abstração que frequentemente perde o detalhe que o Claude precisa para identificar a causa raiz. Dê ao Claude os dados brutos e saia do caminho.

Isso funciona para CI também. “Vá corrigir os testes de CI com falha” com um paste da saída do CI é um dos padrões mais confiáveis. Você também pode colar uma URL ou número de PR e pedir ao Claude para verificar as verificações com falha e corrigi-las. Com a CLI do gh da dica #6 instalada, o Claude faz o resto.

Você também pode redirecionar a saída diretamente do terminal:

cat error.log | claude "explique este erro e sugira uma correção"
npm test 2>&1 | claude "corrija os testes com falha"

14. Use /btw para perguntas rápidas paralelas

/btw abre um overlay para uma pergunta rápida sem entrar no histórico da sua conversa. Uso para esclarecimentos sobre a sessão atual: “Por que você escolheu essa abordagem?” ou “Qual é a troca com a outra opção?” A resposta aparece em um overlay descartável, seu contexto principal permanece enxuto e o Claude continua trabalhando.

15. Use --worktree para branches paralelas isoladas

claude –worktree feature-auth cria uma cópia de trabalho isolada com uma nova branch. O Claude cuida da configuração e limpeza do git worktree para você.

A equipe do Claude Code chama isso de um dos maiores ganhos de produtividade. Crie 3-5 worktrees, cada um rodando sua própria sessão do Claude em paralelo. Eu costumo rodar 2-3. Cada worktree tem sua própria sessão, sua própria branch e seu próprio estado do sistema de arquivos.

O limite em worktrees locais é a sua máquina. Múltiplos servidores de desenvolvimento, builds e sessões do Claude competindo pela CPU. A Builder.io move cada agente para seu próprio contêiner na nuvem com preview no navegador, para que sua máquina fique livre para o trabalho que precisa do seu cérebro.

16. Salve seu prompt com Ctrl+S

Você está no meio de escrever um prompt longo e percebe que precisa de uma resposta rápida primeiro. Ctrl+S salva seu rascunho. Digite sua pergunta rápida, envie e seu prompt salvo é restaurado automaticamente.

17. Mande tarefas longas para segundo plano com Ctrl+B

Quando o Claude inicia um comando bash demorado (uma suite de testes, um build, uma migração), pressione Ctrl+B para mandá-lo para o segundo plano. O Claude continua trabalhando enquanto o processo roda, e você pode continuar conversando. O resultado aparece quando o processo termina.

18. Adicione uma linha de status ao vivo

A linha de status é um shell script que roda após cada turno do Claude. Ela exibe informações ao vivo na parte inferior do terminal: diretório atual, branch do git, uso de contexto com código de cores de acordo com o preenchimento da janela.

A forma mais rápida de configurar é /statusline dentro do Claude Code. Ele perguntará o que você quer exibir e gerará o script para você. A configuração completa com um script pronto para copiar em personalizando o Claude Code.

19. Use subagentes para manter seu contexto principal limpo

“Use subagentes para descobrir como o fluxo de pagamento lida com transações falhas.” Isso gera uma instância separada do Claude com sua própria janela de contexto. Ela lê todos os arquivos, raciocina sobre a base de código e reporta de volta um resumo conciso.

Sua sessão principal permanece limpa com bastante espaço para construir algo. Uma investigação profunda pode consumir metade da sua janela de contexto antes de você escrever qualquer código. Subagentes mantêm esse custo fora da sua sessão principal. Os tipos integrados incluem Explore (Haiku, busca rápida de arquivos) e Plan (análise somente leitura). Para o quadro completo, veja nosso guia sobre subagentes e equipes de agentes.

20. Equipes de agentes para coordenação em múltiplas sessões

Experimental, mas poderoso. Ative primeiro adicionando CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS às suas configurações ou ambiente. Depois diga ao Claude para criar uma equipe: “Crie uma equipe de agentes com 3 membros para refatorar esses módulos em paralelo.” Um líder de equipe distribui o trabalho para os membros, cada um com sua própria janela de contexto e uma lista de tarefas compartilhada. Os membros podem se comunicar diretamente para coordenar.

Comece com 3-5 membros e 5-6 tarefas por membro. Evite atribuir tarefas que modifiquem os mesmos arquivos. Dois membros editando o mesmo arquivo gera sobrescritas. Comece com tarefas de pesquisa e revisão (revisões de PR, investigações de bugs) antes de tentar implementação paralela.

21. Guie a compactação com instruções

Quando o contexto compacta (automaticamente ou via /compact), diga ao Claude o que preservar: “/compact foque nas alterações da API e na lista de arquivos modificados.” Você também pode adicionar instruções permanentes ao seu CLAUDE.md: “Ao compactar, preserve a lista completa de arquivos modificados e o status atual dos testes.”

22. Use /loop para verificações recorrentes

/loop 5m verifique se o deploy foi bem-sucedido e reporte agenda um prompt recorrente que dispara em segundo plano enquanto sua sessão permanece aberta. O intervalo é opcional (padrão de 10 minutos) e suporta as unidades s, m, h e d. Você também pode fazer loops com outros comandos: /loop 20m /review-pr 1234. As tarefas têm escopo de sessão e expiram após 3 dias, então um loop esquecido não vai rodar para sempre. Use /loop para monitorar deploys, acompanhar pipelines de CI ou verificar um serviço externo enquanto você foca em outra coisa.

23. Use ditado por voz para prompts mais ricos

Execute /voice para ativar o push-to-talk e segure Espaço para ditar. Sua fala é transcrita ao vivo no prompt, e você pode misturar voz e digitação na mesma mensagem. Prompts falados naturalmente incluem mais contexto do que os digitados, porque você explica o contexto, menciona restrições e descreve o que quer sem cortar atalhos para economizar teclas. Requer uma conta Claude.ai (não chave de API). Você pode reconfigurar a tecla de push-to-talk para um combo modificador como meta+k em ~/.claude/keybindings.json para pular o aquecimento de detecção de pressionamento.

24. Após 2 correções na mesma coisa, comece do zero

Quando você e o Claude estão num ciclo de correções e o problema ainda não foi resolvido, o contexto agora está cheio de abordagens fracassadas que estão ativamente prejudicando a próxima tentativa. /clear e escreva um prompt inicial melhor que incorpore o que você aprendeu. Uma sessão limpa com um prompt mais preciso quase sempre supera uma sessão longa sobrecarregada por becos sem saída acumulados.

25. Diga ao Claude exatamente quais arquivos olhar

Use @ para referenciar arquivos diretamente: @src/auth/middleware.ts tem o tratamento de sessão. O prefixo @ resolve para o caminho do arquivo automaticamente, então o Claude sabe exatamente onde olhar.

O Claude pode fazer grep e pesquisar sua base de código por conta própria, mas ainda precisa identificar os candidatos e o arquivo certo. Cada etapa de busca custa tokens e contexto. Apontar o Claude para os arquivos certos desde o início pula todo esse processo.

26. Explore código desconhecido com prompts vagos

“O que você melhoraria neste arquivo?” é um ótimo prompt de exploração. Nem todo prompt precisa ser específico. Quando você quer um olhar fresco sobre código existente, uma pergunta vaga dá ao Claude espaço para revelar coisas que você não pensaria em perguntar.

Uso isso ao embarcar em um repositório desconhecido. O Claude aponta padrões, inconsistências e oportunidades de melhoria que eu perderia numa primeira leitura.

27. Edite planos com Ctrl+G

Quando o Claude apresenta um plano, Ctrl+G o abre no seu editor de texto para edição direta. Adicione restrições, remova etapas, redirecione a abordagem antes de o Claude escrever uma única linha de código. Útil quando o plano está quase certo mas você quer ajustar alguns passos sem re-explicar tudo.

28. Execute /init, depois corte o resultado pela metade

CLAUDE.md é um arquivo markdown na raiz do seu projeto que fornece ao Claude instruções persistentes: comandos de build, padrões de código, decisões arquiteturais, convenções do repositório. O Claude o lê no início de cada sessão. /init gera uma versão inicial com base na estrutura do seu projeto. Ele detecta comandos de build, scripts de teste e layout de diretórios.

A saída tende a ser inflada. Se você não consegue explicar por que uma linha está lá, delete-a. Corte o ruído e adicione o que está faltando. Para mais informações sobre como estruturar esses arquivos, veja como escrever um ótimo arquivo CLAUDE.md.

29. O teste decisivo para cada linha do CLAUDE.md

Para cada linha no seu CLAUDE.md, pergunte: o Claude cometeria um erro sem isso? Se o Claude já faz algo corretamente por conta própria, a instrução é ruído. Cada linha desnecessária dilui as que importam. Há aproximadamente um orçamento de 150-200 instruções antes que a conformidade caia, e o prompt do sistema já usa cerca de 50 delas.

30. Após o Claude cometer um erro, diga “Atualize seu CLAUDE.md para que isso não aconteça novamente”

Quando o Claude comete um erro, diga “atualize o arquivo CLAUDE.md para que isso não aconteça novamente.” O Claude escreve sua própria regra. Na próxima sessão, ele a segue automaticamente.

Com o tempo, seu CLAUDE.md se torna um documento vivo moldado por erros reais. Para evitar que cresça indefinidamente, use @imports (dica #32) para referenciar um arquivo separado como @docs/solutions.md para padrões e correções. Seu CLAUDE.md permanece enxuto e o Claude lê os detalhes sob demanda.

31. Use .claude/rules/ para regras que se aplicam apenas às vezes

Coloque arquivos markdown em .claude/rules/ para organizar instruções por tópico. Por padrão, cada arquivo de regra carrega no início de cada sessão. Para fazer uma regra carregar apenas quando o Claude trabalha em arquivos específicos, adicione frontmatter de paths:

---
paths:
  - "**/*.ts"
---
# Convenções TypeScript
Prefira interfaces a types.

Isso mantém seu CLAUDE.md principal enxuto. Regras de TypeScript carregam quando o Claude lê arquivos .ts, regras de Go quando lê arquivos .go. O Claude nunca precisa navegar por convenções de linguagens que não está usando.

32. Use @imports para manter o CLAUDE.md enxuto

Referencie docs com @docs/git-instructions.md. Você também pode referenciar @README.md, @package.json, ou até @~/.claude/my-project-instructions.md.

O Claude lê o arquivo quando precisar. Pense nos @imports como “aqui está mais contexto se precisar” sem inflar o arquivo que o Claude lê a cada sessão.

33. Coloque comandos seguros na allowlist com /permissions

Pare de clicar em “aprovar” no npm run lint pela centésima vez. /permissions permite que você coloque comandos confiáveis na allowlist para permanecer no fluxo. Você ainda será solicitado para qualquer coisa que não esteja na lista.

34. Use /sandbox quando quiser que o Claude trabalhe livremente

Execute /sandbox para habilitar isolamento em nível de SO. Escritas são restritas ao seu diretório de projeto e requisições de rede são limitadas a domínios que você aprova. Usa Seatbelt no macOS e bubblewrap no Linux, então as restrições se aplicam a todos os subprocessos que o Claude gera. No modo de auto-aprovação, comandos em sandbox rodam sem prompts de permissão, o que lhe dá autonomia quase total com proteções.

Para trabalho sem supervisão (migrações noturnas, refatorações experimentais), execute o Claude em um contêiner Docker. Contêineres oferecem isolamento completo, rollback fácil e a confiança para deixar o Claude rodar por horas.

35. Crie subagentes personalizados para tarefas recorrentes

Diferente de usar subagentes na hora (#19), subagentes personalizados são agentes pré-configurados salvos em .claude/agents/. Por exemplo, um agente de revisão de segurança com Opus e ferramentas somente leitura, ou um agente de busca rápida com Haiku para velocidade.

Use /agents para navegar e criá-los. Você pode definir isolation: worktree para agentes que precisam de seu próprio sistema de arquivos.

36. Escolha os servidores MCP certos para sua stack

Os servidores MCP pelos quais começar: Playwright para testes de navegador e verificação de UI, PostgreSQL/MySQL para consultas diretas de esquema, Slack para leitura de relatórios de bugs e contexto de threads, e Figma para fluxos de design para código.

O Claude Code suporta carregamento dinâmico de ferramentas, então os servidores carregam suas definições apenas quando o Claude precisar. Para uma lista abrangente do que está disponível, veja nosso guia sobre os melhores servidores MCP em 2026.

37. Defina seu estilo de saída

Execute /config e selecione seu estilo preferido. As opções integradas são Explicativo (detalhado, passo a passo), Conciso (breve, focado em ação) e Técnico (preciso, amigável a jargões).

Você também pode criar estilos de saída personalizados como arquivos em ~/.claude/output-styles/.

38. Use o CLAUDE.md para sugestões, hooks para requisitos

CLAUDE.md é consultivo. O Claude o segue cerca de 80% das vezes. Hooks são determinísticos, 100%. Se algo precisa acontecer toda vez sem exceção (formatação, linting, verificações de segurança), faça-o um hook. Se é uma orientação que o Claude deve considerar, CLAUDE.md é suficiente.

39. Formate automaticamente com um hook PostToolUse

Toda vez que o Claude editar um arquivo, seu formatador deve rodar automaticamente. Adicione um hook PostToolUse em .claude/settings.json que roda o Prettier (ou seu formatador) em qualquer arquivo após o Claude editá-lo ou escrevê-lo:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$CLAUDE_FILE_PATH\" 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

O || true evita que falhas nos hooks bloqueiem o Claude. Você também pode encadear outras ferramentas. Adicione npx eslint –fix como uma segunda entrada de hook.

Se você tiver um editor aberto nos mesmos arquivos, considere desativar o format-on-save enquanto o Claude estiver trabalhando. Alguns desenvolvedores relataram que salvamentos do editor podem invalidar o cache de prompt, forçando o Claude a reler os arquivos. Deixe o hook cuidar da formatação.

40. Bloqueie comandos destrutivos com hooks PreToolUse

Bloqueie rm -rf, drop table e padrões de truncate com um hook PreToolUse no Bash. O Claude nem tentará. O hook dispara antes de o Claude executar a ferramenta, então comandos destrutivos são interceptados antes de causar dano.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "type": "command",
        "command": "if echo \"$TOOL_INPUT\" | grep -qE 'rm -rf|drop table|truncate'; then echo 'BLOQUEADO: comando destrutivo' >&2; exit 2; fi"
      }
    ]
  }
}

Adicione isso ao .claude/settings.json no seu projeto. Você pode configurá-lo interativamente com /hooks, ou simplesmente dizer ao Claude: “Adicione um hook PreToolUse que bloqueia comandos rm -rf, drop table e truncate.”

41. Preserve contexto importante durante a compactação com hooks

Quando o contexto compacta durante sessões longas, o Claude pode perder o fio do que você está fazendo. Um hook de Notificação com um matcher de compact injeta automaticamente seu contexto-chave toda vez que a compactação ocorre.

Diga ao Claude: “Configure um hook de Notificação que, após a compactação, lembre você da tarefa atual, dos arquivos modificados e de quaisquer restrições.” O Claude criará o hook nas suas configurações. Bons candidatos para reinjeção: a descrição da tarefa atual, a lista de arquivos que você modificou e quaisquer restrições rígidas (“não modifique arquivos de migração”).

Isso é mais valioso durante sessões de várias horas em que você está fundo em uma feature e não pode se dar ao luxo de o Claude perder o fio.

42. Sempre revise manualmente auth, pagamentos e mutações de dados

O Claude é bom em código. Essas decisões precisam de um humano. Fluxos de autenticação, lógica de pagamento, mutações de dados, operações destrutivas no banco de dados. Revise-os independentemente de quão bom o resto pareça. Um escopo de auth errado, um webhook de pagamento mal configurado ou uma migração que remove uma coluna silenciosamente pode custar usuários, dinheiro ou confiança. Nenhum volume de testes automatizados captura todos esses casos.

43. Use /branch para tentar uma abordagem diferente sem perder a atual

/branch (ou /fork) cria uma cópia da sua conversa no ponto atual. Tente a refatoração arriscada na branch. Se funcionar, mantenha-a. Se não, sua conversa original está intocada. Isso é diferente do rewind (#3) porque ambos os caminhos permanecem vivos.

44. Deixe o Claude entrevistá-lo quando você não consegue especificar completamente uma feature

Você sabe o que quer construir, mas sente que não tem todos os detalhes que o Claude precisa para construí-lo bem. Deixe o Claude fazer as perguntas.

Quero construir [breve descrição]. Me entreviste detalhadamente
usando a ferramenta AskUserQuestion. Pergunte sobre implementação técnica,
casos extremos, preocupações e tradeoffs. Não faça perguntas óbvias.
Continue entrevistando até cobrir tudo,
depois escreva uma especificação completa em SPEC.md.

Quando a especificação estiver pronta, inicie uma sessão nova para executar com contexto limpo e uma especificação completa.

45. Faça um Claude escrever, outro Claude revisar

O primeiro Claude implementa a feature, o segundo Claude revisa a partir de um contexto novo como um engenheiro sênior. O revisor não tem conhecimento dos atalhos de implementação e vai questioná-los todos.

A mesma ideia funciona para TDD. Sessão A escreve os testes, Sessão B escreve o código para passá-los.

46. Revise PRs de forma conversacional

Não peça ao Claude uma revisão de PR de uma só vez (embora você possa, se quiser). Abra o PR em uma sessão e tenha uma conversa sobre ele. “Me guie pela mudança mais arriscada neste PR.” “O que quebraria se isso rodasse de forma concorrente?” “O tratamento de erros é consistente com o resto da base de código?”

Revisões conversacionais detectam mais problemas porque você pode se aprofundar nas áreas que importam. Revisões de uma só vez tendem a apontar problemas de estilo e frequentemente perdem os problemas arquiteturais.

47. Nomeie e codifique por cores suas sessões

/rename auth-refactor coloca um rótulo na barra de prompt para que você saiba qual sessão é qual. /color red ou /color blue define a cor da barra de prompt. Cores disponíveis: red, blue, green, yellow, purple, orange, pink, cyan. Quando você está rodando 2-3 sessões paralelas, nomeá-las e colorí-las leva cinco segundos e evita que você digite no terminal errado.

48. Toque um som quando o Claude terminar

Adicione um hook Stop que toca um som do sistema quando o Claude conclui uma resposta. Inicie uma tarefa, mude para outra coisa e ouça um ping quando terminar.

{
  "hooks": {
    "Stop": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "/usr/bin/afplay /System/Library/Sounds/Glass.aiff"
          }
        ]
      }
    ]
  }
}

49. Fan-out com claude -p para operações em lote

Faça um loop por uma lista de arquivos com o modo não interativo. --allowedTools define o escopo do que o Claude pode fazer por arquivo. Rode-os em paralelo com & para máximo throughput.

for file in $(cat files-to-migrate.txt); do
  claude -p "Migre $file de class components para hooks" \
    --allowedTools "Edit,Bash(git commit *)" &
done
wait
```

Ótimo para converter formatos de arquivo, atualizar imports em uma base de código e executar migrações repetitivas onde cada arquivo é independente dos demais.

---

## **50. Personalize os verbos do spinner (a dica divertida)**

Enquanto o Claude pensa, o terminal exibe um spinner com verbos como "Flibbertigibbeting..." e "Flummoxing...". Você pode substituí-los pelo que quiser. Diga ao Claude:
```
Substitua meus verbos do spinner nas configurações do usuário por estes:
Alucinando com responsabilidade, Fingindo pensar,
Chutando com confiança, Culpando a janela de contexto

Você não precisa fornecer uma lista também. Apenas diga ao Claude qual vibe você quer: “Substitua meus verbos do spinner por feitiços de Harry Potter.” O Claude gera a lista. É uma pequena coisa que torna a espera mais agradável.

Tabela de Comandos Essenciais e Melhores Práticas

Conclusão

Você não precisa de todas as 50. Escolha a que resolve o que mais te incomodou na sua última sessão e experimente amanhã. Uma dica que fica é mais valiosa do que cinquenta que você salvou nos favoritos.

E para complementar:

A maioria das pessoas usa o Claude Code como um agente único. Mas quando você precisa coordenar várias tarefas em diferentes domínios, as equipes de agentes mudam tudo.

Neste vídeo, Jhon Kim apresenta 30 dicas sobre o recurso de equipes de agentes do Claude Code. Tudo, desde o que são e como diferem dos subagentes, até como configurá-las, controlar o ciclo de vida e os casos de uso em que realmente se destacam.