INEMA

Aqui está a explicação simples de cada comando citado no vídeo:

Comandos do Claude Code⌗

claude → abre uma sessão do Claude Code no terminal.
cloud → comando principal (CLI) para rodar todas as funções do Claude Code.
/init → cria e configura os arquivos básicos do projeto, incluindo o claw.md.
/clear → limpa a conversa atual e inicia o contexto do zero.
/agents → guia você para criar um sub-agente (um arquivo de agente).
dangerously skip permissions → executa ações sem pedir permissão (só seguro em ambiente isolado).
permissions → menu interno para configurar lista de comandos permitidos ou bloqueados.

Slash commands (exemplos)⌗

/primer → “aquece” o contexto: faz Claude mapear e entender o código e arquivos antes de trabalhar.
/generate PRP → gera o Product Requirement Prompt (documento longo com instruções detalhadas).
/execute PRP → executa o PRP para gerar código ou implementar a feature.
/fixGithubIssue → lê um número de issue no GitHub, corrige o problema, testa e abre um PR automaticamente.
/prep-parallel → prepara múltiplas instâncias/branches para rodar agentes em paralelo.
/execute-parallel → executa as várias instâncias do Claude Code em paralelo com base num plano.
/analyze performance \$arguments → comando parametrizado que recebe argumentos para análise (ex.: nome de função).

MCP (gerenciamento)⌗

claude mcp list → lista os MCP servers conectados (como Serena, Archon).
cloud mcp remove serena → remove um MCP server (no caso, Serena).

Comandos de terminal usados pelo Claude⌗

tree → mostra a estrutura de pastas e arquivos do projeto.
ls → lista arquivos do diretório atual.
cd → muda de pasta no terminal.
mkdir → cria uma nova pasta.
grep → procura por palavras/frases em arquivos.
python → executa código Python.
rm → apaga arquivos (recomendado sempre pedir confirmação manual).

Git e Worktrees⌗

git worktree add → cria uma cópia isolada do repositório em outro diretório.
git worktree list → mostra todas as cópias (worktrees) existentes.
git checkout main → volta para a branch principal do Git.
git merge → junta alterações de uma branch no código principal.

GitHub CLI⌗

gh auth login → autentica no GitHub pelo terminal.
gh repo list → lista seus repositórios do GitHub.
gh issue view → mostra detalhes de uma issue do GitHub.

Dev Containers / VS Code⌗

Reopen in Container → comando do VS Code para abrir o projeto em um Dev Container (ambiente isolado com Docker).

Aqui está a lista dos arquivos que o vídeo citou, organizados por função:

Arquivos de configuração⌗

claw.md → arquivo principal de regras globais (system prompt do projeto).
settings.local.json → define permissões, hooks e configurações locais dentro da pasta .claw/.

Arquivos de comandos (slash commands)⌗

primer.md → instruções para preparar o contexto (ler código, claw.md, readme).
fixGithubIssue.md → fluxo para pegar issue no GitHub, corrigir e abrir PR.
prep-parallel.md → prepara execução paralela criando branches/worktrees.
execute-parallel.md → roda as instâncias paralelas seguindo um plano.
plan.md → documento onde você descreve a feature que quer implementar.

Arquivos do framework PRP⌗

initial.md → descrição inicial da feature ou agente a ser criado.
PRP.md (gerado) → Product Requirement Prompt, com todo o contexto detalhado.
results.md (gerado) → resumo dos resultados das execuções paralelas.

Arquivos de agentes (sub-agents)⌗

validation-gates.md → sub-agente especializado em rodar testes e validar código.
outros agentes em .claw/agents/ → cada um em seu próprio .md com sistema e descrição.

Arquivos de hooks⌗

hooks.json → define quais ganchos (ações automáticas) serão rodados em certos momentos.
log-tool-usage.sh → script bash que registra logs cada vez que o Claude edita algo.

Dev Containers⌗

Dockerfile / devcontainer.json (no template do Anthropic) → definem o container isolado para rodar Claude Code em YOLO mode.

Arquivos comuns do repositório⌗

README.md → guia/documentação do projeto, usado como referência pelo Claude.

github.com/oraios/serena ↗

docs.anthropic.com ↗

anthropic.com ↗

github.com ↗

Full Guide to Using Claude Code in GitHub:

https://github.com/coleam00/context-e...

Previous video where I dive deep into context engineering: • Context Engineering 101 - The Simple Strat...

Anthropic's Claude Code best practices:

https://www.anthropic.com/engineering...

Serena MCP server: https://github.com/oraios/serena

