Skip to main content

​
Comandos de barra integrados

ComandoPropósito
/add-dirAdicionar diretórios de trabalho adicionais
/agentsGerenciar subagentes de IA personalizados para tarefas especializadas
/bashesListar e gerenciar tarefas em segundo plano
/bugRelatar bugs (envia conversa para Anthropic)
/clearLimpar histórico de conversa
/compact [instructions]Compactar conversa com instruções de foco opcionais
/configAbrir a interface de Configurações (aba Config)
/contextVisualizar uso de contexto atual como uma grade colorida
/costMostrar estatísticas de uso de tokens. Veja guia de rastreamento de custos para detalhes específicos de assinatura.
/doctorVerifica a saúde da sua instalação do Claude Code
/exitSair do REPL
/export [filename]Exportar a conversa atual para um arquivo ou área de transferência
/helpObter ajuda de uso
/hooksGerenciar configurações de hooks para eventos de ferramentas
/ideGerenciar integrações de IDE e mostrar status
/initInicializar projeto com guia CLAUDE.md
/install-github-appConfigurar Claude GitHub Actions para um repositório
/loginAlternar contas Anthropic
/logoutSair da sua conta Anthropic
/mcpGerenciar conexões de servidor MCP e autenticação OAuth
/memoryEditar arquivos de memória CLAUDE.md
/modelSelecionar ou alterar o modelo de IA
/output-style [style]Definir o estilo de saída diretamente ou a partir de um menu de seleção
/permissionsVisualizar ou atualizar permissões
/planEntrar no modo de plano diretamente do prompt
/pluginGerenciar plugins do Claude Code
/pr-commentsVisualizar comentários de solicitação de pull
/privacy-settingsVisualizar e atualizar suas configurações de privacidade
/release-notesVisualizar notas de lançamento
/rename <name>Renomear a sessão atual para identificação mais fácil
/remote-envConfigurar ambiente de sessão remota (assinantes claude.ai)
/resume [session]Retomar uma conversa por ID ou nome, ou abrir o seletor de sessão
/reviewSolicitar revisão de código
/rewindRetroceder a conversa e/ou código
/sandboxAtivar ferramenta bash em sandbox com isolamento de sistema de arquivos e rede para execução mais segura e autônoma
/security-reviewCompletar uma revisão de segurança de alterações pendentes no branch atual
/statsVisualizar uso diário, histórico de sessão, sequências e preferências de modelo
/statusAbrir a interface de Configurações (aba Status) mostrando versão, modelo, conta e conectividade
/statuslineConfigurar UI de linha de status do Claude Code
/teleportRetomar uma sessão remota do claude.ai por ID de sessão, ou abrir um seletor (assinantes claude.ai)
/terminal-setupInstalar vinculação de tecla Shift+Enter para novas linhas (VS Code, Alacritty, Zed, Warp)
/themeAlterar o tema de cor
/todosListar itens TODO atuais
/usageApenas para planos de assinatura: mostrar limites de uso do plano e status de limite de taxa
/vimEntrar no modo vim para alternar entre modos de inserção e comando

​
Comandos de barra personalizados

Comandos de barra personalizados permitem que você defina prompts frequentemente usados como arquivos Markdown que o Claude Code pode executar. Os comandos são organizados por escopo (específico do projeto ou pessoal) e suportam namespacing através de estruturas de diretório.
O preenchimento automático de comando de barra funciona em qualquer lugar da sua entrada, não apenas no início. Digite / em qualquer posição para ver os comandos disponíveis.

​
Sintaxe

/<command-name> [arguments]

​
Parâmetros

ParâmetroDescrição
<command-name>Nome derivado do nome do arquivo Markdown (sem extensão .md)
[arguments]Argumentos opcionais passados para o comando

​
Tipos de comando

​
Comandos de projeto

Comandos armazenados no seu repositório e compartilhados com sua equipe. Quando listados em /help, esses comandos mostram “(project)” após sua descrição. Localização: .claude/commands/ O exemplo a seguir cria o comando /optimize: 
# Criar um comando de projeto
mkdir -p .claude/commands
echo "Analyze this code for performance issues and suggest optimizations:" > .claude/commands/optimize.md

​
Comandos pessoais

Comandos disponíveis em todos os seus projetos. Quando listados em /help, esses comandos mostram “(user)” após sua descrição. Localização: ~/.claude/commands/ O exemplo a seguir cria o comando /security-review: 
# Criar um comando pessoal
mkdir -p ~/.claude/commands
echo "Review this code for security vulnerabilities:" > ~/.claude/commands/security-review.md

​
Recursos

​
Namespacing

