Comandos de barra do Claude Code: sessões mais longas e organizadas

Comandos de barra vs flags de CLI vs atalhos de teclado

As flags de CLI definem como o Claude Code é iniciado, os atalhos de teclado lidam com interrupções em tempo real e os comandos de barra dão controle fino quando você já está dentro da sessão. 

Essas três camadas existem porque necessidades diferentes surgem em momentos diferentes do seu fluxo. Você não vai usar todas em toda sessão, mas saber que existem ajuda a pegar a ferramenta certa na hora certa.

Comandos de barra são digitados diretamente dentro de uma sessão ativa. Eles começam com / (por exemplo, /compact, /plan ou /clear) e executam na hora. Eles controlam o que está acontecendo agora, dentro da conversa em que você está.

Flags de CLI são definidas quando você inicia o Claude Code pelo terminal. Coisas como claude --model claude-opus-4-6 ou claude --continue são flags de CLI. Elas configuram a sessão antes de começar. Você pode ler mais sobre todas as flags no nosso tutorial do Claude Code CLI.

Atalhos de teclado operam no nível da interface. Esc interrompe uma resposta em execução. Apertar Esc duas vezes abre o menu de rewind. Shift+Tab alterna entre modo plano, aceitar edições e modo automático. Esses devem virar atalhos de memória muscular para ações frequentes.

Este artigo foca nos comandos de barra, usados entre prompts, com atalhos de teclado mencionados quando coincidem com algum comando específico.

Quais comandos do Claude Code são mais importantes?

A tabela a seguir cobre os 13 comandos mais importantes, todos explicados neste guia.

Observe que /cost agora é um alias de /usage nas versões mais recentes do Claude Code, e /fork é um alias de /branch.

Você pode ver todas as opções digitando / na sua sessão do Claude.

Como gerenciar a janela de contexto do Claude Code

Para gerenciar a janela de contexto no Claude Code — uma habilidade crucial para qualquer usuário avançado — use os comandos /compact, /clear e /context.

O que é a janela de contexto no Claude Code?

A janela de contexto é a memória de trabalho da sua sessão. Ela guarda muita coisa: 

• O histórico da conversa
• Conteúdo de arquivos
• Saídas de comandos
• As instruções do seu CLAUDE.md
• Contexto de MCP
• Prompts de sistema do Claude

Conforme enche, o Claude Code começa a perder de vista partes anteriores da sessão — como a estrutura de arquivos que você descreveu no início, as restrições definidas e outras infos-chave. A qualidade cai antes de você de fato atingir o limite, não só quando bate no teto.

/compact

O comando /compact resume interações antigas da conversa e as substitui por uma versão compactada, liberando tokens enquanto mantém o Claude ciente do que aconteceu antes. A boa prática é rodá-lo cedo e ser intencional sobre o que pedir para preservar.

A chamada básica é só /compact. Mas a forma mais útil é dizer o que preservar. Por exemplo: /compact focus on the auth module ou /compact retain the error handling patterns we discussed.

Quando você passa instruções, o resumo que o Claude gera enfatiza esses tópicos acima do restante. Para quem trabalha com dados, pode ser algo como /compact focus on the schema decisions and the pipeline DAG, mantendo a arquitetura em foco enquanto os detalhes linha a linha de debug são comprimidos.

Uma regra útil da comunidade: compacte antes do uso de contexto passar de 80%. Esperar encher reduz a qualidade do resumo, porque o Claude já estará operando degradado.

Um ponto importante: o conteúdo do CLAUDE.md, as skills carregadas e os arquivos de memória são preservados automaticamente durante a compactação. Você não precisa pedir explicitamente para manter.

/clear

O comando /clear apaga todo o histórico da conversa e recomeça do zero. Use /clear em mudanças de tarefa.

Você pode, opcionalmente, passar um nome para rotular a sessão antes de limpar: /clear payment-refactor. Isso rotula a sessão antiga no seletor do /resume para você voltar depois.

Se você terminou de depurar um carregador de dados e vai partir para um módulo de visualização totalmente diferente, levar o contexto antigo atrapalha mais do que ajuda. Um quadro em branco evita confusões de referência, não carrega restrições que não se aplicam mais e coloca atenção total na nova tarefa.