Anthropic's guide to devcontainers: https://docs.anthropic.com/en/docs/cl...

tiva; preferir soluções simples.” Resposta esperada: O assistente cita a regra nas propostas e evita superengenharia.

Permissões Exemplo: Permitir git, ls, grep; negar rm. Resposta esperada: Edita/commita sem pedir confirmação; bloqueia remoções perigosas.

Slash commands Exemplo: /p primer Resposta esperada: Gera visão da arquitetura e áreas críticas em bullets em poucos segundos.

MCP (Serena/Archon) Exemplo: “Use Serena para entender onde ajustar a camada de serviços.” Resposta esperada: Chamadas MCP automáticas, localização precisa de arquivos a editar.

PRP Exemplo: /generate-prp ./.prp/checkout-novo.md e depois /execute-prp ./.prp/PRP-gerado.md Resposta esperada: Código + testes + checklist atendidos conforme critérios do PRP.

Sub-agents Exemplo: “Finalize com validation gate.” Resposta esperada: Sub-agent cria/roda testes, corrige falhas e só então devolve controle.

Hooks Exemplo: afterToolUse → script de log. Resposta esperada: Arquivo .claw/logs/tools.log populado a cada uso de ferramenta.

GitHub CLI Exemplo: /fix-github-issue 42 Resposta esperada: Busca issue, corrige, testa, cria branch e PR associados.

YOLO mode Exemplo: Rodar em container com skip permissions. Resposta esperada: Execução 100% autônoma em ambiente isolado e seguro.

Execução paralela Exemplo: /prep-parallel BuscaV2 3; /execute-parallel BuscaV2 ./plan.md 3 Resposta esperada: Três variações independentes e um relatório comparando as soluções.

Hacks úteis

No claw.md, proíba “production-ready com backward compat desnecessária” para conter overengineering.
Use palavras-chave do modelo quando quiser mais “raciocínio”: ultrathink, important, proactively.
Sempre valide PRP e RESULT.md antes de integrar; crie checklists curtos e objetivos.
Em projetos grandes, priorize Serena para navegação/edição semântica.
Para times, mantenha regras e docs fora do claw.md e só referencie, evitando drift.

p/feature-inicial.md /clear /execute-prp ./.prp/PRP-gerado.md

7. Sub-agents especializados

1) Crie:

.claw/agents/

```2. Exemplo .claw/agents/validation-gates.md:

## name: validation-gates
## description: Ao final de uma entrega, escrever testes, rodá-los, depurar e só devolver controle com todos passando. Use quando PRP mencionar "validation gate".
model: sonnet
tools:
  - shell
  - fs
  - git
policy:
  - Priorize testes de unidade e integração rápidos.
  - Gere relatórios JUnit ou markdown em ./reports/validation.md

Em pedidos normais, cite “validation gate” e o agente será chamado automaticamente quando fizer sentido.

8) Hooks para automações no fluxo

Crie a pasta:

.c```law/hooks/

```2. Exemplo de script .claw/hooks/log_tool_usage.sh:

!/```usr/bin/env bash

mkdir -p .claw/logs echo "Claude executou uma ferramenta em $(date '+%Y-%m-%d %H:%M:%S')" >> .claw/logs/tools.log

3```. Torne executável:

chm```od +x .claw/hooks/log_tool_usage.sh

4```. Em settings.local.json, registre o hook:

{ ```"hooks": [ { "event": "afterToolUse", "command": ".claw/hooks/log_tool_usage.sh" } ] }

9.``` Integração com GitHub pela CLI

1) Instale e autentique:

gh a```uth login gh repo list

2.``` Crie o comando .claw/commands/fix-github-issue.md:

nam```e: fix-github-issue⌗

description: Corrige uma issue do GitHub e abre um PR automaticamente.⌗

steps: - run: gh issue view $arguments --json number,title,body - analyze: Entenda o problema e proponha plano de correção e testes. - implement: Aplique mudanças; cite commits relacionados à issue. - test: Rode testes; gere ./reports/issue-$arguments.md - run: git checkout -b fix/issue-$arguments - run: git add -A && git commit -m "fix: issue #$arguments" - run: git push -u origin fix/issue-$arguments - run: gh pr create --fill --head fix/issue-$arguments - reply: PR criado para resolver a issue #$arguments.

```Execute:

/fix-```github-issue 123

10.``` YOLO mode com Dev Containers (ambiente seguro e permissivo)

1) Adicione um dev container (VS Code: Reopen in Container) com Dockerfile adequado ao Claude Code. 2) Dentro do container, rode:

claude``` --dangerously-skip-permissions

