50 dicas e boas práticas para usar o Claude Code no dia a dia

• Coletânea de 50 dicas práticas para desenvolvedores que já usam o Claude Code, organizada com base na documentação oficial da Anthropic, no desenvolvedor Boris Cherny, na experiência da comunidade e em 1 ano de uso diário
• Abrange desde atalhos para operar sessões, como alias cc, prefixo ! e rebobinar com Esc, até subagentes, equipes de agentes e trabalho paralelo com worktree
• Inclui metodologias estruturadas para manter qualidade e consistência, como escrita de CLAUDE.md, sistema de Hooks e gerenciamento da janela de contexto
• Apresenta vários padrões de workflow, como uso de ferramentas CLI, escolha de servidores MCP e processamento em lote
• Em vez de aplicar todas as 50 de uma vez, recomenda uma adoção gradual, começando pela que mais te incomodava

---

1. Configurar o alias cc

• Adicione alias cc='claude --dangerously-skip-permissions' ao ~/.zshrc (ou ~/.bashrc) para iniciar uma sessão do Claude Code digitando apenas cc
• Essa configuração pula todos os prompts de permissão, e o nome da flag é intencionalmente ameaçador
• Só deve ser usada depois de entender completamente o que o Claude Code pode fazer no codebase

2. Executar comandos bash inline com o prefixo !

• Ao digitar !git status ou !npm test, o comando é executado imediatamente, e o comando com a saída fica no contexto
• O Claude pode verificar o resultado e seguir com o trabalho — é mais rápido do que pedir ao Claude para executar o comando

3. Pare com Esc, rebobine com Esc+Esc

• Esc interrompe o Claude no meio sem perder o contexto — dá para mudar de direção na hora
• Esc+Esc (ou /rewind) abre um menu com rolagem de todos os checkpoints criados pelo Claude, permitindo restaurar código, conversa ou ambos
  • Há 4 opções de restauração: código e conversa, só conversa, só código, resumo após o checkpoint
• Dá para testar até uma abordagem com 40% de confiança — se falhar, basta rebobinar com dano zero
  • Porém, os checkpoints rastreiam apenas edições em arquivos; mudanças feitas por comandos bash (migrações, operações em banco) não são capturadas
• Use claude --continue para retomar a conversa mais recente e claude --resume para abrir o seletor de sessões

4. Dê ao Claude meios de validar o próprio trabalho

• Inclua no prompt comandos de teste, checks de lint e saídas esperadas para criar um ciclo de feedback em que o Claude detecta os próprios erros
  • Exemplo: "Refatore o middleware de auth para JWT. Depois da mudança, rode a suíte de testes existente, corrija todas as falhas e só então conclua"
• Segundo Boris Cherny, só isso já traz uma melhora de qualidade de 2 a 3 vezes
• Em mudanças de UI, configure o servidor MCP do Playwright para que o Claude abra o navegador, interaja com a página e valide se a UI funciona como esperado — capturando problemas que testes unitários deixam passar

5. Instale plugins de inteligência de código por linguagem

• Os plugins LSP fornecem diagnósticos automáticos após editar arquivos (erros de tipo, imports não usados, tipos de retorno ausentes etc.) — entre os plugins que dá para instalar, é o de maior impacto
• Exemplos de 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 na aba Discover de /plugin
• Os binários do servidor de linguagem correspondente precisam estar instalados no sistema (caso contrário, o plugin avisa)

6. Use o gh CLI e aprenda todas as ferramentas CLI

• Com o gh CLI, dá para lidar com PRs, issues e comentários sem precisar de um servidor MCP separado — ferramentas CLI são mais eficientes em contexto do que servidores MCP (não carregam o schema da ferramenta na janela de contexto)
• O mesmo vale para ferramentas CLI padrão, como jq e curl
• Se o Claude não conhecer uma ferramenta, ele pode ler a saída de --help, entender a sintaxe e executar os comandos por conta própria — por exemplo: "aprenda com sentry-cli --help e depois encontre o erro mais recente em produção"
• Isso também funciona com ferramentas CLI internas e mais nichadas

7. Adicione "ultrathink" para raciocínio complexo

