Claude Code: Extraindo 100% — Guia Definitivo para Full Stack Developers

Guia completo e avançado do Claude Code: todos os comandos, flags, hooks (29+ eventos), skills, rules path-scoped, MCP, subagentes, SDK, auto-memory, permissões e como integrar no workflow diário de um desenvolvedor full stack.

Este guia assume que você já usa Claude Code no básico. Aqui vamos cobrir tudo que a maioria dos desenvolvedores não sabe que existe — desde os 29+ eventos de hooks até o Agent SDK, passando por flags que mudam o comportamento do agente.

1. Terminal — todos os comandos

Comandos principais

# Sessão interativa
claude                           # Iniciar sessão no diretório atual
claude "implemente auth JWT"     # Iniciar com prompt inicial

# Print mode (não-interativo, ideal para scripts)
claude -p "corrija os erros de lint"
cat error.log | claude -p "root cause?"
git diff main | claude -p "review this diff"

# Continuar sessões
claude -c                        # Continuar a última sessão
claude -r "session-id" "continue" # Resumir sessão específica
claude -c -p "termine a tarefa"  # Continuar via SDK

# Autenticação
claude auth login                # Login (suporta --email, --sso, --console)
claude auth status               # Status como JSON (--text para humano)
claude auth logout               # Logout

# Utilitários
claude update                    # Atualizar para última versão
claude install                   # Reinstalar binário nativo
claude setup-token               # Gerar token OAuth longo para CI
claude mcp                       # Configurar servidores MCP
claude plugin                    # Gerenciar plugins
claude agents                    # Listar subagentes configurados
claude project purge .           # Deletar todo estado local do projeto

Flags que mudam o jogo

# Effort level — controla qualidade vs custo
claude --effort xhigh "implemente o módulo de billing"
# Opções: low, medium, high, xhigh, max

# Budget control (print mode)
claude -p "refatore auth" --max-budget-usd 2.00

# Limite de turnos
claude -p "corrija todos os testes" --max-turns 10

# Modelo específico
claude --model claude-opus-4-7 "tarefa complexa"
claude --model claude-sonnet-4 "tarefa simples"

# Modo bare — pula auto-discovery de hooks/skills/plugins/MCP/CLAUDE.md
claude --bare "prompt rápido"

# Permissões
claude --permission-mode auto       # Auto-aprovar
claude --permission-mode plan       # Apenas planejar
claude --allowedTools "Read,Bash"   # Só permite essas tools

# Worktree isolado
claude --worktree "refatoração do módulo auth"

# Output estruturado
claude -p "liste os endpoints" --output-format json
claude -p "gere schema" --json-schema '{"type":"object"}'

# System prompt customizado
claude --append-system-prompt "Sempre responda em português"
claude --system-prompt-file prompts/custom.md

# Excluir seções dinâmicas do system prompt (melhor cache)
claude --exclude-dynamic-system-prompt-sections

2. Sistema de Memória (CLAUDE.md)

Hierarquia de carregamento

1. Managed policy     → /Library/Application Support/ClaudeCode/CLAUDE.md
   (org-wide, MDM, NUNCA pode ser sobrescrito)

2. Project CLAUDE.md  → ./CLAUDE.md ou ./.claude/CLAUDE.md
   (equipe, versionado no git)

3. User CLAUDE.md     → ~/.claude/CLAUDE.md
   (pessoal, todas as máquinas)

4. Local CLAUDE.md    → ./CLAUDE.local.md
   (gitignored, específico deste clone)

5. Rules              → .claude/rules/*.md
   (path-scoped via YAML frontmatter)

6. Auto memory        → ~/.claude/projects/<projeto>/memory/
   (Claude escreve sozinho, primeiras 200 linhas/25KB)

Import com @

# CLAUDE.md
## Convenções
@docs/conventions.md        ← importado (máx 5 hops de recursão)

## Stack
@backend/README.md
@frontend/README.md

Auto-memory

O Claude Code escreve automaticamente em ~/.claude/projects/<projeto>/memory/ o que aprende durante as sessões. Isso persiste entre sessões.

Para ver: cat ~/.claude/projects/*/memory/MEMORY.md

Para controlar:

// settings.json
{
  "autoMemoryEnabled": true,
  "autoMemoryDirectory": "~/.claude/custom-memory/"
}

Regras path-scoped

---
# .claude/rules/backend.md
paths:
  - "backend/**/*.go"
  - "backend/**/*.mod"
---
## Go 1.23 Conventions
- Gin framework, MongoDB driver v2
- Sempre rodar go fmt antes de commitar
- Table-driven tests
- Error handling: fmt.Errorf("contexto: %w", err)

---
# .claude/rules/tests.md
paths:
  - "**/*.test.ts"
  - "**/*.test.tsx"
  - "tests/**"
---
## Vitest (NUNCA Jest)
- Import { describe, it, expect, vi } from 'vitest'
- Nomes em português: it('retorna 400 sem email')
- vi.fn() para mocks

---
# .claude/rules/global.md
# Sem paths = SEMPRE carregado
---
2-space indent, single quotes, trailing commas.
Nunca commitar .env ou secrets.
Conventional Commits: feat:, fix:, refactor:, chore:

3. Hooks — 29+ eventos de ciclo de vida

Eventos disponíveis

# Sessão
SessionStart, SessionEnd

# Por turno
UserPromptSubmit, Stop, StopFailure

# Por tool call
PreToolUse, PostToolUse, PostToolUseFailure
PostToolBatch

# Permissões
PermissionRequest, PermissionDenied

# Subagentes
SubagentStart, SubagentStop

# Tarefas
TaskCreated, TaskCompleted

# Equipe
TeammateIdle

# Configuração
InstructionsLoaded, ConfigChange, CwdChanged, FileChanged

# Worktree
WorktreeCreate, WorktreeRemove

# Compactação
PreCompact, PostCompact

# Elicitação
Elicitation, ElicitationResult

# Prompt
UserPromptExpansion

5 tipos de hook

// .claude/settings.json
{
  "hooks": {
    "PreToolUse": [
      {
        "type": "command",
        "command": "pnpm lint:fix",
        "description": "Lint before any tool use"
      }
    ],
    "PostToolUse": [
      {
        "type": "command",
        "command": "pnpm format",
        "description": "Format after edits"
      },
      {
        "type": "http",
        "url": "https://monitor.internal/hook",
        "description": "Notify monitoring"
      }
    ],
    "SessionStart": [
      {
        "type": "command",
        "command": "echo 'Session started at $(date)' >> .claude/sessions.log"
      }
    ]
  }
}

Exit codes

0  = sucesso (stdout parseado como JSON)
2  = erro bloqueante (stderr volta pro Claude como feedback)
!= 0 e != 2 = erro não-bloqueante

Hooks como guardrails

{
  "hooks": {
    "PreToolUse": [
      {
        "type": "command",
        "command": "bash .claude/hooks/pre-edit-check.sh"
      }
    ],
    "PostToolUse": [
      {
        "type": "command",
        "command": "pnpm vitest run --related",
        "description": "Run related tests after edits"
      }
    ],
    "Stop": [
      {
        "type": "command",
        "command": "pnpm build 2>/dev/null || echo 'BUILD FAILED' >&2",
        "description": "Verify build before stopping"
      }
    ]
  }
}

4. Skills — workflows sob demanda

Estrutura

.claude/skills/
├── commit/
│   └── SKILL.md
├── deploy/
│   ├── SKILL.md
│   ├── deploy-checklist.md
│   └── scripts/pre-deploy.sh
└── review-pr/
    └── SKILL.md

SKILL.md com frontmatter

---
name: commit
description: "Conventional commit with pre-checks"
license: MIT
compatibility: [claude-code]
---

## Trigger
When the user says "commit", "/commit", or stages changes.

## Steps
1. git status && git diff --cached
2. Analyze and draft Conventional Commit message
3. Run: pnpm lint:fix && pnpm vitest run
4. If green, commit. If red, fix and retry.

## Hooks (scoped to this skill)
PostToolUse:
  - type: command
    command: pnpm format

5. MCP — Model Context Protocol

Configuração

// .claude/settings.json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-filesystem", "/path/to/project"]
    },
    "postgres": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "postgresql://localhost:5432/mydb" }
    },
    "puppeteer": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Via CLI