Use subdiretórios para agrupar comandos relacionados. Os subdiretórios aparecem na descrição do comando, mas não afetam o nome do comando. Por exemplo:
  • .claude/commands/frontend/component.md cria /component com descrição “(project:frontend)”
  • ~/.claude/commands/component.md cria /component com descrição “(user)”
Se um comando de projeto e um comando de usuário compartilharem o mesmo nome, o comando de projeto tem precedência e o comando de usuário é silenciosamente ignorado. Por exemplo, se ambos .claude/commands/deploy.md e ~/.claude/commands/deploy.md existirem, /deploy executa a versão do projeto. Comandos em subdiretórios diferentes podem compartilhar nomes, pois o subdiretório aparece na descrição para distingui-los. Por exemplo, .claude/commands/frontend/test.md e .claude/commands/backend/test.md ambos criam /test, mas mostram como “(project:frontend)” e “(project:backend)” respectivamente.

​
Argumentos

Passe valores dinâmicos para comandos usando placeholders de argumento:
Todos os argumentos com $ARGUMENTS
O placeholder $ARGUMENTS captura todos os argumentos passados para o comando: 
# Definição de comando
echo 'Fix issue #$ARGUMENTS following our coding standards' > .claude/commands/fix-issue.md

# Uso
> /fix-issue 123 high-priority
# $ARGUMENTS se torna: "123 high-priority"
Argumentos individuais com $1, $2, etc.
Acesse argumentos específicos individualmente usando parâmetros posicionais (semelhante a scripts de shell): 
# Definição de comando  
echo 'Review PR #$1 with priority $2 and assign to $3' > .claude/commands/review-pr.md

# Uso
> /review-pr 456 high alice
# $1 se torna "456", $2 se torna "high", $3 se torna "alice"
Use argumentos posicionais quando você precisar:
  • Acessar argumentos individualmente em diferentes partes do seu comando
  • Fornecer padrões para argumentos ausentes
  • Construir comandos mais estruturados com funções de parâmetro específicas

​
Execução de comando bash

Execute comandos bash antes do comando de barra ser executado usando o prefixo !. A saída é incluída no contexto do comando. Você deve incluir allowed-tools com a ferramenta Bash, mas pode escolher os comandos bash específicos a permitir. Por exemplo: 
---
allowed-tools: Bash(git add:*), Bash(git status:*), Bash(git commit:*)
description: Create a git commit
---

## Context

- Current git status: !`git status`
- Current git diff (staged and unstaged changes): !`git diff HEAD`
- Current branch: !`git branch --show-current`
- Recent commits: !`git log --oneline -10`

## Your task

Based on the above changes, create a single git commit.

​
Referências de arquivo

Inclua conteúdos de arquivo em comandos usando o prefixo @ para referenciar arquivos. Por exemplo: 
# Referenciar um arquivo específico

Review the implementation in @src/utils/helpers.js

# Referenciar múltiplos arquivos

Compare @src/old-version.js with @src/new-version.js

​
Modo de pensamento

Comandos de barra podem disparar pensamento estendido incluindo palavras-chave de pensamento estendido.

​
Frontmatter

Arquivos de comando suportam frontmatter, útil para especificar metadados sobre o comando:
FrontmatterPropósitoPadrão
allowed-toolsLista de ferramentas que o comando pode usarHerda da conversa
argument-hintOs argumentos esperados para o comando de barra. Exemplo: argument-hint: add [tagId] | remove [tagId] | list. Esta dica é mostrada ao usuário ao preencher automaticamente o comando de barra.Nenhum
descriptionBreve descrição do comandoUsa a primeira linha do prompt
modelString de modelo específica (veja Visão geral de modelos)Herda da conversa
disable-model-invocationSe deve impedir que a ferramenta Skill chame este comandofalse
hooksDefinir hooks com escopo para a execução deste comando. Veja Definir hooks para comandos.Nenhum
Por exemplo: 
---
allowed-tools: Bash(git add:*), Bash(git status:*), Bash(git commit:*)
argument-hint: [message]
description: Create a git commit
model: claude-3-5-haiku-20241022
---

Create a git commit with message: $ARGUMENTS
Exemplo usando argumentos posicionais: 
---
argument-hint: [pr-number] [priority] [assignee]
description: Review pull request
---

Review PR #$1 with priority $2 and assign to $3.
Focus on security, performance, and code style.

​
Definir hooks para comandos

Comandos de barra podem definir hooks que são executados durante a execução do comando. Use o campo hooks para especificar manipuladores PreToolUse, PostToolUse ou Stop: 
---
description: Deploy to staging with validation
hooks:
  PreToolUse:
    - matcher: "Bash"
      hooks:
        - type: command
          command: "./scripts/validate-deploy.sh"
          once: true
---