• A palavra-chave "ultrathink" aumenta o nível de effort e ativa o raciocínio adaptativo no Opus 4.6
• É ideal para situações em que o Claude precisa pensar bem antes de agir, como decisões de arquitetura, debugging difícil e raciocínio em múltiplas etapas
• Também dá para definir isso como padrão com /effort — mantendo baixo effort em tarefas simples para ser mais rápido e barato
• Não faz sentido gastar tokens de thinking para renomear variáveis — ajuste o effort ao problema

8. Expanda conhecimento sob demanda com skills

• Skills são arquivos Markdown que expandem o conhecimento do Claude e, ao contrário de CLAUDE.md, são carregados apenas em tarefas relevantes, mantendo o contexto mais leve
• Podem ser criadas em .claude/skills/ ou instaladas como skills prontas empacotadas por plugins (navegue em /plugin)
• São ideais para conhecimento de domínio especializado de que o Claude precisa às vezes, mas não o tempo todo, como regras de API, procedimentos de deploy e padrões de código

9. Controle o Claude Code pelo celular

• Inicie uma sessão com claude remote-control e conecte em claude.ai/code ou no app Claude para iOS/Android
• A sessão roda na máquina local, e o celular ou navegador serve apenas como ponto de acesso — dá para enviar mensagens, aprovar chamadas de ferramenta e acompanhar o progresso
• Se você usar o alias cc da dica #1, não precisa de aprovações separadas, o que deixa o controle remoto ainda mais fluido — inicie a tarefa, saia da mesa e só confira quando o Claude terminar ou se acontecer algo inesperado

10. Expanda a janela de contexto para 1M tokens

• Tanto o Sonnet 4.6 quanto o Opus 4.6 suportam janela de contexto de 1M tokens
• Nos planos Max, Team e Enterprise, o Opus é automaticamente atualizado para contexto de 1M
• Você pode trocar de modelo durante a sessão com /model opus[1m] ou /model sonnet[1m]
• Se estiver preocupado com a qualidade em contexto grande, teste aumentando gradualmente a partir de 500k
• Use CLAUDE_CODE_AUTO_COMPACT_WINDOW e CLAUDE_AUTOCOMPACT_PCT_OVERRIDE para controlar quando a compactação é acionada

11. Use o Plan Mode quando não tiver certeza da abordagem

• O Plan Mode é adequado para mudanças em vários arquivos, código desconhecido e decisões de arquitetura — investir alguns minutos antes evita que o Claude passe 20 minutos resolvendo o problema errado
• Em tarefas pequenas e com escopo claro, pule essa etapa — se você consegue explicar o diff em uma frase, pode executar direto
• Dá para alternar entre os modos de permissão Normal, Auto-Accept e Plan com Shift+Tab (sem sair da conversa)

12. Rode /clear entre tarefas não relacionadas

• Um prompt afiado em uma sessão limpa é melhor do que uma sessão bagunçada de 3 horas — se for outra tarefa, comece com /clear
• Parece que você está jogando fora o progresso, mas o contexto acumulado acaba soterrando a instrução atual e gera a sensação de 30 minutos desperdiçados
• Os 5 segundos gastos com /clear e um prompt inicial focado rendem muito mais

13. Não interprete o bug; cole os dados brutos

• Quando você descreve o bug em palavras, o Claude entra num ciclo lento de adivinhar, corrigir e repetir
• Cole logs de erro, saída de CI e threads do Slack como estão e diga "corrija"; assim o Claude lê logs de sistemas distribuídos e rastreia onde está o problema
• A interpretação humana adiciona uma camada de abstração que faz perder detalhes necessários para o Claude encontrar a causa raiz com precisão
• Isso também vale para CI — cole algo como "Vá corrigir os testes de CI que falharam" com a saída do CI, ou peça para corrigir os checks com falha usando a URL ou o número do PR
• Também dá para fazer pipe da saída do terminal diretamente:
  • cat error.log | claude "explique este erro e sugira uma correção"
  • npm test 2>&1 | claude "corrija os testes que estão falhando"

14. Perguntas rápidas paralelas com /btw

• /btw abre uma sobreposição que não entra no histórico da conversa, permitindo fazer perguntas rápidas
• Use para esclarecer a sessão atual: "por que você escolheu essa abordagem?" ou "quais são os trade-offs em relação a outras opções?"
• A resposta aparece em uma sobreposição que pode ser fechada, mantendo o contexto principal enxuto

15. Executar branches paralelos isolados com --worktree