G```aranta allowlists de rede e volumes isolados. Seu host fica protegido enquanto o assistente opera sem prompts de permissão.

11) Execução paralela com git worktrees

Crie comandos auxiliares:

.claw/commands/prep-parallel.md

name:``` prep-parallel⌗

description: Prepara N worktrees para execução paralela de uma mesma feature.⌗

steps: - plan: Crie branches feature/$1-{1..$2} e worktrees em ./trees/$1-{i}. - loop: count: $2 do: - run: git branch feature/$1-{i} || true - run: git worktree add ./trees/$1-{i} feature/$1-{i} - run: git worktree list - reply: Worktrees criadas em ./trees para $2 variações da feature $1.

.cl```aw/commands/execute-parallel.md

name:``` execute-parallel⌗

description: Executa a mesma feature em N worktrees e gera um relatório comparativo.⌗

steps: - read: $2 # caminho de um plan.md com escopo claro - loop: count: $3 do: - run: cd ./trees/$1-{i} - implement: Aplique o plano com autonomia total; crie ./RESULT.md sumarizando decisões. - aggregate: Leia todos ./trees/$1-*/RESULT.md e gere ./PARALLEL-REPORT.md com comparação. - reply: Relatório comparativo gerado em ./PARALLEL-REPORT.md.

Us```e:

/prep-p```arallel CLI-UI 3 /execute-parallel CLI-UI ./plan.md 3

Te```ste cada variação e faça merge da melhor branch no main.

12) Rotina diária sugerida

Inicie com /p primer.
Valide tarefas no PRP; gere/execute PRP.
Antes de finalizar, invoque validation-gates.
Para bugs, /fix-github-issue .
Para features arriscadas, use YOLO mode em dev container.
Para velocidade, use execução paralela e escolha a melhor implementação.

Tópicos com exemplos e respostas rápidas⌗

Global rules (claw.md) Exemplo: Defina “Não reaproveitar código legado sem justifica

./.pr

Passo a passo prático para aplicar o guia de Claude Code⌗

Abaixo está um roteiro direto, do zero ao avançado, para você configurar e usar Claude Code com regras globais, permissões, slash commands, MCP, PRP, sub-agents, hooks, GitHub, dev container (YOLO mode) e execução paralela. Onde houver caminhos/nomes, ajuste aos seus diretórios.

Instalação e primeiro run

1) Instale e autentique o CLI do Claude Code (no vídeo ele usa o comando claude dentro do terminal; se estiver no Windows, use WSL/Ubuntu). 2) Abra seu projeto no IDE, abra o terminal integrado e rode:

claude

Teste com um pedido simples: “Liste os arquivos e descreva o objetivo do repositório”.

2) Regras globais com claw.md

Na raiz do repo, crie o arquivo:

c```law.md

2. Coloque diretrizes de arquitetura, padrões, limites, “do/do not”, palavras-chave úteis (ex.: important, proactively, ultrathink), preferências de testes e estilo de código.
3. Opcional: crie claw\.md específicos em subpastas (frontend/, backend/) para contexto local.
4. Mantenha textos normativos extensos fora do claw\.md e apenas referencie-os (facilita reuso entre times e outras AIs).

3) Permissões no settings.local.json

1. Crie a pasta oculta de configurações:

.c```law/

```2. Crie o arquivo:

.cl```aw/settings.local.json

3```. Exemplo seguro (ajuste a seu stack; nunca inclua rm):

{
  ```"permissions": {
    "allow": [
      "ls", "cat", "grep", "find", "tree",
      "git", "git status", "git diff", "git add", "git commit", "git push",
      "python", "uv", "pip", "node", "npm", "pnpm"
    ],
    "deny": ["rm", "sudo"]
  }
}

4.``` Slash commands reutilizáveis

1) Crie a pasta:

.cla```w/commands/

2.``` Exemplo de comando para “aquecer” o contexto do repo, em .claw/commands/primer.md:

## nam```e: primer
## description: Lê estrutura e artefatos-chave do projeto para sintonizar o contexto.
steps:
  - run: tree -L 3
  - read: ./claw.md
  - read: ./README.md
  - read: ./package.json
  - read: ./pyproject.toml
  - reply: Resuma a arquitetura, as dependências e áreas suspeitas de débito técnico em 10 bullets.

3. ```Recarregue a sessão do Claude Code e execute:

/p pr```imer