Deploy the current branch to staging environment.
A opção once: true executa o hook apenas uma vez por sessão. Após a primeira execução bem-sucedida, o hook é removido. Hooks definidos em um comando têm escopo para a execução desse comando e são automaticamente limpos quando o comando termina. Veja Hooks para o formato completo de configuração de hooks.

​
Comandos de plugin

Plugins podem fornecer comandos de barra personalizados que se integram perfeitamente com o Claude Code. Comandos de plugin funcionam exatamente como comandos definidos pelo usuário, mas são distribuídos através de marketplaces de plugin.

​
Como funcionam os comandos de plugin

Comandos de plugin são:
  • Com namespace: Comandos podem usar o formato /plugin-name:command-name para evitar conflitos (prefixo de plugin é opcional a menos que haja colisões de nome)
  • Automaticamente disponíveis: Uma vez que um plugin é instalado e habilitado, seus comandos aparecem em /help
  • Totalmente integrados: Suportam todos os recursos de comando (argumentos, frontmatter, execução bash, referências de arquivo)

​
Estrutura de comando de plugin

Localização: diretório commands/ na raiz do plugin Formato de arquivo: Arquivos Markdown com frontmatter Estrutura básica de comando: 
---
description: Brief description of what the command does
---

# Command Name

Detailed instructions for Claude on how to execute this command.
Include specific guidance on parameters, expected outcomes, and any special considerations.
Recursos avançados de comando:
  • Argumentos: Use placeholders como {arg1} em descrições de comando
  • Subdiretórios: Organize comandos em subdiretórios para namespacing
  • Integração Bash: Comandos podem executar scripts de shell e programas
  • Referências de arquivo: Comandos podem referenciar e modificar arquivos de projeto

​
Padrões de invocação

Comando direto (quando não há conflitos)
/command-name
Com prefixo de plugin (quando necessário para desambiguação)
/plugin-name:command-name
Com argumentos (se o comando os suportar)
/command-name arg1 arg2

​
Comandos de barra MCP

Servidores MCP podem expor prompts como comandos de barra que se tornam disponíveis no Claude Code. Esses comandos são descobertos dinamicamente de servidores MCP conectados.

​
Formato de comando

Comandos MCP seguem o padrão: 
/mcp__<server-name>__<prompt-name> [arguments]

​
Recursos

​
Descoberta dinâmica

Comandos MCP estão automaticamente disponíveis quando:
  • Um servidor MCP está conectado e ativo
  • O servidor expõe prompts através do protocolo MCP
  • Os prompts são recuperados com sucesso durante a conexão

​
Argumentos

Prompts MCP podem aceitar argumentos definidos pelo servidor: 
# Sem argumentos
> /mcp__github__list_prs

# Com argumentos
> /mcp__github__pr_review 456
> /mcp__jira__create_issue "Bug title" high

​
Convenções de nomenclatura

Nomes de servidor e prompt são normalizados:
  • Espaços e caracteres especiais se tornam underscores
  • Nomes são minúsculos para consistência

​
Gerenciando conexões MCP

Use o comando /mcp para:
  • Visualizar todos os servidores MCP configurados
  • Verificar status de conexão
  • Autenticar com servidores habilitados para OAuth
  • Limpar tokens de autenticação
  • Visualizar ferramentas e prompts disponíveis de cada servidor

​
Permissões MCP e wildcards

Para aprovar todas as ferramentas de um servidor MCP, use o nome do servidor sozinho ou sintaxe de wildcard:
  • mcp__github (aprova todas as ferramentas GitHub)
  • mcp__github__* (sintaxe de wildcard, também aprova todas as ferramentas GitHub)
Para aprovar ferramentas específicas, liste cada uma explicitamente:
  • mcp__github__get_issue
  • mcp__github__list_issues
Veja regras de permissão MCP para mais detalhes.

​
Ferramenta Skill

Em versões anteriores do Claude Code, a invocação de comando de barra era fornecida por uma ferramenta SlashCommand separada. Isso foi mesclado na ferramenta Skill. Se você tiver regras de permissão existentes usando SlashCommand, atualize-as para usar Skill.
A ferramenta Skill permite que Claude invoque programaticamente tanto comandos de barra personalizados quanto Agent Skills durante uma conversa. Isso dá ao Claude a capacidade de usar essas capacidades em seu nome quando apropriado.

​
O que a ferramenta Skill pode invocar

A ferramenta Skill fornece acesso a:
TipoLocalizaçãoRequisitos
Comandos de barra personalizados.claude/commands/ ou ~/.claude/commands/Deve ter frontmatter description
Agent Skills.claude/skills/ ou ~/.claude/skills/Não deve ter disable-model-invocation: true
Comandos integrados como /compact e /init não estão disponíveis através desta ferramenta.

​
Encorajar Claude a usar comandos específicos