Use /compact para continuar o mesmo trabalho com menos inchaço de contexto e /clear para trocar de assunto por completo.

/context

Antes de decidir entre compactar ou limpar, ajuda saber como as coisas estão. O comando /context visualiza o uso atual da janela de contexto em uma grade colorida e mostra exatamente para onde os tokens estão indo.

Você verá a divisão por categoria: 

• Histórico da conversa
• Conteúdo de arquivos
• Arquivos de memória
• Skills carregadas

O legal é que o Claude sugere otimizações se algum item estiver consumindo espaço de forma incomum. Passe all para expandir o detalhamento por item: /context all

Crie o hábito de rodar /context antes de começar uma tarefa grande. Se a janela já estiver 60% cheia por causa do que rolou antes, iniciar um refactor multi-arquivo sem compactar ou limpar é pedir frustração.

Como planejar e revisar mudanças no Claude Code

O jeito mais rápido de fazer bagunça com "vibe coding" em IA é deixar o agente editar arquivos sem um plano claro. Para evitar que instruções ambíguas gerem mudanças inconsistentes, use /plan e diff.

/plan

Usar /plan coloca o Claude em modo somente leitura: ele analisa o codebase, propõe um plano de ação e espera sua aprovação antes de fazer qualquer alteração. 

Você pode passar uma descrição para dar contexto inicial: /plan refactor the feature engineering pipeline to support lazy evaluation. Nada será escrito ou apagado até você autorizar. Depois de revisar e aprovar, o Claude executa o plano completo.

O atalho de teclado para alternar o modo plano é Shift+Tab, mais rápido do que digitar o comando quando você já está no meio da sessão.

O modo plano é mais valioso em 3 situações: 

• Quando você não conhece bem o codebase
• Quando a mudança afeta muitos arquivos
• Quando as instruções são inerentemente ambíguas

Pode ser qualquer tarefa: migrar um feature store, refatorar lógica de ETL ou atualizar scripts de treinamento de modelos cheios de mudanças pontuais acumuladas ao longo dos anos.

Para se aprofundar, vale ler nosso tutorial completo: Claude Code Plan Mode: ciclos de refatoração com revisão de design primeiro.

/diff

O /diff abre um visualizador de diff interativo mostrando todas as mudanças de arquivos da sessão atual.

É útil para revisar rápido e confirmar que nada inesperado aconteceu — como mudanças em arquivos indevidas ou aumento de escopo sem querer. Pense como o último checkpoint entre "o Claude fez coisas" e "tenho certeza do que vai entrar neste commit".

Dentro do visualizador, navegue com as setas. Esquerda e direita alternam entre o diff cumulativo atual do git e os diffs por interação. Cima e baixo percorrem os arquivos dentro da visão. Assim você vê o que aconteceu ao longo da sessão e em cada turno.

Como manter o Claude Code no caminho certo

Para impedir que sessões complexas se percam e poluam o contexto com desvios, use os comandos /goal e /btw.

/goal

O comando /goal define um objetivo de alto nível que persiste ao longo das interações e mantém o Claude trabalhando rumo a um resultado definido. 

Depois que o goal é definido, o Claude segue automaticamente até a condição descrita ser atendida. É especialmente útil para migrações longas, correções amplas de testes ou qualquer tarefa que, de outra forma, exigiria ficar pedindo para continuar.

Use passando o resultado que você quer. Ajuda escrever objetivos claros, com estados finais específicos, como /goal All tests in the data pipeline are passing with no deprecation warnings.

Um overlay de progresso aparece na barra de status mostrando tempo decorrido, número de interações e uso de tokens enquanto o goal estiver ativo. Ao atingir o objetivo, o Claude para e informa a conclusão. 

Para remover um goal antes de atingir: /goal clear.

Para uma abordagem parecida, mas diferente, leia nosso tutorial sobre desenvolvimento orientado por especificação no Claude Code.

/btw

O comando /btw permite fazer uma pergunta paralela que não entra no fio principal da conversa.

O Claude responde em um overlay, e a conversa principal segue de onde parou: /btw what was that config option for SQLAlchemy connection pooling called again? 

