Cada tarefa neste documento inclui instruções claras, comandos de exemplo e melhores práticas para ajudá-lo a obter o máximo do Claude Code.

​
Compreender novas bases de código

​
Obter uma visão geral rápida da base de código

Suponha que você acabou de se juntar a um novo projeto e precisa entender sua estrutura rapidamente.
1

Navegar para o diretório raiz do projeto

cd /path/to/project
2

Iniciar Claude Code

claude
3

Pedir uma visão geral de alto nível

> me dê uma visão geral desta base de código
4

Aprofundar em componentes específicos

> explique os principais padrões de arquitetura usados aqui 

> quais são os principais modelos de dados?

> como a autenticação é tratada?
Dicas:
  • Comece com perguntas amplas, depois afunile para áreas específicas
  • Pergunte sobre convenções de codificação e padrões usados no projeto
  • Solicite um glossário de termos específicos do projeto

​
Encontrar código relevante

Suponha que você precisa localizar código relacionado a uma funcionalidade ou recurso específico.
1

Pedir ao Claude para encontrar arquivos relevantes

> encontre os arquivos que lidam com autenticação de usuário
2

Obter contexto sobre como os componentes interagem

> como esses arquivos de autenticação funcionam juntos?
3

Entender o fluxo de execução

> rastreie o processo de login do front-end ao banco de dados
Dicas:
  • Seja específico sobre o que você está procurando
  • Use linguagem de domínio do projeto

​
Corrigir bugs eficientemente

Suponha que você encontrou uma mensagem de erro e precisa encontrar e corrigir sua origem.
1

Compartilhar o erro com Claude

> estou vendo um erro quando executo npm test
2

Pedir recomendações de correção

> sugira algumas maneiras de corrigir o @ts-ignore em user.ts
3

Aplicar a correção

> atualize user.ts para adicionar a verificação nula que você sugeriu
Dicas:
  • Diga ao Claude o comando para reproduzir o problema e obter um stack trace
  • Mencione quaisquer passos para reproduzir o erro
  • Informe ao Claude se o erro é intermitente ou consistente

​
Refatorar código

Suponha que você precisa atualizar código antigo para usar padrões e práticas modernas.
1

Identificar código legado para refatoração

> encontre uso de API depreciada em nossa base de código
2

Obter recomendações de refatoração

> sugira como refatorar utils.js para usar recursos modernos do JavaScript
3

Aplicar as mudanças com segurança

> refatore utils.js para usar recursos ES2024 mantendo o mesmo comportamento
4

Verificar a refatoração

> execute testes para o código refatorado
Dicas:
  • Peça ao Claude para explicar os benefícios da abordagem moderna
  • Solicite que as mudanças mantenham compatibilidade com versões anteriores quando necessário
  • Faça refatoração em incrementos pequenos e testáveis

​
Usar subagentes especializados

Suponha que você queira usar subagentes de IA especializados para lidar com tarefas específicas de forma mais eficaz.
1

Ver subagentes disponíveis

> /agents
Isso mostra todos os subagentes disponíveis e permite criar novos.
2

Usar subagentes automaticamente

Claude Code delegará automaticamente tarefas apropriadas para subagentes especializados:
> revise minhas mudanças recentes de código para problemas de segurança

> execute todos os testes e corrija quaisquer falhas
3

Solicitar explicitamente subagentes específicos

> use o subagente code-reviewer para verificar o módulo de autenticação

> faça o subagente debugger investigar por que os usuários não conseguem fazer login
4

Criar subagentes personalizados para seu fluxo de trabalho

> /agents
Em seguida, selecione “Create New subagent” e siga as instruções para definir:
  • Tipo de subagente (ex: api-designer, performance-optimizer)
  • Quando usá-lo
  • Quais ferramentas ele pode acessar
  • Seu prompt de sistema especializado
Dicas:
  • Crie subagentes específicos do projeto em .claude/agents/ para compartilhamento em equipe
  • Use campos description descritivos para habilitar delegação automática
  • Limite o acesso a ferramentas ao que cada subagente realmente precisa
  • Verifique a documentação de subagentes para exemplos detalhados

​
Usar Modo de Planejamento para análise segura de código

O Modo de Planejamento instrui Claude a criar um plano analisando a base de código com operações somente leitura, perfeito para explorar bases de código, planejar mudanças complexas ou revisar código com segurança.

​
Quando usar o Modo de Planejamento

  • Implementação multi-etapas: Quando seu recurso requer fazer edições em muitos arquivos
  • Exploração de código: Quando você quer pesquisar a base de código completamente antes de mudar qualquer coisa
  • Desenvolvimento interativo: Quando você quer iterar na direção com Claude

