Comandos de Barra (Slash Commands): Um único / para Acessar Todos os Atalhos do Claude
📚 Navegação da Série: O capítulo anterior 35 Controle e Modos ensinou você a apertar ou soltar as rédeas do Claude durante a sessão (interruptores como modo de permissão,
/model,/effort). Este capítulo traz o foco de volta para aquele ponto de entrada que você digita todos os dias, mas talvez ainda não domine completamente — os comandos de barra. Ao digitar/, tudo, desde trocar de modelo e limpar o contexto até executar fluxos personalizados criados por você, estará disponível em um único menu. Vou apresentar os comandos embutidos e ensinar como criar os seus próprios.
Muitas pessoas, quando começaram a usar o Claude Code, cometeram um erro bobo.
Toda vez que queriam limpar a conversa e começar do zero, faziam exatamente isto: pressionavam Ctrl+C para sair do claude, depois digitavam claude no terminal para reiniciar, esperavam que ele recarregasse o projeto e lesse o CLAUDE.md novamente — um processo que levava cerca de dez segundos. Depois de repetir isso por uma ou duas semanas, ainda achavam que "reiniciar era assim mesmo". Até que, ao ler a documentação oficial, depararam-se com o comando /clear, cuja descrição era simplesmente "inicia uma nova conversa com um contexto vazio". Foi aí que perceberam: bastavam três caracteres no meio da sessão, e as duas semanas de reinicializações foram puro desperdício de tempo.
O pior veio depois. Descobriram que /compact resume conversas longas para continuar o papo, /model troca de modelo sem reiniciar, /init gera o CLAUDE.md com um clique... todas tarefas que antes eram feitas manualmente ou que nem sabiam ser possíveis. Esses comandos sempre estiveram ali, no menu que surge ao digitar /, mas nunca tinham sido explorados.
Contamos essa história para que você evite caminhos desnecessários: os comandos de barra não são um "recurso avançado", são o painel de controle básico do Claude Code. Quase todas as "meta-operações" que você deseja realizar na sessão — não para pedir que ele escreva código, mas para gerenciar a ferramenta em si — começam com /. Este capítulo apresentará os comandos integrados e ensinará como transformar os prompts que você digita repetidamente em comandos personalizados acionáveis com um clique.
Ao ler este capítulo, você obterá:
- A definição simples do que é um comando de barra e por que ele só funciona se estiver no início da mensagem.
- Uma lista organizada por cenários de uso dos comandos embutidos (
/help,/clear,/compact,/init,/model,/agents,/mcp,/memoryetc.), para consulta rápida. - O passo a passo completo para criar seu próprio comando de barra: basta salvar um arquivo markdown sob
.claude/commands/, adicionar frontmatter e receber parâmetros com$ARGUMENTS. - Um truque avançado: como fazer com que o comando injete dados dinâmicos do ambiente (como
git diff) antes de enviar o prompt ao Claude. - O funcionamento de namespaces e por que comandos de plugins nunca entrarão em conflito com os seus.
- A relação real entre comandos de barra e Skills (em uma frase: um comando de barra é a forma de acionar uma Skill "ativamente", conforme detalhado no Capítulo 26).
- Um exercício prático com resultado esperado: crie um comando
/explaincom parâmetros em 5 minutos e valide seu funcionamento.
01 O que é de fato um Comando de Barra e por que só funciona no Início?
Para ir direto ao ponto: um comando de barra é uma instrução de controle que você executa na sessão do Claude — não para pedir que o Claude faça algo, mas para comandar o próprio programa Claude Code: trocar de modelo, limpar o contexto, executar um fluxo de trabalho ou abrir um painel.
Ao longo dos capítulos anteriores, vimos que as interações com o Claude dividem-se em dois tipos. O primeiro são as demandas de desenvolvimento: "refatore esta função", "o que significa este erro?" — que são direcionadas ao modelo. O segundo são as meta-operações: "limpe a conversa", "mude para um modelo mais barato", "gere uma documentação do projeto" — que não devem depender de uma conversa com o modelo, mas sim de um botão de comando direto. Os comandos de barra são esses botões.
Analogia: Os botões de atalho no controle remoto da TV. Ao assistir TV, para mudar de canal, ajustar o volume, trocar a entrada de vídeo ou abrir o menu, você não fala com a TV pedindo para aumentar o som; você pressiona o botão correspondente no controle remoto. Cada botão executa uma tarefa específica e imediata, sem necessidade de interpretação ou risco de erro. Os comandos de barra são esses botões no Claude Code: /clear limpa a tela, /model altera o modelo e /help abre o menu de ajuda — ações programadas que não envolvem "pedir ajuda ao modelo".
A documentação define a função deles claramente:
Os comandos controlam o Claude Code de dentro da sessão. Eles oferecem uma maneira rápida de alternar modelos, gerenciar permissões, limpar o contexto, executar fluxos de trabalho e muito mais.
Aqui está um detalhe importante onde os iniciantes costumam errar — e que a documentação oficial enfatiza: os comandos só são identificados no início da mensagem:
Os comandos só são reconhecidos no início da mensagem. O texto que segue o nome do comando é passado a ele como parâmetro.
Em termos simples: o caractere / deve ser o primeiro caractere da mensagem para que ela seja tratada como um comando. Se você digitar "me diga o que o /clear faz", o /clear estará no meio da frase e não será executado, sendo enviado como texto normal para o Claude. Esse design é intencional — caso contrário, ao discutir os comandos com o Claude, a conversa seria limpa toda vez que você mencionasse /clear. Lembre-se: o comando inicia a linha, e o texto seguinte são os parâmetros.
Considere alguns cenários reais de uso desses "botões":
- Notou no meio da conversa que precisa de um modelo mais potente — sem sair e reiniciar, digite
/modelpara trocar de modelo imediatamente, mantendo o histórico da conversa. - Concluiu uma tarefa e quer começar outra totalmente diferente — digite
/clearpara limpar a tela; a conversa anterior ainda poderá ser recuperada via/resume. - Acabou de clonar um projeto desconhecido e quer que o Claude o entenda — digite
/initpara que ele analise o código e gere o arquivoCLAUDE.md.
O fator comum aqui: não estamos pedindo para o Claude programar, mas sim controlando o próprio Claude Code — a especialidade dos comandos de barra.
Como ver todos os comandos disponíveis? O jeito mais fácil — digite / na sessão para abrir o menu pop-up com todos os comandos que você pode usar; continue digitando letras para filtrar a lista em tempo real. A documentação oficial orienta:
Digite
/para visualizar todos os comandos disponíveis, ou digite/seguido de letras para filtrar.
💡 Resumo em uma frase: Os comandos de barra funcionam como o painel de controle do Claude Code, gerenciando o programa (mudar modelo, limpar contexto, rodar rotinas) em vez de pedir tarefas de código; só funcionam se inseridos no início da linha, e digitar
/exibe a lista completa.
02 Lista de Comandos Embutidos: Organizada por Etapa de Trabalho
Como existem dezenas de comandos integrados, decorar todos de uma vez é desnecessário. A documentação oficial do Claude Code organiza-os de acordo com o fluxo de uma sessão de trabalho — basta consultar a linha correspondente à sua necessidade no momento.
Antes de prosseguirmos, vale esclarecer: a maioria deles são "comandos integrados" (cujo comportamento está programado diretamente na CLI), enquanto alguns são classificados como Skills — que funcionam como instruções pré-configuradas para o Claude orquestrar tarefas usando suas próprias ferramentas (como /code-review e /debug). Há ainda um número menor de comandos chamados de Workflows — processos dinâmicos executados por múltiplos subagentes em paralelo (como /batch e /deep-research). Para você, todos são acionados digitando / seguido do nome, sem diferença na usabilidade; a diferença está apenas na implementação interna (assunto detalhado no Capítulo 26).
Grupo 1: Preparação ao Entrar em um Novo Projeto
| Comando | Função | Quando usar |
|---|---|---|
/init | Gera um arquivo CLAUDE.md inicial para o projeto | Ao começar a trabalhar em um repositório pela primeira vez (Capítulo 12) |
/memory | Edita a memória do CLAUDE.md ou gerencia a memória automática | Para ajustar as diretrizes após a execução do /init (Capítulo 25) |
/mcp | Gerencia conexões e permissões de servidores MCP | Para conectar ferramentas e serviços externos (Capítulo 22) |
/agents | Gerencia a configuração de subagentes | Para delegar tarefas a agentes especializados (Capítulo 23) |
/permissions | Gerencia regras de permissão (permitir/perguntar/negar) | Para definir se a IA deve pedir confirmação antes de agir (Capítulo 20) |
Este grupo reflete o fluxo inicial padrão ao entrar em um projeto: primeiro execute /init para ler o código e gerar o rascunho do CLAUDE.md, depois use /memory para ajustar possíveis suposições incorretas. Isso evita ter que escrever essa documentação do zero — o que é uma excelente facilidade no primeiro uso.
Grupo 2: Ajustes no Meio do Trabalho
| Comando | Função | Quando usar |
|---|---|---|
/model | Alterna o modelo e o define como padrão para novas sessões | Para mudar para um modelo mais potente ou mais barato |
/clear | Abre uma nova conversa com contexto limpo (recuperável via /resume) | Para começar uma nova tarefa do zero, limpando a mesa de trabalho |
/compact | Reduz a conversa atual a um resumo para liberar espaço de contexto | Quando a conversa estiver muito longa e o contexto quase cheio (Capítulo 19) |
/context | Exibe o uso atual do contexto em uma grade colorida | Para visualizar o consumo de memória da sessão |
/plan | Ativa diretamente o modo de planejamento (plan mode) | Antes de grandes alterações, para propor planos sem modificar arquivos |
A diferença entre /clear e /compact é uma dúvida comum. O segredo está em: use /clear para iniciar uma tarefa totalmente nova e não relacionada (limpando a mesa), e use /compact para resumir a conversa atual e continuar na mesma tarefa (economizando espaço de rascunho). O Capítulo 19 detalha essa diferença. Lembre-se: "mudar de tarefa = clear; continuar a tarefa = compact".
Grupo 3: Validação Antes da Entrega
| Comando | Função |
|---|---|
/diff | Abre um visualizador de diff interativo para alterações não salvas |
/review | Revisa um pull request (PR) na sessão atual |
/security-review | Varre as alterações do branch atual em busca de falhas de segurança |
/code-review | Revisa o diff em busca de bugs e simplificações, aceitando --fix para correções diretas |
Grupo 4: Comandos Diversos de Utilidade Geral
| Comando | Função |
|---|---|
/help | Exibe a ajuda e os comandos disponíveis |
/config | Abre o menu de configurações (temas, modelos, estilos de saída, etc.) |
/doctor | Analisa a instalação e a configuração, permitindo correção automática com f |
/resume | Restaura uma conversa anterior pelo ID ou nome, ou abre o menu de seleção |
/skills | Lista todas as Skills disponíveis no momento |
/rewind | Restaura o código e/ou a conversa para um ponto de controle anterior (assunto do próximo capítulo) |
Nota: a disponibilidade dos comandos pode variar. Como diz a documentação oficial, "a disponibilidade depende do seu sistema operacional, plano e ambiente". Por exemplo,
/desktopaparece apenas no macOS e Windows com login de assinatura do Claude, e/upgradeé exclusivo para planos Pro e Max. O menu que surge ao digitar/exibe exatamente o que está disponível no seu ambiente de trabalho — use-o como referência principal.
Embora esta lista não seja exaustiva (a tabela oficial contém dezenas de itens), ela cobre cerca de 90% do seu uso diário. Para necessidades específicas, basta digitar / e filtrar digitando as primeiras letras do comando.
💡 Resumo em uma frase: Não tente decorar os comandos integrados; consulte-os conforme a etapa do fluxo de trabalho — inicialização (
/init,/memory), ajustes em tempo de execução (/model,/clear,/compact), revisão (/diff,/code-review) e utilitários (/help,/doctor,/resume). O menu do/é a sua lista em tempo real.
03 Criando Seu Próprio Comando: Crie um Markdown sob .claude/commands/
Conhecer os comandos integrados é ótimo, mas o verdadeiro poder dos comandos de barra surge quando você cria os seus.
Por que fazer isso? Pense nos prompts que você digita repetidamente no dia a dia com o Claude — ditar as diretrizes de commit, as regras de revisão de PR ou o formato de explicação de código. Quando você se pegar digitando a mesma instrução pela quinta vez, é um sinal claro: hora de transformá-la em um comando.
Analogia: Programar uma tecla de atalho no controle remoto. Controles universais mais avançados permitem gravar uma macro (como ligar a TV → mudar para HDMI2 → ajustar volume para 15). Depois disso, basta pressionar um botão para que toda a sequência seja executada automaticamente. Comandos personalizados funcionam exatamente assim: você grava um prompt recorrente sob um nome de comando e, ao digitá-lo, o texto é enviado de forma automatizada.
Como fazer? É surpreendentemente simples — basta salvar um arquivo markdown sob o diretório .claude/commands/, onde o nome do arquivo define o nome do comando. A documentação oficial descreve:
O arquivo em
.claude/commands/deploy.md... cria o comando/deploy.
Isso significa que, se você criar um arquivo .claude/commands/commit.md contendo suas diretrizes de commit, ele se tornará instantaneamente o comando /commit. O nome do arquivo (sem a extensão .md) define o comando que você digitará no prompt. Sem necessidade de configurações adicionais.
Vejamos um exemplo simples. Crie o arquivo .claude/commands/review.md com o seguinte conteúdo:
Por favor, analise minhas alterações não salvas no momento, focando em três pontos:
1. Tratamento de erros ausentes.
2. Valores de configuração fixados no código (portas, chaves, caminhos).
3. Testes necessários que não foram adicionados.
Apresente em português, listando os pontos por arquivo.Após salvar, ao digitar /review na sessão, o Claude receberá exatamente a instrução acima — poupando você de digitar todo esse texto manualmente, reduzindo a ação a apenas sete caracteres digitados.
Aqui está a diferença importante de localização do arquivo, em linha com o que vimos sobre MCP e Skills:
| Localização do Arquivo | Escopo do Comando | Salvo no Git? |
|---|---|---|
Nível do Projeto .claude/commands/ | Apenas no projeto atual | Sim, disponível para toda a equipe |
Nível do Usuário ~/.claude/commands/ | Em todos os seus projetos | Não, uso pessoal privado |
A lógica é a mesma das Skills: se o comando é específico para um projeto e útil para outros colaboradores (como o fluxo de deploy desse repositório), salve no nível do projeto e envie ao controle de versão; se for um utilitário geral para seu fluxo de trabalho pessoal (como seu estilo de explicação de código), salve na pasta pessoal do usuário em ~/.claude/commands/. Ter seus comandos pessoais disponíveis automaticamente em qualquer projeto poupa muito tempo de configuração.
💡 Resumo em uma frase: Criar comandos personalizados é automatizar prompts recorrentes — salve um markdown em
.claude/commands/(com o nome do arquivo definindo o comando); use o escopo do projeto para compartilhar com o time, ou a pasta do usuário (~/.claude/commands/) para uso pessoal em múltiplos projetos.
04 Expandindo Comandos: Configurações de Frontmatter e Parâmetros com $ARGUMENTS
O comando /review criado anteriormente funciona, mas tem um limite: ele é estático e não aceita parâmetros. Não há como pedir "analise apenas o arquivo src/auth.ts" — ele sempre analisará todas as alterações. Para torná-lo flexível, precisamos de duas coisas: configurações de frontmatter e variáveis de parâmetros.
Capturando Parâmetros com $ARGUMENTS
Para trabalhar com argumentos, o Claude Code fornece a variável $ARGUMENTS — qualquer texto que você digitar após o nome do comando substituirá essa variável no prompt enviado. O exemplo da documentação ilustra isso claramente:
Fix GitHub issue $ARGUMENTS following our coding standards.
1. Read the issue description
2. Understand the requirements
3. Implement the fixA documentação explica o resultado:
Ao executar
/fix-issue 123, o Claude receberá "Fix GitHub issue 123 following our coding standards..."
O valor 123 digitado no prompt substitui a variável $ARGUMENTS. Um único modelo de comando, com parâmetros dinâmicos — essa é a chave da flexibilidade.
Há também uma proteção integrada: a documentação explica que, se você passar argumentos mas o arquivo do comando não contiver a variável
$ARGUMENTS, o Claude Code anexará automaticamenteARGUMENTS: <seu texto>ao final do prompt enviado "para garantir que o Claude veja o que você digitou". Dessa forma, o parâmetro nunca é perdido.
Múltiplos Parâmetros? Use $0, $1 por Posição
Se você precisar de vários parâmetros (como "migre o componente SearchBar do React para o Vue"), use as variáveis posicionais — $ARGUMENTS[N] ou o atalho $N (iniciando em 0):
Migrate the $0 component from $1 to $2.
Preserve all existing behavior and tests.Ao executar /migrate-component SearchBar React Vue, $0 receberá SearchBar, $1 receberá React e $2 receberá Vue. Fique atento a um detalhe: a documentação oficial observa que o parsing segue as regras de aspas do shell — ou seja, valores que contenham espaços devem ser envolvidos em aspas para serem lidos como um único parâmetro. Por exemplo, em /my-cmd "hello world" second, $0 receberá hello world por completo, caso contrário o espaço dividiria as palavras. (A variável global $ARGUMENTS não sofre essa divisão, recebendo todo o texto digitado de forma literal).
Controlando o Comportamento com Frontmatter
Além de aceitar parâmetros, você pode precisar restringir ações para evitar surpresas — como impedir que o Claude execute um deploy automático sem sua validação direta. É aí que entra o frontmatter.
O frontmatter consiste em configurações YAML delimitadas por --- no início del arquivo (o mesmo conceito visto nas diretrizes de SKILL.md no Capítulo 26). Os dois campos mais importantes para comandos são:
---
description: Adiciona e commita as alterações atuais
disable-model-invocation: true
---
Adicione e envie as alterações atuais com uma mensagem de commit em português seguindo o padrão feat/fix/docs:
1. Execute a suíte de testes primeiro
2. Execute git add para as alterações
3. Commite com uma mensagem clara em portuguêsdescription: Uma breve descrição do que o comando faz. O Claude usa essa descrição para decidir se deve acionar o comando de forma autônoma, por isso é recomendado preenchê-la sempre.disable-model-invocation: true: Configurado comotrue, este comando só poderá ser acionado manualmente por você, impedindo o Claude de ativá-lo por conta própria. Deve ser usado em comandos que causam efeitos colaterais (deploy, commits, envios de mensagens).
Isso destaca um ponto crucial sobre o comportamento do sistema — por padrão, comandos personalizados podem ser acionados tanto por você quanto pelo Claude. Você digita /commit para acioná-lo de forma direta; mas se o Claude identificar que a descrição de /commit atende à necessidade atual, ele poderá executá-lo de forma autônoma. Isso mostra como comandos e Skills compartilham a mesma essência (Capítulo 26). Para manter controle total e evitar ações autônomas, configure disable-model-invocation: true. Comandos de commits e deploys devem sempre conter essa configuração.
| Comportamento Desejado | Configuração de Frontmatter |
|---|---|
| Impedir ativação autônoma do Claude (apenas acionamento manual) | disable-model-invocation: true |
| Permitir que o Claude saiba quando o comando é útil | Definir description |
| Restringir as ferramentas disponíveis durante o comando | Ex: allowed-tools: Bash(git add *) Bash(git commit *) |
💡 Resumo em uma frase: Use
$ARGUMENTSpara receber todo o texto digitado ou$0/$1para ler parâmetros por posição (valores com espaço exigem aspas); no frontmatter,descriptionorienta o uso autônomo do Claude, enquantodisable-model-invocation: truebloqueia o comando para acionamento exclusivamente manual (essencial para tarefas críticas).
05 Injeção de Contexto Dinâmico: Trazendo Dados do Ambiente
Além de aceitar parâmetros de texto, você pode tornar seus comandos ainda mais inteligentes fazendo com que eles capturem dados do ambiente no momento da execução. Essa técnica, chamada de injeção de contexto dinâmico, permite preencher dados antes de enviar o prompt ao Claude.
Considere o comando /review. Em sua forma simples, ele instrui: "analise minhas alterações não salvas no momento". Para executar isso, o Claude ainda precisará rodar o comando git diff de forma autônoma para ler o código modificado. E se pudéssemos injetar o diff diretamente no prompt antes que a IA leia a instrução? É possível fazer isso.
A sintaxe para injeção é !`comando` (um ponto de exclamação seguido do comando shell envolvido em crases). A documentação explica o funcionamento:
A sintaxe
!`<command>`executa o comando shell antes de enviar o conteúdo ao Claude. A saída do comando substitui a variável, garantindo que o Claude receba os dados reais em vez da instrução de comando.
Vamos atualizar o arquivo do comando /review em .claude/commands/review.md:
## Alterações Atuais
!`git diff HEAD`
## Instruções
Analise as alterações acima focando em tratamentos de erro ausentes, configurações expostas e cobertura de testes. Liste as observações em português.O que acontece com a linha !`git diff HEAD`? A ordem de execução ocorre da seguinte forma:
- O Claude Code executa o comando
git diff HEADno shell local do sistema. - O resultado (output) do comando substitui a linha correspondente no markdown.
- O Claude recebe a instrução final com as alterações reais já preenchidas.
Dessa forma, a IA recebe os dados prontos para análise, eliminando a etapa de ter que descobrir as alterações por conta própria. O processamento é realizado antes do envio do prompt, otimizando o fluxo.
Alguns detalhes de uso importantes para evitar problemas:
- O ponto de exclamação deve estar no início da linha ou precedido por espaço. Configurações como
KEY=!cmdcoladas a outros caracteres não serão interpretadas como shell e serão enviadas como texto literal. - Para múltiplos comandos em sequência, em vez da sintaxe em linha, use o bloco de código demarcado por
```!(executando um comando por linha). - Este recurso pode ser desativado por segurança: configurando
disableSkillShellExecution: trueno painel de configurações, o sistema impede a execução de chamadas shell em comandos, substituindo-as por uma mensagem de aviso em inglês:[shell command execution disabled by policy]. É muito útil em ambientes corporativos para evitar que comandos compartilhados em repositórios executem scripts indesejados.
Dica de preenchimento automático: se você definir argument-hint no frontmatter (como argument-hint: [numero-da-issue]), a CLI exibirá essa dica visual enquanto você digita o nome do comando no prompt, facilitando o uso sem precisar consultar documentações.
💡 Resumo em uma frase: A sintaxe
!`comando`permite que o comando capture dados do sistema (comogit diff) e os injete no prompt antes do envio ao Claude, agilizando a resposta; use no início da linha, blocos de código com!para múltiplas instruções e desative viadisableSkillShellExecutionem ambientes de equipe se necessário.
06 Namespaces: Evitando Conflitos entre Comandos
Conforme você cria comandos personalizados e instala plugins (que trazem seus próprios comandos), surge uma dúvida natural: o que acontece se houver comandos com o mesmo nome? Se você criar um /review e instalar um plugin que também possui um /review, qual deles será acionado?
O sistema resolve conflitos com base na origem dos comandos.
Conflitos entre Recursos Próprios: Prevalência de Skills
Se houver uma Skill em .claude/skills/ e um comando em .claude/commands/ com o mesmo nome, a documentação define a seguinte regra de prioridade:
Se uma skill e um comando compartilham o mesmo nome, a skill tem prioridade.
Se você tiver .claude/commands/deploy.md e .claude/skills/deploy/SKILL.md, digitar /deploy executará a Skill. Tenha essa regra de prioridade em mente, embora o ideal seja evitar criar nomes duplicados prositalmente.
Comandos de Plugins: Namespaces Dedicados
No caso de comandos que acompanham plugins, a separação é garantida por design — eles não disputam o mesmo nome:
As skills de plugins utilizam o namespace
nome-do-plugin:nome-da-skill, garantindo que não colidam com comandos de outros níveis.
Analogia: Adicionar sobrenomes ou empresas para contatos homônimos na agenda. Se você tem dois conhecidos chamados "Alex", costuma salvá-los como "Alex (Trabalho)" e "Alex (Faculdade)" para não confundir. O namespace faz exatamente isso: o comando review do plugin my-plugin será registrado como /my-plugin:review. Dessa forma, mesmo que você possua um comando pessoal /review, ambos coexistirão sem conflitos.
Por isso, como vimos no Capítulo 24 sobre plugins, comandos de plugins utilizam o formato nome-do-plugin:nome-do-comando para evitar conflitos de nomes. Se instalar múltiplos plugins que contenham o comando review, eles serão mapeados como /plugin-a:review e /plugin-b:review, mantendo cada um em seu respectivo escopo.
Comandos com o prefixo de duplo sublinhado (__) representam prompts expostos por servidores MCP. Eles seguem o formato /mcp__<servidor>__<prompt>, permitindo a descoberta dinâmica a partir dos servidores conectados (conforme detalhado no Capítulo 22).
💡 Resumo em uma frase: Em conflitos de nomes locais, as Skills têm prioridade sobre comandos; para plugins, o conflito é evitado usando a estrutura de namespace
nome-do-plugin:nome-do-comando; e chamadas de servidores MCP seguem o padrão/mcp__<servidor>__<prompt>.
07 Comandos de Barra e Skills: Qual a Relação e Como Escolher?
Nesta altura, você deve estar se perguntando: qual a real diferença entre comandos de barra e as Skills explicadas no Capítulo 26? O markdown em .claude/commands/ difere em que de um arquivo SKILL.md em .claude/skills/?
Esta é uma dúvida muito comum para quem está começando. A resposta é direta:
Os comandos de barra personalizados foram integrados ao ecossistema de Skills. Os arquivos markdown sob
.claude/commands/continuam funcionando normalmente, mas as Skills trazem recursos adicionais — como suporte a scripts e arquivos complementares, controle refinado de ativação autônoma pelo Claude e injeção progressiva de contexto (em vez de carregar toda a documentação no início da sessão).
A documentação oficial afirma:
Os comandos personalizados foram mesclados às skills. Tanto um arquivo em
.claude/commands/deploy.mdquanto uma skill em.claude/skills/deploy/SKILL.mdcriam o comando/deploye funcionam da mesma maneira.
Isso significa que ambos compartilham o mesmo motor de execução. Podemos ver a relação da seguinte forma: "comando de barra" é a forma de acionamento (o atalho digitado com /), enquanto a Skill é a estrutura que contém a lógica. O Capítulo 30 detalha a escolha entre as ferramentas do ecossistema, mas a tabela abaixo ajuda a escolher o melhor caminho para cada necessidade:
| Necessidade | Comando Simples (.claude/commands/xx.md) | Skill Completa (.claude/skills/xx/SKILL.md) |
|---|---|---|
| Prompt de texto estático acionado manualmente | ✅ Ideal, mais simples de criar | Possível, mas desnecessariamente complexo |
| Depende de templates, scripts ou arquivos de teste | ❌ Não suportado | ✅ Estrutura de diretório ideal para arquivos adicionais |
| Permitir que o Claude decida quando acionar | Possível via description, mas limitado | ✅ Caso de uso nativo principal |
| Injetar documentações extensas sem estourar o contexto | ❌ Carregado por completo | ✅ Suporta referências sob demanda nos arquivos da pasta |
Uma regra prática: se o seu objetivo é automatizar um prompt simples de texto acionado por você no dia a dia (como o comando /review), un arquivo markdown em .claude/commands/ resolve o problema com menor esforço; se precisar estruturar scripts auxiliares, referenciar manuais extensos ou permitir que o Claude tome a decisão de uso, opte por criar uma Skill (detalhado nos Capítulos 26, 27 e 28).
Os comandos em .claude/commands/ continuam sendo um recurso oficialmente suportado pelo ecossistema, servindo como uma excelente porta de entrada antes de avançar para estruturas mais complexas de Skills.
💡 Resumo em uma frase: Comandos de barra personalizados compartilham a mesma base técnica das Skills — use arquivos em
.claude/commands/para prompts de texto simples acionados por você, e estruture uma Skill completa quando precisar de scripts de apoio, arquivos de referência ou acionamentos autônomos.
08 Prática: Criando Seu Comando /explain em 5 Minutos
Vamos consolidar o aprendizado criando um comando prático que aceita parâmetros — um explicador de código chamado /explain voltado para iniciantes. Você pode realizar este teste em uma pasta vazia.
Passo 1: Criar o diretório de comandos
Em um diretório de sua escolha, crie a pasta .claude/commands/:
mkdir -p .claude/commands(No Windows, crie a pasta .claude\commands\ usando o explorador de arquivos ou o PowerShell no diretório raiz do teste).
Resultado esperado: O diretório
.claude/commands/é criado com sucesso.
Passo 2: Criar o arquivo do comando
Abra seu editor de texto e salve o seguinte conteúdo no arquivo .claude/commands/explain.md:
---
description: Explica um trecho de código ou mensagem de erro em linguagem simples. Use quando o usuário solicitar ajuda para entender um código ou erro.
---
Por favor, explique o seguinte conteúdo em linguagem simples, ideal para iniciantes:
$ARGUMENTS
Regras de resposta:
1. Explique brevemente o objetivo geral do código ou erro.
2. Detalhe o funcionamento linha por linha ou por blocos.
3. Se for uma mensagem de erro, aponte a causa provável e como corrigi-la.
4. Evite jargões excessivos e use analogias do dia a dia quando possível.Nota: o campo
descriptionno frontmatter orienta o Claude sobre a utilidade do comando, e$ARGUMENTSreceberá o código ou erro que passarmos no prompt.
Resultado esperado: O arquivo
explain.mdé salvo no diretório correspondente.
Passo 3: Iniciar o Claude Code e verificar o comando
Inicie a ferramenta no terminal:
claudeDigite / no prompt da sessão (apenas a barra, sem pressionar Enter) para listar as opções:
Resultado esperado: O comando
/explainaparece listado no menu com a descrição fornecida no frontmatter. A presença no menu confirma que o comando foi carregado com sucesso. Caso não apareça, verifique se o caminho do arquivo é exatamente.claude/commands/explain.md.
Passo 4: Executar o comando passando parâmetros
Execute o comando fornecendo um trecho de código como argumento (que preencherá a variável $ARGUMENTS):
/explain print(sum([1,2,3]) / len([1,2,3]))Resultado esperado: O Claude recebe a instrução completa com a variável
$ARGUMENTSsubstituída pelo código fornecido, estruturando a resposta conforme as quatro regras definidas (explicando a média aritmética com linguagem simples e analogias). O preenchimento automático demonstra o funcionamento de parâmetros em comandos.
Passo 5: Testar com outro parâmetro
Substitua o parâmetro por uma mensagem de erro clássica:
/explain ZeroDivisionError: division by zeroResultado esperado: O comando
/explainé acionado novamente, desta vez analisando a falha de divisão por zero e focando na regra 3 (causas comuns e correção). O teste demonstra a flexibilidade de aplicar o mesmo modelo de prompt a parâmetros dinâmicos.
Com a conclusão deste exercício, você validou a criação de comandos via markdown, a configuração de descrições e o recebimento de parâmetros com $ARGUMENTS. O mesmo processo pode ser usado para estruturar qualquer comando personalizado de seu interesse.
💡 Resumo em uma frase: Para criar comandos, basta salvar um markdown em
.claude/commands/(que define o nome do comando), adicionar a descrição e mapear a variável$ARGUMENTS; digite/na CLI para validar o menu e execute testes com parâmetros diferentes para consolidar o aprendizado.
09 Resumo
Neste capítulo, desmistificamos os comandos de barra, revelando-os como a central de controle operacional do Claude Code — gerenciando desde configurações internas até automações personalizadas criadas por você.
Revisão dos pontos principais abordados:
| Assunto | Conceito Chave | Aplicação |
|---|---|---|
| O que são comandos | Atalhos de controle do programa | Gerenciam a CLI (limpar tela, mudar modelo) e só funcionam no início do prompt |
| Comandos embutidos | Organizados por fluxo de trabalho | Inicialização (/init), controle em tempo real (/model, /clear, /compact), revisão (/code-review) |
| Como personalizar | Salvar markdown em pasta específica | .claude/commands/ (projeto) ou ~/.claude/commands/ (pessoal) |
| Recebimento de parâmetros | Substituição de variáveis | $ARGUMENTS para entrada geral, ou $0/$1 para dados posicionais |
| Injeção de shell | Execução prévia de comandos | Sintaxe !`comando` para injetar dados como git diff antes de enviar o prompt |
| Configurações de frontmatter | Controle comportamental | description para guiar a IA, e disable-model-invocation: true para bloquear chamadas automáticas |
| Namespaces de plugins | Evitar conflito de nomes | Comandos de plugins seguem a estrutura /nome-do-plugin:nome-do-comando |
| Relação com as Skills | Compartilham o mesmo motor técnico | O comando é a porta de entrada simples, e a Skill é a estrutura para fluxos complexos |
Agora você é capaz de: navegar com facilidade pelo menu / e escolher o comando embutido correto para cada momento da sessão, criar comandos markdown personalizados para automatizar seus prompts diários usando parâmetros, injetar dados dinâmicos do ambiente com comandos shell pré-processados e decidir quando expandir seus atalhos para Skills completas. Isso elimina tarefas manuais repetitivas e otimiza sua velocidade de desenvolvimento.
Com os modos de controle e os comandos de barra explicados, avançamos significativamente nas opções de interação com a ferramenta.
O próximo capítulo, 37 "Pontos de Controle (Checkpoints)", abordará detalhadamente o comando /rewind que mencionamos rapidamente. Se o Claude realizar uma série de modificações no código e o resultado não for o esperado, como retornar ao estado anterior com facilidade? Veremos como funciona a mecânica de pontos de salvamento automáticos do Claude Code para reverter o código e a conversa para estados seguros, permitindo testar soluções com maior segurança. Nos vemos no próximo capítulo!