• claude --worktree feature-auth cria uma cópia de trabalho isolada e uma nova branch — o Claude configura e limpa o git worktree automaticamente
• A equipe do Claude Code considera isso um dos maiores destravadores de produtividade
• Suba de 3 a 5 worktrees para executar em paralelo sessões independentes do Claude em cada uma (normalmente usam 2 ou 3)
• Cada worktree mantém uma sessão, branch e estado do sistema de arquivos independentes
• O limite dos worktrees locais são os recursos da máquina — vários dev servers, builds e sessões do Claude disputam CPU
  • A Builder.io resolve a carga da máquina colocando cada agente em um contêiner de nuvem separado

16. Salvar temporariamente o prompt com Ctrl+S

• Se você estiver escrevendo um prompt longo, mas precisar antes de uma resposta rápida, use Ctrl+S para guardar o rascunho
• Depois de enviar a pergunta rápida, o prompt salvo é restaurado automaticamente

17. Colocar tarefas longas em segundo plano com Ctrl+B

• Quando o Claude iniciar um comando bash demorado (suite de testes, build, migração), use Ctrl+B para colocá-lo em segundo plano
• O Claude continua trabalhando e você pode seguir conversando — quando o processo terminar, ele mostra o resultado

18. Adicionar uma barra de status ao vivo

• A barra de status é um script de shell executado após cada turno do Claude, exibindo na parte inferior do terminal o diretório atual, a branch git e o uso de contexto com cores
• Pode ser configurada rapidamente com o comando /statusline — ele pergunta o que mostrar e gera o script automaticamente

19. Manter o contexto principal limpo com subagentes

• Diga algo como "use um subagente para descobrir como o fluxo de pagamento trata transações com falha" e uma instância separada do Claude lerá os arquivos, analisará em uma janela de contexto independente e retornará um resumo conciso
• Como uma investigação profunda pode consumir metade da janela de contexto, use subagentes para isolar esse custo da sessão principal
• Tipos embutidos: Explore (Haiku, busca rápida de arquivos) e Plan (análise somente leitura)

20. Equipe de agentes para coordenar múltiplas sessões

• Recurso experimental, mas poderoso — ative adicionando CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS à configuração ou às variáveis de ambiente
• Dê instruções como "crie uma equipe de agentes com 3 membros para refatorar estes módulos em paralelo"
• O líder da equipe distribui tarefas aos membros; cada um tem sua própria janela de contexto e uma lista de tarefas compartilhada, além de poder trocar mensagens diretamente
• Recomenda-se começar com 3 a 5 membros e 5 a 6 tarefas por membro
• Evite atribuir tarefas que editem o mesmo arquivo por causa de problemas de sobrescrita — comece com tarefas de pesquisa e revisão e depois avance para implementação em paralelo

21. Adicionar instruções de preservação à compactação

• Ao compactar o contexto (automaticamente ou com /compact), é possível especificar o que deve ser preservado: /compact focus on the API changes and the list of modified files
• Também dá para adicionar uma instrução permanente no CLAUDE.md: "ao compactar, preserve a lista completa de arquivos modificados e o estado atual dos testes"

22. Executar verificações repetidas com /loop

• Use /loop 5m check if the deploy succeeded and report back para agendar um prompt recorrente em segundo plano
• O intervalo é opcional (padrão de 10 minutos) e aceita unidades s, m, h, d
• Também é possível repetir outros comandos, como em /loop 20m /review-pr 1234
• As tarefas são limitadas à sessão e expiram após 3 dias — loops esquecidos não ficam rodando para sempre
• Útil para monitorar deploys, acompanhar pipelines de CI e consultar serviços externos

23. Escrever prompts mais ricos com ditado por voz

• /voice ativa o push-to-talk; segure a tecla Space e fale para que a transcrição em tempo real seja inserida no prompt
• Você pode misturar voz e digitação na mesma mensagem
• Prompts por voz naturalmente incluem mais contexto do que os digitados — dá para explicar background, restrições e o que você quer sem o esforço de digitar tudo
• Requer uma conta Claude.ai (não uma chave de API)
• Em ~/.claude/keybindings.json, é possível remapear a tecla de push-to-talk para meta+k etc., pulando o aquecimento da detecção de pressionamento contínuo

24. Se o problema não for resolvido após 2 tentativas de correção, recomece