4. ```Parâmetros: crie comandos com \$arguments para dinamizar consultas, por exemplo analyze-performance.md aceitando um alvo.

5) Conectar MCPs (Serena, Archon, etc.)

1. Instale o MCP desejado (ex.: Serena) e adicione a conexão via CLI do Claude Code conforme sua instalação.
2. No settings.local.json, permita o uso automático das ferramentas MCP (ajuste o nome do servidor MCP que você adicionou):

{
  "p```ermissions": {
    "allow": ["ls", "cat", "git"],
    "deny": ["rm"]
  },
  "mcp_allow": ["serena", "archon"]
}

3. O```pcional: edite o primer.md para instruir o uso de Serena como primeira opção de busca/edição semântica.

6) Framework PRP (Product Requirement Prompt)

1. Estruture uma pasta para PRP:

.prp/

C```rie o documento de requisitos inicial, por ex. .prp/feature-inicial.md, contendo:

Objetivo/escopo claro
Exemplos de referência
Documentação a ler
Restrições técnicas, checklist e critérios de aceite 3. Crie os comandos:
.claw/commands/generate-prp.md
.claw/commands/execute-prp.md 4. Exemplo simples generate-prp.md:

name:``` generate-prp⌗

description: Gera o PRP consolidado a partir do inicial.⌗

steps: - read: $arguments # caminho do inicial.md - research: Use fontes citadas no arquivo e exemplos embutidos. - write: .prp/PRP-gerado.md - reply: PRP gerado em .prp/PRP-gerado.md; valide antes da execução.

Ex```emplo execute-prp.md:

name:``` execute-prp⌗

description: Executa o PRP para gerar/alterar código e testes.⌗

steps: - read: $arguments # caminho do PRP-gerado.md - plan: Liste tarefas com estimativa e riscos. - implement: Siga as tarefas, escreva código incremental com testes. - validate: Rode testes e critérios de aceite; itere até passar. - reply: Resumo das mudanças, caminhos dos arquivos e próximo passo sugerido.

Ro```de:

/generate-prp

Dublado

youtube.com/watch ↗

Guia completo sobre como usar o Claude Code, explorando do básico até estratégias avançadas para maximizar seu potencial como assistente de programação. O criador explica não só recursos internos, mas também integrações, automações e boas práticas para acelerar o desenvolvimento.

Resumo dos principais pontos abordados:

Global Rules (claw.md) Definir um “sistema de regras” para guiar o comportamento do Claude Code. Pode ser criado pelo comando /init ou manualmente, usando templates diferentes para cada tipo de projeto. É possível ter múltiplos arquivos claw.md em pastas específicas e referenciar documentos externos para manter consistência.
Gerenciamento de Permissões Configurar o settings.local.json para permitir que o Claude execute certos comandos sem pedir autorização, aumentando a autonomia. Recomenda-se evitar dar permissão para comandos perigosos como rm.
Slash Commands Personalizados Criar fluxos de trabalho reutilizáveis e parametrizáveis com comandos no formato /comando, armazenados na pasta commands. Facilitam padronizar tarefas e compartilhar entre equipes.
Servidores MCP Conectar o Claude a ferramentas externas como o MCP Serena (para busca semântica e edição de código) e Archon (gestão de conhecimento e tarefas). Isso melhora a compreensão do código e integra funcionalidades extras.
Framework PRP (Product Requirement Prompt) Processo em 3 etapas para criar prompts longos e completos que dão ao Claude todo o contexto necessário para gerar software pronto para produção. Inclui documentos de requisitos, exemplos e validação.
Sub Agents Agentes especializados que o Claude pode acionar de forma autônoma para tarefas específicas, cada um com seu próprio contexto e permissões. Úteis para validação, atualização de documentação e outras funções especializadas.
Hooks Ações automáticas disparadas em momentos específicos do fluxo de trabalho (antes/depois de usar ferramentas, subagentes, etc.). Configurados em JSON, permitem adicionar comandos ou scripts personalizados.
Integração com GitHub CLI Permite ao Claude criar, gerenciar e resolver issues e PRs diretamente, podendo automatizar todo o ciclo — da leitura do problema à entrega do pull request.
YOLO Mode com Dev Containers Rodar o Claude em um ambiente isolado (container) para dar permissões totais sem risco ao sistema, permitindo execução completamente autônoma.
Execução Paralela de Agentes Usar git worktrees e comandos personalizados para criar várias versões de uma mesma funcionalidade em paralelo, escolhendo depois a melhor implementação.

Master de Claude Code 2025

chatgpt.com ↗

Compilação de um guia completo sobre Claude Code, cobrindo do setup…