​
Como usar o Modo de Planejamento

Ativar o Modo de Planejamento durante uma sessão Você pode alternar para o Modo de Planejamento durante uma sessão usando Shift+Tab para alternar entre modos de permissão. Se você estiver no Modo Normal, Shift+Tab primeiro alternará para o Modo Auto-Aceitar, indicado por ⏵⏵ accept edits on na parte inferior do terminal. Um Shift+Tab subsequente alternará para o Modo de Planejamento, indicado por ⏸ plan mode on. Iniciar uma nova sessão no Modo de Planejamento Para iniciar uma nova sessão no Modo de Planejamento, use a flag --permission-mode plan: 
claude --permission-mode plan
Executar consultas “headless” no Modo de Planejamento Você também pode executar uma consulta no Modo de Planejamento diretamente com -p (ou seja, no “modo headless”): 
claude --permission-mode plan -p "Analise o sistema de autenticação e sugira melhorias"

​
Exemplo: Planejando uma refatoração complexa

claude --permission-mode plan

> Preciso refatorar nosso sistema de autenticação para usar OAuth2. Crie um plano de migração detalhado.
Claude analisará a implementação atual e criará um plano abrangente. Refine com acompanhamentos: 
> E quanto à compatibilidade com versões anteriores?
> Como devemos lidar com a migração do banco de dados?

​
Configurar Modo de Planejamento como padrão

// .claude/settings.json
{
  "permissions": {
    "defaultMode": "plan"
  }
}
Veja a documentação de configurações para mais opções de configuração.

​
Trabalhar com testes

Suponha que você precisa adicionar testes para código não coberto.
1

Identificar código não testado

> encontre funções em NotificationsService.swift que não são cobertas por testes
2

Gerar estrutura de teste

> adicione testes para o serviço de notificação
3

Adicionar casos de teste significativos

> adicione casos de teste para condições extremas no serviço de notificação
4

Executar e verificar testes

> execute os novos testes e corrija quaisquer falhas
Dicas:
  • Peça testes que cubram casos extremos e condições de erro
  • Solicite testes unitários e de integração quando apropriado
  • Faça Claude explicar a estratégia de teste

​
Criar pull requests

Suponha que você precisa criar um pull request bem documentado para suas mudanças.
1

Resumir suas mudanças

> resuma as mudanças que fiz no módulo de autenticação
2

Gerar um PR com Claude

> crie um pr
3

Revisar e refinar

> melhore a descrição do PR com mais contexto sobre as melhorias de segurança
4

Adicionar detalhes de teste

> adicione informações sobre como essas mudanças foram testadas
Dicas:
  • Peça ao Claude diretamente para fazer um PR para você
  • Revise o PR gerado pelo Claude antes de enviar
  • Peça ao Claude para destacar riscos potenciais ou considerações

​
Lidar com documentação

Suponha que você precisa adicionar ou atualizar documentação para seu código.
1

Identificar código não documentado

> encontre funções sem comentários JSDoc adequados no módulo de autenticação
2

Gerar documentação

> adicione comentários JSDoc às funções não documentadas em auth.js
3

Revisar e melhorar

> melhore a documentação gerada com mais contexto e exemplos
4

Verificar documentação

> verifique se a documentação segue nossos padrões do projeto
Dicas:
  • Especifique o estilo de documentação que você quer (JSDoc, docstrings, etc.)
  • Peça exemplos na documentação
  • Solicite documentação para APIs públicas, interfaces e lógica complexa

​
Trabalhar com imagens

Suponha que você precisa trabalhar com imagens em sua base de código e quer a ajuda do Claude analisando o conteúdo da imagem.
1

Adicionar uma imagem à conversa

Você pode usar qualquer um destes métodos:
  1. Arrastar e soltar uma imagem na janela do Claude Code
  2. Copiar uma imagem e colá-la no CLI com ctrl+v (Não use cmd+v)
  3. Fornecer um caminho de imagem ao Claude. Ex: “Analise esta imagem: /path/to/your/image.png”
2

Pedir ao Claude para analisar a imagem

> O que esta imagem mostra?

> Descreva os elementos da UI nesta captura de tela

> Há algum elemento problemático neste diagrama?
3

Usar imagens para contexto

> Aqui está uma captura de tela do erro. O que está causando isso?

> Este é nosso esquema de banco de dados atual. Como devemos modificá-lo para o novo recurso?
4