Para encorajar Claude a usar a ferramenta Skill, referencie o comando pelo nome, incluindo a barra, em seus prompts ou arquivo CLAUDE.md: 
> Run /write-unit-test when you are about to start writing tests.
Esta ferramenta coloca os metadados de cada comando disponível no contexto até o limite de orçamento de caracteres. Use /context para monitorar o uso de tokens. Para ver quais comandos e Skills estão disponíveis para a ferramenta Skill, execute claude --debug e dispare uma consulta.

​
Desabilitar a ferramenta Skill

Para impedir que Claude invoque programaticamente qualquer comando ou Skill: 
/permissions
# Add to deny rules: Skill
Isso remove a ferramenta Skill e todas as descrições de comando/Skill do contexto.

​
Desabilitar comandos ou Skills específicos

Para impedir que um comando ou Skill específico seja invocado programaticamente via ferramenta Skill, adicione disable-model-invocation: true ao seu frontmatter. Isso também remove os metadados do item do contexto.
O campo user-invocable em Skills apenas controla a visibilidade do menu, não o acesso à ferramenta Skill. Use disable-model-invocation: true para bloquear a invocação programática. Veja Controlar visibilidade de Skill para detalhes.

​
Regras de permissão Skill

As regras de permissão suportam:
  • Correspondência exata: Skill(/commit) (permite apenas /commit sem argumentos)
  • Correspondência de prefixo: Skill(/review-pr:*) (permite /review-pr com qualquer argumento)

​
Limite de orçamento de caracteres

A ferramenta Skill inclui um orçamento de caracteres para limitar o uso de contexto. Isso previne overflow de tokens quando muitos comandos e Skills estão disponíveis. O orçamento inclui o nome, argumentos e descrição de cada item.
  • Limite padrão: 15.000 caracteres
  • Limite personalizado: Definir via variável de ambiente SLASH_COMMAND_TOOL_CHAR_BUDGET. O nome é retido para compatibilidade com versões anteriores.
Quando o orçamento é excedido, Claude vê apenas um subconjunto de itens disponíveis. Em /context, um aviso mostra quantos estão incluídos.

​
Skills vs comandos de barra

Comandos de barra e Agent Skills servem propósitos diferentes no Claude Code:

​
Use comandos de barra para

Prompts rápidos e frequentemente usados:
  • Snippets de prompt simples que você usa frequentemente
  • Lembretes rápidos ou templates
  • Instruções frequentemente usadas que cabem em um arquivo
Exemplos:
  • /review → “Review this code for bugs and suggest improvements”
  • /explain → “Explain this code in simple terms”
  • /optimize → “Analyze this code for performance issues”

​
Use Skills para

Capacidades abrangentes com estrutura:
  • Fluxos de trabalho complexos com múltiplas etapas
  • Capacidades que requerem scripts ou utilitários
  • Conhecimento organizado em múltiplos arquivos
  • Fluxos de trabalho de equipe que você quer padronizar
Exemplos:
  • Skill de processamento de PDF com scripts de preenchimento de formulário e validação
  • Skill de análise de dados com documentos de referência para diferentes tipos de dados
  • Skill de documentação com guias de estilo e templates

​
Diferenças principais

AspectoComandos de BarraAgent Skills
ComplexidadePrompts simplesCapacidades complexas
EstruturaArquivo .md únicoDiretório com SKILL.md + recursos
DescobertaInvocação explícita (/command)Automática (baseada em contexto)
ArquivosUm arquivo apenasMúltiplos arquivos, scripts, templates
EscopoProjeto ou pessoalProjeto ou pessoal
CompartilhamentoVia gitVia git

​
Comparação de exemplo

Como um comando de barra: 
# .claude/commands/review.md
Review this code for:
- Security vulnerabilities
- Performance issues
- Code style violations
Uso: /review (invocação manual) Como um Skill: 
.claude/skills/code-review/
├── SKILL.md (overview and workflows)
├── SECURITY.md (security checklist)
├── PERFORMANCE.md (performance patterns)
├── STYLE.md (style guide reference)
└── scripts/
    └── run-linters.sh
Uso: “Can you review this code?” (descoberta automática) O Skill fornece contexto mais rico, scripts de validação e material de referência organizado.

​
Quando usar cada um

Use comandos de barra:
  • Você invoca o mesmo prompt repetidamente
  • O prompt cabe em um arquivo único
  • Você quer controle explícito sobre quando ele é executado
Use Skills:
  • Claude deve descobrir a capacidade automaticamente
  • Múltiplos arquivos ou scripts são necessários
  • Fluxos de trabalho complexos com etapas de validação
  • Equipe precisa de orientação detalhada e padronizada
Ambos comandos de barra e Skills podem coexistir. Use a abordagem que se adequa às suas necessidades. Saiba mais sobre Agent Skills.

​
Veja também