Eu passo por isso direto: o Claude está trabalhando e surge uma dúvida sobre o processo. Se eu interrompo para perguntar, adiciono ruído e ele pode precisar reiniciar a tarefa. Se ignoro a pergunta, eu a perco. O /btw resolve isso de forma limpa.

Pense como um post-it que você passa para si mesmo no meio da tarefa — a resposta que você precisa sem o custo de contexto ou tempo de um desvio.

Como navegar entre sessões no Claude Code

Projetos longos não cabem em uma única sessão. Você precisa retomar trabalhos antigos, experimentar sem destruir o progresso e, às vezes, desfazer mudanças que deram errado. Os comandos /resume, /branch e /rewind ajudam nisso tudo.

/resume

O /resume permite continuar uma sessão anterior. Sem argumentos, ele abre um seletor com sessões recentes por data e uma ideia do último prompt. Passe um nome ou ID para ir direto: /resume payment-refactor

Você também pode fazer isso pela linha de comando antes de iniciar uma sessão. Usar claude --continue (ou claude -c) retoma a sessão mais recente, e claude --resume <id> retoma por ID. As flags de CLI e o comando de barra fazem a mesma coisa; use a CLI antes de começar ou o comando de barra no meio de uma sessão.

O Claude Code salva cada sessão localmente em ~/.claude/projects/ como um arquivo JSONL, registrando cada mensagem, uso de ferramenta e resultado. É isso que viabiliza retomar, voltar e ramificar.

/branch

O comando /branch cria uma cópia da conversa no estado atual, muda você para a nova branch e deixa a original intacta. Você pode nomear suas branches: /branch try-polars-instead-of-pandas

É o equivalente conversacional de uma branch git. Se quiser testar uma abordagem diferente sem perder a que já construiu, faça uma branch, teste a alternativa e, se não der certo, /resume volta para a original. Se funcionar, você tem uma branch limpa refletindo o melhor caminho.

Essa abordagem também é útil quando a janela de contexto está enchendo e você precisa tratar dois problemas separados que dependem do contexto reunido no chat ativo.

/branch também existe como /fork, e em materiais antigos você verá /fork. O nome canônico na documentação atual é /branch, mas ambos funcionam.

/rewind

Digamos que a gente foi longe demais e percebeu erros… O /rewind volta a sessão para uma interação anterior — como um botão de desfazer prático. 

O melhor é que você recebe um menu interativo. Navegue com as setas e selecione o ponto para onde quer voltar. 

O diferencial é escolher o que voltar:

• Ambos (padrão): arquivos são restaurados ao estado daquela interação, e as mensagens posteriores são removidas. Use quando uma sequência de mudanças deu errado e você quer recomeçar limpo de um estado bom conhecido.
• Somente conversa remove mensagens após o ponto escolhido, mas mantém as mudanças de arquivo. Use quando as respostas posteriores do Claude não ajudaram, mas o código escrito ficou ok.
• Somente código restaura os arquivos ao estado escolhido, mas mantém a conversa. Use quando quer preservar a análise e o raciocínio do Claude, desfazendo apenas as alterações de arquivo.

O atalho Esc Esc abre o mesmo menu de rewind sem digitar o comando.

Um aviso importante: apenas operações de arquivo feitas pelo Claude por meio das ferramentas oficiais são rastreadas e reversíveis. Mudanças que você fez manualmente em outro editor durante a sessão não são cobertas.

Como controlar custo e performance no Claude Code

Para equilibrar custo e performance no Claude Code, use os comandos /cost, /model e /effort.

Se você usa API, o gasto de tokens importa. Se está nos planos Pro ou Max, cumprir a cota também. Em ambos os casos, rodar o modelo mais potente com a máxima profundidade em toda tarefa é desperdício.

/cost

/cost é um alias de /usage e mostra o que você gastou até agora:

• Para usuários de API, exibe contagem de tokens, uso de cache e custo em dólar por modelo. 
• Para assinantes Pro e Max, mostra seu uso versus a cota do período de cobrança.