claude mcp add postgres npx @modelcontextprotocol/server-postgres
claude mcp add github npx @modelcontextprotocol/server-github

6. Subagentes

Configuração via CLI

# Definir subagentes customizados
claude --agents '[
  {
    "name": "tester",
    "description": "Writes and runs tests",
    "tools": ["Read", "Bash", "Write"]
  },
  {
    "name": "reviewer",
    "description": "Reviews code for security",
    "tools": ["Read", "Grep"]
  }
]'

Orquestração no prompt

Spawn subagents in parallel to:
1. Read specs/billing.md
2. Read src/db/schema.ts
3. Read src/api/users.ts

After all return, implement the billing module.

7. Permissões granulares

No settings.json

{
  "permissions": {
    "allow": [
      "Read(src/**)",
      "Grep(*)",
      "Bash(pnpm *)",
      "Bash(git *)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Read(.env*)",
      "Write(.env*)"
    ]
  }
}

Via CLI

claude --allowedTools "Read,Bash,Write"
claude --disallowedTools "Bash(rm *)"

8. Agent SDK (automação externa)

TypeScript

import { Agent } from '@anthropic-ai/claude-agent-sdk';

const agent = new Agent({
  model: 'claude-sonnet-4-20250514',
  tools: ['Read', 'Write', 'Bash'],
  hooks: {
    PostToolUse: async (event) => {
      console.log(`Tool used: ${event.tool}`);
    }
  }
});

const result = await agent.run(
  'Read src/api/users.ts and generate Vitest tests'
);
console.log(result.output);

Python

from claude_agent_sdk import Agent

agent = Agent(
    model="claude-sonnet-4-20250514",
    tools=["Read", "Write", "Bash"]
)

result = agent.run("Read src/api/users.ts and generate tests")
print(result.output)

9. Configurações avançadas

settings.json completo

{
  "model": "claude-sonnet-4-20250514",
  "effortLevel": "xhigh",
  "editorMode": "vim",
  "language": "pt-BR",
  "autoMemoryEnabled": true,
  "cleanupPeriodDays": 30,
  "env": {
    "NODE_ENV": "development",
    "GO_API_URL": "http://localhost:8080"
  },
  "permissions": {
    "allow": ["Read(*)", "Grep(*)", "Bash(pnpm *)"],
    "deny": ["Read(.env*)", "Bash(rm -rf *)"]
  },
  "hooks": {
    "PreToolUse": [{ "type": "command", "command": "pnpm lint:fix" }],
    "PostToolUse": [{ "type": "command", "command": "pnpm format" }]
  },
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-filesystem", "."]
    }
  }
}

.claude/settings.local.json (gitignored)

{
  "model": "claude-opus-4-7-20250514",
  "effortLevel": "max",
  "autoMemoryEnabled": true
}

10. Checklist: setup completo para full stack dev

# 1. Instalar
curl -fsSL https://claude.ai/install.sh | bash

# 2. Login
claude auth login

# 3. Init do projeto
cd seu-projeto
claude init              # Gera CLAUDE.md inicial

# 4. Criar estrutura
mkdir -p .claude/rules .claude/skills/commit .claude/hooks

# 5. Rules globais
cat > .claude/rules/global.md << 'EOF'
---
# Sempre carregado
---
2-space indent, single quotes, trailing commas.
Nunca commitar .env ou secrets.
Conventional Commits.
EOF

# 6. Rules por stack
# (criar backend.md, frontend.md, tests.md conforme seu projeto)

# 7. Hooks
cat > .claude/settings.json << 'EOF'
{
  "effortLevel": "xhigh",
  "hooks": {
    "PreToolUse": [{ "type": "command", "command": "pnpm lint:fix" }],
    "Stop": [{ "type": "command", "command": "pnpm vitest run && pnpm build" }]
  }
}
EOF

# 8. Skill de commit
cat > .claude/skills/commit/SKILL.md << 'EOF'
## Trigger: "commit" or staged changes
## Steps: git status → draft message → lint+test → commit
EOF

# 9. MCP (opcional)
claude mcp add filesystem npx @modelcontextprotocol/server-filesystem .

# 10. Testar
claude "Read CLAUDE.md and summarize the project"

Claude Code: Extraindo 100% — Guia Definitivo para Full Stack Developers

On this page