Obter sugestões de código a partir de conteúdo visual

> Gere CSS para corresponder a este mockup de design

> Que estrutura HTML recriaria este componente?
Dicas:
  • Use imagens quando descrições de texto seriam pouco claras ou complicadas
  • Inclua capturas de tela de erros, designs de UI ou diagramas para melhor contexto
  • Você pode trabalhar com múltiplas imagens em uma conversa
  • Análise de imagem funciona com diagramas, capturas de tela, mockups e mais

​
Referenciar arquivos e diretórios

Use @ para incluir rapidamente arquivos ou diretórios sem esperar Claude lê-los.
1

Referenciar um único arquivo

> Explique a lógica em @src/utils/auth.js
Isso inclui o conteúdo completo do arquivo na conversa.
2

Referenciar um diretório

> Qual é a estrutura de @src/components?
Isso fornece uma listagem de diretório com informações de arquivo.
3

Referenciar recursos MCP

> Mostre-me os dados de @github:repos/owner/repo/issues
Isso busca dados de servidores MCP conectados usando o formato @server:resource. Veja recursos MCP para detalhes.
Dicas:
  • Caminhos de arquivo podem ser relativos ou absolutos
  • Referências de arquivo @ adicionam CLAUDE.md no diretório do arquivo e diretórios pai ao contexto
  • Referências de diretório mostram listagens de arquivo, não conteúdos
  • Você pode referenciar múltiplos arquivos em uma única mensagem (ex: “@file1.js e @file2.js”)

​
Usar pensamento estendido

Suponha que você está trabalhando em decisões arquiteturais complexas, bugs desafiadores ou planejando implementações multi-etapas que requerem raciocínio profundo.
1

Fornecer contexto e pedir ao Claude para pensar

> Preciso implementar um novo sistema de autenticação usando OAuth2 para nossa API. Pense profundamente sobre a melhor abordagem para implementar isso em nossa base de código.
Claude coletará informações relevantes de sua base de código e usará pensamento estendido, que será visível na interface.
2

Refinar o pensamento com prompts de acompanhamento

> pense sobre vulnerabilidades de segurança potenciais nesta abordagem 

> continue pensando sobre casos extremos que devemos lidar
Dicas para obter o máximo valor do pensamento estendido:O pensamento estendido é mais valioso para tarefas complexas como:
  • Planejar mudanças arquiteturais complexas
  • Debugar problemas intrincados
  • Criar planos de implementação para novos recursos
  • Entender bases de código complexas
  • Avaliar trade-offs entre diferentes abordagens
A maneira como você solicita pensamento resulta em níveis variados de profundidade de pensamento:
  • “pense” aciona pensamento estendido básico
  • frases intensificadoras como “continue pensando”, “pense mais”, “pense muito” ou “pense mais tempo” acionam pensamento mais profundo
Para mais dicas de prompt de pensamento estendido, veja Dicas de pensamento estendido.
Claude exibirá seu processo de pensamento como texto cinza em itálico acima da resposta.

​
Retomar conversas anteriores

Suponha que você esteve trabalhando em uma tarefa com Claude Code e precisa continuar de onde parou em uma sessão posterior. Claude Code fornece duas opções para retomar conversas anteriores:
  • --continue para continuar automaticamente a conversa mais recente
  • --resume para exibir um seletor de conversa
1

Continuar a conversa mais recente

claude --continue
Isso retoma imediatamente sua conversa mais recente sem nenhum prompt.
2

Continuar em modo não interativo

claude --continue --print "Continue com minha tarefa"
Use --print com --continue para retomar a conversa mais recente em modo não interativo, perfeito para scripts ou automação.
3

Mostrar seletor de conversa

claude --resume
Isso exibe um seletor de conversa interativo mostrando:
  • Hora de início da conversa
  • Prompt inicial ou resumo da conversa
  • Contagem de mensagens
Use as setas para navegar e pressione Enter para selecionar uma conversa.
Dicas:
  • Histórico de conversa é armazenado localmente em sua máquina
  • Use --continue para acesso rápido à sua conversa mais recente
  • Use --resume quando precisar selecionar uma conversa passada específica
  • Ao retomar, você verá todo o histórico da conversa antes de continuar
  • A conversa retomada inicia com o mesmo modelo e configuração da original
Como funciona:
  1. Armazenamento de Conversa: Todas as conversas são automaticamente salvas localmente com seu histórico completo de mensagens
  2. Desserialização de Mensagem: Ao retomar, todo o histórico de mensagens é restaurado para manter contexto
  3. Estado de Ferramenta: Uso de ferramentas e resultados da conversa anterior são preservados
  4. Restauração de Contexto: A conversa retoma com todo o contexto anterior intacto