• Se você cair em um rabbit hole de correções e o problema continuar sem solução, o contexto fica cheio de abordagens fracassadas, o que atrapalha a próxima tentativa
• Use /clear e recomece com um prompt inicial melhor, incorporando o que foi aprendido
• Uma sessão limpa com um prompt afiado quase sempre supera uma sessão longa atolada em becos sem saída acumulados

25. Diga ao Claude exatamente quais arquivos olhar

• Faça referência direta a arquivos com o prefixo @, como em @src/auth/middleware.ts has the session handling
• O prefixo @ é interpretado automaticamente como caminho de arquivo, então o Claude localiza exatamente o ponto certo de imediato
• O Claude também consegue usar grep/busca por conta própria, mas o processo de reduzir candidatos e identificar o arquivo correto consome tokens e contexto — ao indicar o arquivo desde o início, você pula todo esse processo

26. Explorar código desconhecido com prompts ambíguos

• "O que você melhoraria neste arquivo?" é um excelente prompt de exploração — nem todo prompt precisa ser específico
• Quando você precisa de uma nova perspectiva sobre código existente, perguntas ambíguas dão ao Claude espaço para encontrar coisas inesperadas
• Isso ajuda no onboarding em repositórios desconhecidos — o Claude pode apontar padrões, inconsistências e oportunidades de melhoria que passariam batido em uma primeira leitura

27. Editar planos com Ctrl+G

• Quando o Claude apresentar um plano, use Ctrl+G para abri-lo diretamente em um editor de texto e editá-lo
• Você pode acrescentar restrições, remover etapas ou mudar a abordagem antes que o Claude escreva uma única linha de código
• Quando o plano está basicamente certo, mas você quer ajustar só algumas etapas, não é preciso explicar tudo de novo

28. Rodar /init e depois cortar o resultado pela metade

• CLAUDE.md é um arquivo Markdown na raiz do projeto que fornece ao Claude instruções permanentes sobre comandos de build, padrões de código, decisões de arquitetura, convenções do repositório etc.
• O Claude o lê no início de cada sessão
• Use /init para gerar uma versão inicial com base na estrutura do projeto — ele detecta automaticamente comandos de build, scripts de teste e o layout de diretórios
• A saída tende a ficar inchada — remova qualquer linha cuja razão de existir você não consiga explicar e adicione o que estiver faltando

29. Teste decisivo para cada linha do CLAUDE.md

• Para cada linha do CLAUDE.md, pergunte: "sem esta linha, o Claude cometeria um erro?"
• Instruções que o Claude já executa corretamente são ruído — linhas desnecessárias diluem as importantes
• Há um limite de cerca de 150 a 200 instruções antes de a aderência começar a cair, e o prompt do sistema já usa aproximadamente 50

30. Depois de um erro do Claude, diga: "atualize o CLAUDE.md para que isso não aconteça de novo"

