Você já viu os prints: “5 códigos secretos do Claude que poucos conhecem”. Vamos ser honestos primeiro e práticos depois. Aqui você tem os dois lados — a real sobre os códigos virais (em 30 segundos) e os comandos nativos avançados do Claude Code, a CLI da Anthropic, que transformam o chat num agente de verdade. Este texto é pra quem já usa o Claude Code e quer sair do básico. Todos com exemplo pra colar.

Os “códigos secretos” que viralizaram (a real, em 30s)

Antes de tudo: esses códigos não são comandos nativos — são convenções de prompt, palavras que você digita pra dar contexto. Não existe “modo oculto”. Funcionam como atalho mental, e no Claude Code você transforma cada um num comando real (próxima seção). O resumo honesto:

Code
L99       → "responda em nível de especialista, sem simplificar"
/godmode  → resposta mais completa e direta (NÃO é jailbreak)
/ghost    → tom mais natural (NÃO dribla detector de IA de forma confiável)
OODA      → aplica o loop Observar-Orientar-Decidir-Agir e dá um plano
ARTIFACTS → pede um artefato pronto (é recurso do Claude.ai web, não da CLI)
…e variantes: /critique, /roadmap, /devil, /brief, /eli5

Úteis como mnemônico, sim. Secretos, não. O valor de verdade começa agora:

Publicidade

Os comandos NATIVOS do Claude Code que poucos usam

É aqui que a CLI deixa de ser chat caro e vira infraestrutura. Todos oficiais, documentados, com exemplo.

1. Slash commands customizados: transforme os “códigos” em comando real

Um comando é um arquivo .claude/commands/nome.md que vira /nome, recebe $ARGUMENTS, roda bash com ! e injeta arquivos com @. Aqui os “/critique” e “/roadmap” do Instagram viram comandos REAIS, versionados no git e herdados pelo time.

Code
# arquivo: .claude/commands/critique.md
Revise as mudanças e aponte falhas de segurança e edge cases.

Diff atual: !`git diff --staged`
Contexto extra: @src/$ARGUMENTS

# no terminal (o "auth" preenche o $ARGUMENTS):
/critique auth

2. Skills: comandos que carregam contexto sob demanda

Uma skill (.claude/skills/nome/SKILL.md) é um comando cujo corpo só entra no contexto quando é usado — reference pesada custa quase zero até você precisar. O Claude decide carregá-la sozinho pela description, e o frontmatter deixa fixar um model, um nível de effort ou rodar num subagente.

Code
---
name: migrar-teste
description: Converte testes de Jest para Vitest quando o usuario pede
model: sonnet
---
Troque os imports do Jest por Vitest e ajuste os mocks.

3. Output styles: o “/godmode” honesto e permanente