Exemplos:
# Continuar conversa mais recente
claude --continue

# Continuar conversa mais recente com um prompt específico
claude --continue --print "Mostre-me nosso progresso"

# Mostrar seletor de conversa
claude --resume

# Continuar conversa mais recente em modo não interativo
claude --continue --print "Execute os testes novamente"

​
Executar sessões paralelas do Claude Code com Git worktrees

Suponha que você precisa trabalhar em múltiplas tarefas simultaneamente com isolamento completo de código entre instâncias do Claude Code.
1

Entender Git worktrees

Git worktrees permitem que você faça checkout de múltiplas branches do mesmo repositório em diretórios separados. Cada worktree tem seu próprio diretório de trabalho com arquivos isolados, enquanto compartilha o mesmo histórico Git. Saiba mais na documentação oficial do Git worktree.
2

Criar um novo worktree

# Criar um novo worktree com uma nova branch 
git worktree add ../project-feature-a -b feature-a

# Ou criar um worktree com uma branch existente
git worktree add ../project-bugfix bugfix-123
Isso cria um novo diretório com uma cópia de trabalho separada do seu repositório.
3

Executar Claude Code em cada worktree

# Navegar para seu worktree 
cd ../project-feature-a

# Executar Claude Code neste ambiente isolado
claude
4

Executar Claude em outro worktree

cd ../project-bugfix
claude
5

Gerenciar seus worktrees

# Listar todos os worktrees
git worktree list

# Remover um worktree quando terminar
git worktree remove ../project-feature-a
Dicas:
  • Cada worktree tem seu próprio estado de arquivo independente, tornando-o perfeito para sessões paralelas do Claude Code
  • Mudanças feitas em um worktree não afetarão outros, impedindo que instâncias do Claude interfiram umas com as outras
  • Todos os worktrees compartilham o mesmo histórico Git e conexões remotas
  • Para tarefas de l onga duração, você pode ter Claude trabalhando em um worktree enquanto continua desenvolvimento em outro
  • Use nomes de diretório descritivos para identificar facilmente qual tarefa cada worktree é para
  • Lembre-se de inicializar seu ambiente de desenvolvimento em cada novo worktree de acordo com a configuração do seu projeto. Dependendo da sua stack, isso pode incluir:
    • Projetos JavaScript: Executar instalação de dependências (npm install, yarn)
    • Projetos Python: Configurar ambientes virtuais ou instalar com gerenciadores de pacote
    • Outras linguagens: Seguir o processo de configuração padrão do seu projeto

​
Usar Claude como um utilitário estilo unix

​
Adicionar Claude ao seu processo de verificação

Suponha que você queira usar Claude Code como um linter ou revisor de código. Adicionar Claude ao seu script de build: 
// package.json
{
    ...
    "scripts": {
        ...
        "lint:claude": "claude -p 'você é um linter. por favor, olhe as mudanças vs. main e relate quaisquer problemas relacionados a erros de digitação. relate o nome do arquivo e número da linha em uma linha, e uma descrição do problema na segunda linha. não retorne nenhum outro texto.'"
    }
}
Dicas:
  • Use Claude para revisão automatizada de código em seu pipeline de CI/CD
  • Personalize o prompt para verificar problemas específicos relevantes ao seu projeto
  • Considere criar múltiplos scripts para diferentes tipos de verificação

​
Pipe in, pipe out

Suponha que você queira canalizar dados para Claude e obter dados de volta em um formato estruturado. Canalizar dados através do Claude: 
cat build-error.txt | claude -p 'explique concisamente a causa raiz deste erro de build' > output.txt
Dicas:
  • Use pipes para integrar Claude em scripts shell existentes
  • Combine com outras ferramentas Unix para fluxos de trabalho poderosos
  • Considere usar —output-format para saída estruturada

​
Controlar formato de saída

Suponha que você precisa da saída do Claude em um formato específico, especialmente ao integrar Claude Code em scripts ou outras ferramentas.
1

Usar formato de texto (padrão)

cat data.txt | claude -p 'resuma estes dados' --output-format text > summary.txt
Isso produz apenas a resposta de texto simples do Claude (comportamento padrão).
2

Usar formato JSON

cat code.py | claude -p 'analise este código para bugs' --output-format json > analysis.json
Isso produz um array JSON de mensagens com metadados incluindo custo e duração.
3

Usar formato JSON de streaming