Vale checar /cost no início de uma sessão pesada para estabelecer uma linha de base e, depois, periodicamente em execuções longas para ver a que velocidade o orçamento está sendo consumido. 

Se os custos sobem mais rápido que o esperado, os próximos dois comandos são suas alavancas.

/model

Trocar o modelo ativo com /model no meio da sessão, sem perder contexto, é poderoso quando suas necessidades mudam ao longo do trabalho.

Sem argumentos, abre um seletor interativo navegável com as setas. Você também pode passar o nome direto: /model claude-haiku-4-5.

Uma estratégia prática: 

1. Comece a sessão com o Claude Opus para raciocínio arquitetural complexo
2. Depois mude para o Claude Sonnet para implementação
3. Caia para o Claude Haiku para tarefas mecânicas como renomear variáveis, gerar docstrings ou preencher boilerplate. 

A diferença de custo entre Opus e Haiku é de aproximadamente 10 a 20 vezes em escala.

A partir da v2.1.153, o modelo selecionado com /model é salvo como padrão para novas sessões. Pressione s no seletor interativo para aplicar só à sessão atual sem mudar o padrão.

/effort

Você decide quanta /effort o modelo usa e define a profundidade de raciocínio. Sem argumentos, abre um controle deslizante interativo; você também pode definir direto, como /effort low.

Os níveis disponíveis são: 

• low

• medium

• high

• xhigh (abril de 2026)

• max (maio de 2026)

• ultracode (maio de 2026)

Os níveis max e ultracode são apenas por sessão e não podem ser salvos como padrão. Use /effort auto para voltar ao padrão do modelo atual.

O nível ultracode combina raciocínio xhigh com orquestração automática de fluxos para tarefas multi-etapas bem complexas. Cuidado: isso pode consumir muitos tokens, já que a orquestração automática pode disparar mais de 100 agentes.

Regra prática: 

• Use low ou medium para boilerplate, geração simples de código e refactors diretos. 

• Reserve high ou xhigh para depuração complexa, decisões arquiteturais e análises multi-arquivo em que acertar de primeira evita idas e vindas. 

• Use ultracode só para grandes refactors, reescritas de codebase ou tarefas com muitos componentes em movimento. 

O esforço impacta diretamente qualidade e custo de tokens, então calibrar para a tarefa compensa.

Como criar comandos de barra personalizados no Claude Code

Os comandos nativos cobrem o básico operacional. Já os comandos personalizados é que fazem a ferramenta parecer feita sob medida para você.

A ideia é simples: qualquer prompt que você digita com frequência pode ser salvo como arquivo de comando e chamado com um único /nome-do-comando. O checklist padrão de code review do seu time, os passos de verificação de deploy do seu projeto e o seu jeito de pedir geração de testes viram itens compartilháveis. 

Comandos de barra vs skills de agente

Um aviso logo de cara: a Anthropic unificou comandos personalizados com skills. O formato .claude/commands/ agora é considerado legado. Ele continua funcionando, e a CLI seguirá suportando, mas o formato recomendado daqui para frente é .claude/skills/<name>/SKILL.md. 

As skills suportam a mesma invocação /name, podem ser chamadas autonomamente pelo Claude quando a descrição combina com a tarefa e permitem agrupar arquivos de suporte (scripts, templates, docs de referência) junto do prompt. 

Você pode ler mais sobre skills no nosso tutorial sobre Claude Skills.

Onde ficam os comandos personalizados

Comandos personalizados são arquivos Markdown armazenados em um destes locais:

• Nível de projeto: .claude/commands/ na raiz do projeto. Eles ficam limitados ao projeto, podem ir para o controle de versão e são compartilhados com quem trabalha no mesmo repositório.

• Pessoal (global): ~/.claude/commands/ no seu diretório home. Eles ficam disponíveis em todos os projetos da sua máquina e são privados para você.

O nome do arquivo sem a extensão .md vira o nome do comando. Um arquivo em .claude/commands/fix-issue.md cria /fix-issue. Um arquivo em .claude/commands/frontend/component.md cria /component com um rótulo de namespace indicando que vem do subdiretório frontend.