A versão real do “/godmode”: um output style (.claude/output-styles/*.md) altera o system prompt — role, tom, formato — em toda resposta, ativado por /config. Com keep-coding-instructions: true muda só como o Claude fala, sem perder o comportamento de código.

Code
---
name: Direto ao ponto
description: Sem rodeios, so o essencial
keep-coding-instructions: true
---
Responda sem introducoes. Codigo primeiro, no maximo 2 linhas de contexto.

4. Hooks que BLOQUEIAM (não pedem)

CLAUDE.md pede; hook garante. Um hook PreToolUse — registrado no settings.json com um matcher — roda um script antes da ferramenta; sair com exit 2 barra a ação (impede editar um .env ou rodar um rm). O script sozinho não faz nada: precisa do registro.

Code
// .claude/settings.json — sem isto, o hook nao dispara
{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{ "type": "command", "command": ".claude/hooks/block-rm.sh" }]
    }]
  }
}
Code
# .claude/hooks/block-rm.sh
cmd=$(jq -r ".tool_input.command" < /dev/stdin)
if [[ "$cmd" == rm* ]]; then
  echo "Bloqueado: rm nao permitido" >&2
  exit 2   # exit 2 = barra a ferramenta
fi
exit 0

Atenção: isso é defense-in-depth, não barreira infalível. Um matcher de string como rm* não pega sudo rm, rm depois de &&, find . -delete nem /bin/rm. Trave o essencial e não confie só nisso.

5. Permissions as code: trave o que o agente pode tocar

No .claude/settings.json, permissions.allow e permissions.deny definem o que o Claude pode fazer — e deny sempre vence. São regras sintáticas (prefix match), então valem como cerca, não cofre: Bash(rm *) não cobre sudo rm. E nunca rode com --dangerously-skip-permissions: ela anula allow, deny e hooks de uma vez.

JSON
{
  "permissions": {
    "allow": ["Bash(npm run test *)", "Edit(./src/**)"],
    "deny":  ["Bash(rm *)", "Bash(curl *)", "Read(./.env*)"]
  }
}

Publicidade

6. Headless orquestrado: Claude como peça de pipeline

O modo -p vira utilitário Unix: recebe o prompt, responde e sai. Com --output-format json a saída é um objeto único que você joga no jq; --append-system-prompt ajusta só naquela chamada. (Precisa de streaming? --output-format stream-json emite NDJSON, uma linha por evento — aí o parsing é linha a linha.)

Bash
git diff --staged | claude -p "revise e responda PASS ou FAIL com o motivo" \
  --output-format json | jq -r &#x27;.result&#x27;

Um aviso pra CI: LLM não é determinístico — use a saída como sinal/revisão, não como gate rígido que pode falhar o build sem motivo.

7. Subagents com modelo e memória próprios

Cada subagente em .claude/agents/*.md tem contexto isolado, pode fixar um model: e manter auto-memória — vários em paralelo. Um Opus revisa arquitetura, um Haiku varre lint. Detalhamos em agentes e subagentes. Custo: Opus em paralelo queima token rápido — reserve-o pro que exige raciocínio e mande o repetitivo pro Haiku/Sonnet.

Code
---
name: revisor-seguranca
description: Audita diffs em busca de falhas
model: opus
---
Voce e um pentester. Liste vulnerabilidades do diff por severidade.

8. MCP versionado no repo + resources

Um .mcp.json no repositório dá ao time inteiro as mesmas ferramentas externas (Postgres, browser, Notion) via MCP. Registre com claude mcp add (o server precisa da credencial/connection string), gerencie com /mcp, injete dados com @servidor:resource. Como MCP roda código de terceiros (npx), trate servidor e credencial como superfície de ataque.

Code
claude mcp add postgres -- \
  npx -y @modelcontextprotocol/server-postgres postgresql://user:senha@localhost:5432/meubanco

> compare o schema atual com @postgres:tables

9. Checkpoints e /rewind: rede de segurança

O Claude Code cria checkpoints; /rewind (ou Esc duas vezes) volta código e conversa a um ponto anterior. Ótimo pra deixar o agente editar agressivo — mas atenção: ele restaura arquivos, não desfaz efeito colateral de bash já executado (uma migration ou git push continuam feitos). Não substitui git.

Code
/rewind        # escolhe um checkpoint (codigo + conversa)
# atalho: Esc Esc

10. .claude/rules/ com paths: regra que carrega só onde importa

Em vez de inflar o CLAUDE.md, quebre em .claude/rules/*.md com frontmatter paths: — a regra só entra no contexto quando o Claude mexe num arquivo que casa com o glob. É o disparo determinístico por caminho (diferente da skill, que o modelo decide carregar). Monorepo grande fica enxuto.

Code
---
paths:
  - "src/api/**/*.ts"
---
# Regras de API
- Todo endpoint valida input e usa o formato de erro padrao.

Juntando tudo: o esqueleto do seu super agente

Os comandos sozinhos são peças; o “super agente” é o .claude/ do projeto que combina elas — versionado no git, herdado por quem clonar o repo:

Code
.claude/
├── CLAUDE.md            # regras e stack do projeto
├── settings.json        # permissions.deny + registro dos hooks
├── commands/
│   └── ship.md          # /ship: builda, testa e resume
├── agents/
│   └── revisor.md        # subagente de review (model: opus)
├── hooks/
│   └── block-rm.sh       # PreToolUse: barra comando destrutivo
└── rules/
    └── api.md            # regra que so carrega em src/api/**

Com esse esqueleto, cada sessão já nasce com contexto, guardrails e automação. É a diferença entre pedir e delegar — o tal do agente.

Do chat ao agente: o Claude Code que poucos operam

Os “códigos secretos” são o gancho; a vantagem real é tratar o Claude Code como infraestrutura — comandos e skills que você define, hooks que garantem, permissões que travam, subagentes que escalam, headless que automatiza. Escolha uma peça e monte hoje. Pra comparar ferramentas, veja o Cursor e a alternativa OpenCode; a referência está na doc de settings e skills.

“/godmode”, “/ghost”, “L99” e “OODA” são comandos reais do Claude Code?
Não. São convenções de prompt que viralizaram — palavras que você digita pra dar contexto, não comandos nativos com “modo secreto”. Funcionam como atalho mental, e no Claude Code você recria cada um como um comando real em .claude/commands/ ou como um output style.
Como criar um comando customizado no Claude Code?
Crie .claude/commands/nome.md (ou uma skill em .claude/skills/nome/SKILL.md). O nome do arquivo vira /nome, $ARGUMENTS recebe parâmetros, e o comando pode rodar bash com ! e injetar arquivos com @.
Como fazer um hook realmente bloquear uma ação?
Registre um hook PreToolUse no settings.json (com um matcher) apontando pra um script; se o script sair com exit 2, a ação é barrada. Lembre que matchers de string são contornáveis — use como defense-in-depth, junto com permissions.deny.
Dá pra rodar o Claude Code em um script ou CI?
Sim, no modo headless: claude -p "prompt" --output-format json. Ele responde e sai, dá pra encadear por pipe com jq. Como a saída não é determinística, use como sinal/revisão, não como gate rígido de build.
Qual a diferença entre skill e regra (rules) no Claude Code?
A skill (SKILL.md) o modelo decide carregar pela description quando é relevante; a regra (.claude/rules/ com paths:) carrega de forma determinística sempre que você toca um arquivo que casa com o glob.

Informações verificadas na documentação oficial do Claude Code (slash commands, modo headless, hooks e memória) em julho de 2026. Recursos e atalhos podem variar conforme a versão da CLI e o terminal usado.