cat log.txt | claude -p 'analise este arquivo de log para erros' --output-format stream-json
Isso produz uma série de objetos JSON em tempo real conforme Claude processa a solicitação. Cada mensagem é um objeto JSON válido, mas a saída inteira não é JSON válido se concatenada.
Dicas:
  • Use --output-format text para integrações simples onde você só precisa da resposta do Claude
  • Use --output-format json quando precisar do log completo da conversa
  • Use --output-format stream-json para saída em tempo real de cada turno da conversa

​
Criar comandos slash personalizados

Claude Code suporta comandos slash personalizados que você pode criar para executar rapidamente prompts ou tarefas específicas. Para mais detalhes, veja a página de referência Comandos slash.

​
Criar comandos específicos do projeto

Suponha que você queira criar comandos slash reutilizáveis para seu projeto que todos os membros da equipe podem usar.
1

Criar um diretório de comandos em seu projeto

mkdir -p .claude/commands
2

Criar um arquivo Markdown para cada comando

echo "Analise a performance deste código e sugira três otimizações específicas:" > .claude/commands/optimize.md
3

Usar seu comando personalizado no Claude Code

> /optimize
Dicas:
  • Nomes de comando são derivados do nome do arquivo (ex: optimize.md torna-se /optimize)
  • Você pode organizar comandos em subdiretórios (ex: .claude/commands/frontend/component.md cria /component com “(project:frontend)” mostrado na descrição)
  • Comandos de projeto estão disponíveis para todos que clonam o repositório
  • O conteúdo do arquivo Markdown torna-se o prompt enviado ao Claude quando o comando é invocado

​
Adicionar argumentos de comando com $ARGUMENTS

Suponha que você queira criar comandos slash flexíveis que podem aceitar entrada adicional dos usuários.
1

Criar um arquivo de comando com o placeholder $ARGUMENTS

echo 'Encontre e corrija o problema #$ARGUMENTS. Siga estes passos: 1.
Entenda o problema descrito no ticket 2. Localize o código relevante em
nossa base de código 3. Implemente uma solução que aborde a causa raiz 4. Adicione
testes apropriados 5. Prepare uma descrição concisa de PR' >
.claude/commands/fix-issue.md
2

Usar o comando com um número de problema

Em sua sessão Claude, use o comando com argumentos.
> /fix-issue 123
Isso substituirá $ARGUMENTS por “123” no prompt.
Dicas:
  • O placeholder $ARGUMENTS é substituído por qualquer texto que segue o comando
  • Você pode posicionar $ARGUMENTS em qualquer lugar no seu template de comando
  • Outras aplicações úteis: gerar casos de teste para funções específicas, criar documentação para componentes, revisar código em arquivos particulares, ou traduzir conteúdo para idiomas especificados

​
Criar comandos slash pessoais

Suponha que você queira criar comandos slash pessoais que funcionam em todos os seus projetos.
1

Criar um diretório de comandos em sua pasta home

mkdir -p ~/.claude/commands
2

Criar um arquivo Markdown para cada comando

echo "Revise este código para vulnerabilidades de segurança, focando em:" >
~/.claude/commands/security-review.md
3

Usar seu comando personalizado pessoal

> /security-review
Dicas:
  • Comandos pessoais mostram “(user)” em sua descrição quando listados com /help
  • Comandos pessoais estão disponíveis apenas para você e não são compartilhados com sua equipe
  • Comandos pessoais funcionam em todos os seus projetos
  • Você pode usá-los para fluxos de trabalho consistentes em diferentes bases de código

​
Perguntar ao Claude sobre suas capacidades

Claude tem acesso integrado à sua documentação e pode responder perguntas sobre seus próprios recursos e limitações.

​
Perguntas de exemplo

> Claude Code pode criar pull requests?

> como Claude Code lida com permissões?

> quais comandos slash estão disponíveis?

> como uso MCP com Claude Code?

> como configuro Claude Code para Amazon Bedrock?

> quais são as limitações do Claude Code?
Claude fornece respostas baseadas em documentação para essas perguntas. Para exemplos executáveis e demonstrações práticas, consulte as seções específicas de fluxo de trabalho acima.
Dicas:
  • Claude sempre tem acesso à documentação mais recente do Claude Code, independentemente da versão que você está usando
  • Faça perguntas específicas para obter respostas detalhadas
  • Claude pode explicar recursos complexos como integração MCP, configurações empresariais e fluxos de trabalho avançados

​
Próximos passos

Implementação de referência do Claude Code

Clone nossa implementação de referência de container de desenvolvimento.