• Se o Claude cometer um erro, diga: "update the CLAUDE.md file so this doesn't happen again"
• O Claude escreve sua própria regra e, nas sessões seguintes, passa a segui-la automaticamente
• Com o tempo, o CLAUDE.md evolui para um documento vivo moldado por erros reais
• Para evitar crescimento infinito, use @imports (dica #32) para referenciar arquivos separados (@docs/solutions.md etc.) — mantendo o CLAUDE.md leve e deixando o Claude ler os detalhes quando necessário

31. Aplicar regras condicionais com .claude/rules/

• Coloque arquivos Markdown em .claude/rules/ para organizar instruções por tema — por padrão, todos os arquivos de regras são carregados no início da sessão
• É possível ativar de forma condicional com frontmatter paths, para que sejam carregados apenas em padrões de arquivos específicos:
  • Ex.: se definir paths: ["**/*.ts"], o Claude carrega as regras de TypeScript somente quando lê arquivos .ts
• Mantenha o CLAUDE.md principal enxuto — assim o Claude não lê regras de linguagens nas quais não está trabalhando no momento

32. Mantenha o CLAUDE.md enxuto com @imports

• Consulte documentos como @docs/git-instructions.md — também funciona com @README.md, @package.json e @~/.claude/my-project-instructions.md
• O Claude lê o arquivo só quando precisa — isso serve para adicionar contexto sob demanda sem deixar o CLAUDE.md, carregado em toda sessão, inflado demais

33. Configure uma allowlist de comandos seguros com /permissions

• Pare de clicar pela centésima vez para aprovar npm run lint — use /permissions para colocar comandos confiáveis na allowlist
• Comandos fora da lista continuam exibindo prompt

34. Use /sandbox para dar liberdade de trabalho ao Claude

• Ative o isolamento em nível de sistema operacional com /sandbox — a escrita fica restrita ao diretório do projeto, e requisições de rede só são permitidas para domínios aprovados
• No macOS usa Seatbelt; no Linux, bubblewrap; as restrições se aplicam a todos os subprocessos gerados pelo Claude
• No modo auto-allow, comandos dentro do sandbox são executados sem prompts de permissão — quase autonomia total, mas com guardrails
• Para trabalho sem supervisão direta (migrações durante a noite, refatorações experimentais), execute o Claude dentro de um container Docker para isolamento completo e rollback fácil

35. Crie subagentes personalizados para tarefas repetitivas

• Diferentemente dos subagentes improvisados da dica #19, os subagentes personalizados ficam pré-configurados e salvos em .claude/agents/
  • Ex.: um agente revisor de segurança com Opus + ferramentas somente leitura, ou um agente de busca rápida com Haiku
• Use /agents para explorar e criar
• Também é possível configurar um agente com sistema de arquivos independente usando isolation: worktree

36. Escolha servidores MCP adequados à sua stack

• Bons servidores MCP para começar: Playwright (testes de navegador e validação de UI), PostgreSQL/MySQL (consulta direta ao schema), Slack (relatórios de bugs e contexto de threads), Figma (fluxo de trabalho de design para código)
• O Claude Code oferece suporte a carregamento dinâmico de ferramentas — o Claude carrega a definição do servidor só quando precisa

37. Configure o estilo de saída

• Escolha o estilo preferido em /config — opções embutidas: Explanatory (detalhado, passo a passo), Concise (objetivo, focado em ação), Technical (preciso, amigável a jargão técnico)
• Também é possível criar estilos de saída personalizados em ~/.claude/output-styles/

38. CLAUDE.md é sugestão; Hooks são exigência

• CLAUDE.md é orientativo — o Claude segue cerca de 80% do tempo
• Hooks são determinísticos — executam 100% das vezes
• Tudo que precisa ser executado sempre, sem exceção (formatação, linting, checagens de segurança), deve ser configurado como Hook
• Se for apenas uma diretriz que o Claude deve considerar, CLAUDE.md já basta

39. Formatação automática com PostToolUse Hook

• Adicione um PostToolUse Hook em .claude/settings.json para que o formatador rode automaticamente sempre que o Claude editar arquivos
  • Registre npx prettier --write "$CLAUDE_FILE_PATH" 2>/dev/null || true no matcher Edit|Write
• Use || true para evitar que falhas do Hook bloqueiem o Claude
• Também dá para encadear npx eslint --fix como uma segunda entrada de Hook
• Se o editor estiver com o mesmo arquivo aberto, pode ser melhor desativar o format-on-save — há relatos de que salvar pelo editor pode invalidar o cache de prompt, então deixe a formatação por conta do Hook

40. Bloqueie comandos destrutivos com PreToolUse Hook

• Bloqueie padrões como rm -rf, drop table e truncate com um PreToolUse Hook — assim o Claude nem tenta executá-los
• O Hook é acionado antes de o Claude executar a ferramenta, impedindo previamente comandos destrutivos
• Você pode adicionar isso em .claude/settings.json, configurar interativamente com /hooks ou pedir ao Claude: "adicione um PreToolUse Hook que bloqueie os comandos rm -rf, drop table e truncate"

41. Preserve contexto importante na compactação com Hook

• Em sessões longas, o Claude pode perder o contexto do que está fazendo quando ocorre compactação de contexto
• Um Notification Hook com matcher compact pode reinjetar automaticamente o contexto essencial sempre que a compactação for acionada
• Peça ao Claude: "configure um Notification Hook que relembre a tarefa atual, os arquivos modificados e as restrições após a compactação"
• Bons itens para reinjeção: descrição da tarefa atual, lista de arquivos modificados e restrições rígidas ("não mexa nos arquivos de migração")
• Isso é mais útil em sessões de várias horas, quando o Claude está tão mergulhado na funcionalidade que não pode perder o fio da meada

42. Sempre faça revisão manual em autenticação, pagamentos e mutações de dados

• Fluxos de autenticação, lógica de pagamento, mutações de dados e operações destrutivas no banco — não importa quão bom o resto do código pareça, isso sempre deve ser revisado por uma pessoa
• Escopos de autenticação errados, webhooks de pagamento mal configurados e migrações que removem colunas silenciosamente fazem você perder usuários, dinheiro e confiança
• Nenhuma quantidade de testes automatizados consegue pegar todos esses problemas

43. Use /branch para testar outra abordagem sem perder o caminho atual

• Use /branch (ou /fork) para criar uma cópia da conversa a partir do ponto atual
• Tente a refatoração arriscada no branch — se der certo, mantenha; se falhar, a conversa original continua intacta
• Diferente do rewind (dica #3): os dois caminhos continuam existindo

44. Peça ao Claude que faça uma entrevista quando a especificação estiver incompleta

• Se você sabe o que quer construir, mas ainda faltam todos os detalhes necessários para o Claude fazer um bom trabalho, faça o Claude perguntar
  • "Quero construir [descrição breve]. Use a ferramenta AskUserQuestion para me entrevistar em detalhe. Pergunte sobre implementação técnica, edge cases, preocupações e trade-offs. Não faça perguntas óbvias. Entreviste até cobrir tudo e então escreva uma especificação completa em SPEC.md"
• Depois que a especificação estiver pronta, comece a implementação em uma nova sessão, com contexto limpo e a especificação completa

45. Deixe um Claude escrever e outro revisar

• O primeiro Claude implementa a funcionalidade; o segundo Claude faz a revisão em um contexto novo, como um staff engineer
• Como o revisor não tem conhecimento prévio dos atalhos usados na implementação, ele tende a questionar tudo
• A mesma ideia vale para TDD: a sessão A escreve os testes, a sessão B escreve o código para passar

46. Faça a revisão de PR de forma interativa

• Em vez de pedir uma revisão de PR em uma tacada só (embora isso também seja possível), abra o PR na sessão e conduza uma conversa
  • "Explique a mudança mais arriscada deste PR"
  • "Se isso rodar em paralelo, o que pode quebrar?"
  • "O tratamento de erros está consistente com o restante do codebase?"
• A revisão interativa encontra mais problemas — porque permite aprofundar nas áreas importantes
• Revisões em uma tacada só tendem a marcar detalhes de estilo e podem deixar passar problemas de arquitetura

47. Dê nome e cor às sessões

• Use /rename auth-refactor para exibir um rótulo na barra de prompt
• Use /color red ou /color blue para definir a cor da barra de prompt
  • Cores disponíveis: red, blue, green, yellow, purple, orange, pink, cyan
• Se você toca 2 ou 3 sessões em paralelo, investir 5 segundos em nome e cor ajuda a evitar digitar no terminal errado

48. Reproduzir som ao concluir no Claude

• Com o Stop Hook, reproduza um som do sistema quando o Claude terminar de responder
• Inicie uma tarefa, mude para outro trabalho e receba um aviso com um ping ao concluir
• Ex.: registre /usr/bin/afplay /System/Library/Sounds/Glass.aiff como Stop Hook em .claude/settings.json

49. Fan-out de trabalhos em lote com claude -p

• No modo não interativo, percorra uma lista de arquivos em loop para processá-los — use --allowedTools para limitar o escopo do que o Claude pode fazer por arquivo
• Execute em paralelo com & para obter a vazão máxima:
  • for file in $(cat files-to-migrate.txt); do claude -p "Migrate $file from class components to hooks" --allowedTools "Edit,Bash(git commit *)" & done; wait
• Ideal para conversão de formatos de arquivo, atualização de imports em toda a base de código e migrações repetitivas em que cada arquivo é independente

50. Personalizar os verbos do spinner (diversão)

• Enquanto o Claude está pensando, o terminal mostra verbos do spinner como "Flibbertigibbeting..." e "Flummoxing..."
• Você pode trocá-los pelas frases que quiser — peça ao Claude:
  • "Replace my spinner verbs in user settings with these: Hallucinating responsibly, Pretending to think, Confidently guessing, Blaming the context window"
• Não é necessário fornecer a lista manualmente — se você passar só a vibe, como em "Replace my spinner verbs with Harry Potter spells", o Claude gera a lista
• Uma pequena personalização que torna o tempo de espera mais divertido

[roxie]

Desde o item 1 já está muito divertido.