Se preferir usar o formato de skills, os caminhos equivalentes são .claude/skills/<command-name>/SKILL.md para projeto e ~/.claude/skills/<command-name>/SKILL.md para pessoal. O frontmatter e o corpo do prompt descritos abaixo funcionam do mesmo jeito.

O formato do arquivo

O corpo do arquivo Markdown é o template do prompt. Ao invocar o comando, o Claude lê o arquivo, processa substituições e executa como se você tivesse digitado aquele prompt.

Aqui vai um exemplo mínimo para um arquivo em .claude/commands/summarize-pr.md:

Review the current git diff and write a concise pull request description.
Include: what changed, why it changed, and any important implementation notes.
Format as plain prose, not bullet points.

Rode /summarize-pr e o Claude executa esse prompt no contexto da sessão atual.

Adicionando YAML frontmatter

Para ter mais controle sobre o comportamento do comando, adicione um YAML frontmatter no topo do arquivo:

description: Generate a PR description from the current diff
allowed-tools: Bash(git diff *), Read
model: claude-sonnet-4-6

O frontmatter é importante por vários motivos:

• description aparece na listagem do /help para você lembrar o que o comando faz — e para o Claude conseguir combiná-lo automaticamente quando você descreve um caso de uso sem chamar o comando/skill explicitamente.

• Como o nome indica, allowed-tools restringe quais ferramentas o Claude pode usar ao executar o comando — ótimo para limitar escopo e contexto. 

• Por fim, model fixa o comando em um modelo específico, independente do ativo na sessão.

Usando $ARGUMENTS

O placeholder $ARGUMENTS é o que torna os comandos personalizados bem flexíveis. Qualquer texto digitado após o nome do comando é substituído onde $ARGUMENTS aparecer no prompt.

Aqui vai um exemplo completo. Vamos criar um comando para corrigir issues do repositório chamado .claude/commands/fix-issue.md:

---
description: Find and fix a GitHub issue by number
allowed-tools: Read, Edit, Bash(git diff *)
argument-hint: [issue-number]
---

Find and fix issue #$ARGUMENTS in this repository.

Steps:
1. Read the relevant source files to understand the current behavior
2. Identify the root cause
3. Implement the fix with minimal scope — do not change unrelated code
4. Verify the fix does not break anything obvious
5. Write a brief explanation of what changed and why

Você chama assim: /fix-issue 847 e o Claude recebe o prompt completo com $ARGUMENTS substituído por 847. Também dá para usar argumentos posicionais $0, $1 etc. para comandos com várias entradas distintas.

Injetando saída ao vivo do shell

Comandos podem injetar saídas ao vivo do shell usando o prefixo !. Isso é útil quando o comando deve operar sempre no estado atual:

allowed-tools: Read, Bash(git *)
description: Review staged changes before committing

Current staged diff:
!git diff --cached

Review these changes and suggest a clear, conventional commit message.
Flag any obvious bugs, missing tests, or incomplete logic before I commit.

Quando o Claude carrega esse comando, ele roda git diff --cached, captura a saída e injeta no prompt. O Claude vê o diff real, não um placeholder.

Essa combinação de $ARGUMENTS, injeção de shell e frontmatter torna os comandos personalizados do Claude Code um ótimo jeito de acelerar seus prompts. 

Para mais padrões e exemplos reais, os tutoriais da DataCamp sobre Claude Code Best Practices e Claude Code Hooks mostram como esses recursos se encaixam em fluxos de trabalho de produção.

Considerações finais

Comandos de barra não são recursos avançados só para power users. Eles são a camada operacional básica do Claude Code — aprender cedo muda sua forma de encarar o desenvolvimento assistido por IA.

Se você está começando, vá de pouquinho. Adote /compact, /plan e /cost como formas simples e poderosas de otimizar suas sessões. Quando isso estiver natural, adicione /diff antes dos commits e /goal para qualquer tarefa que dure mais de algumas interações. O resto vem com a prática.

Para mais inspiração de comandos personalizados, recomendo continuar com nosso tutorial de Claude Code no terminal. Se você quer uma base estruturada de como os modelos Claude pensam e para que foram projetados, nossos cursos Introduction to Claude Models e Claude Code 101 são o lugar certo para construir isso.