Claude Code em Ação: automação, hooks e agentes: Parte 2

A Parte 1 cobre a base: como o Claude executa ações via tool use, como configurar CLAUDE.md, quando criar custom commands, como usar Planning Mode e como controlar contexto durante a sessão. Com isso no lugar, o agente já entra no projeto com contexto, repete rotinas no padrão certo e pede menos explicação a cada turno.

Esta parte cobre os recursos que entram depois dessa base: controle fino de profundidade de raciocínio, execução sem confirmação manual, hooks para validar cada ação, MCP servers para conectar banco e browser, agendamento via GitHub Actions e SDK para orquestrar múltiplos agentes.

1. Effort Level: profundidade de raciocínio

A Parte 1 introduz effort level com três níveis (low, default, max) como controle de profundidade. A versão completa tem cinco níveis e dois mecanismos de ativação.

O effort level não muda quais ferramentas o Claude usa. Muda quanto o modelo raciocina antes de agir. Níveis altos consomem mais tokens e são mais lentos, mas chegam a soluções melhores em problemas que exigem planejamento ou análise de múltiplas variáveis.

Para ajustar a sessão inteira:

/effort xhigh

O nível persiste até você mudar de novo ou fechar a sessão. Para voltar ao padrão do modelo:

/effort auto

Keywords inline: sobrepor por turno

Quando você não quer mudar o nível da sessão mas precisa de raciocínio extra num único turno, use keywords no início da mensagem:

think analise os edge cases desse fluxo de autenticação
ultrathink por que essa migration está causando deadlock?

A gradação é: think < think hard < think harder < ultrathink. Cada keyword força raciocínio extra só naquele turno. O nível da sessão não muda.

Ctrl+O expande os passos de raciocínio do Claude na interface. Útil quando o Claude chegou a uma decisão que não parece óbvia e você quer entender o caminho que ele percorreu.

2. Auto Mode: execução sem confirmação

No fluxo padrão, o Claude pede confirmação antes de cada edição ou comando. No Auto Mode, ele lê, edita e executa em sequência sem parar para perguntar. Você define a tarefa, ele executa, você revisa o diff ao final.

O que aparece na revisão: arquivos criados, arquivos editados com o diff de cada um, comandos executados e seus outputs.

Como ativar

Via settings.json (controle por ferramenta):

{
  "permissions": {
    "allow": ["Read", "Edit", "Write", "Bash"]
  }
}

Via CLI (libera tudo, sessão única):

claude --dangerously-skip-permissions

O flag --dangerously-skip-permissions é para ambiente controlado: containers de CI ou scripts de automação onde você sabe o que o Claude vai executar.

Classificador de segurança

Auto Mode não significa ausência de controle. Um classificador separado revisa cada ação antes de executar. Por padrão, bloqueia:

• Deploy direto em produção
• Force push em qualquer branch
• Acesso a arquivos com credenciais ou dados sensíveis

O Claude exibe o plano antes de começar a executar. Você pode interromper antes da primeira ação se o plano não faz sentido.

A regra prática: quanto mais previsível e bem delimitada a tarefa, mais seguro é ativar.

3. Hooks: interceptar tool calls em tempo real

Toda vez que o Claude executa uma tool (ler arquivo, editar, rodar bash), o sistema pode passar a ação por um script seu antes ou depois. O script recebe o input da tool como JSON via stdin.

O exit code decide o resultado:

• 0: permite a ação
• 1: bloqueia e devolve a mensagem de erro ao Claude

O Claude vê a mensagem de erro como feedback e ajusta o comportamento. Se o hook barrar o acesso a .env, o Claude entende que aquele arquivo está fora dos limites e não tenta novamente.

PreToolUse vs PostToolUse

PreToolUse roda antes da tool call:

• Barrar acesso a arquivos sensíveis (.env, arquivos de credencial)
• Validar que o path alvo está dentro do diretório permitido
• Checar permissões antes de qualquer escrita

PostToolUse roda depois da tool call:

• Rodar type check automático após cada edição
• Rodar lint após cada escrita
• Enviar notificação quando o Claude modificar arquivos críticos

Exemplo: barrar acesso a .env

#!/bin/bash
# .claude/hooks/block-env.sh
 
INPUT=$(cat)
TOOL=$(echo "$INPUT" | jq -r '.tool')
PATH_ARG=$(echo "$INPUT" | jq -r '.input.path // empty')
 
if [[ "$TOOL" == "Read" || "$TOOL" == "Edit" || "$TOOL" == "Write" ]]; then
  if [[ "$PATH_ARG" == *".env"* ]]; then
    echo "Acesso a .env bloqueado por política do projeto" >&2
    exit 1
  fi
fi
 
exit 0

Exemplo: type check automático pós-edição

#!/bin/bash
# .claude/hooks/typecheck-on-edit.sh
 
INPUT=$(cat)
TOOL=$(echo "$INPUT" | jq -r '.tool')
 
if [[ "$TOOL" == "Edit" || "$TOOL" == "Write" ]]; then
  npx tsc --noEmit 2>&1
  if [ $? -ne 0 ]; then
    echo "Type check falhou após edição. Corrija os erros antes de continuar." >&2
    exit 1
  fi
fi
 
exit 0

Escopos de configuração

Para registrar os hooks no settings.json do projeto:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            "command": "bash .claude/hooks/block-env.sh"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "bash .claude/hooks/typecheck-on-edit.sh"
          }
        ]
      }
    ]
  }
}

Use o escopo global para hooks de segurança que se aplicam em qualquer projeto (bloquear arquivos de credencial). Use o escopo de projeto para hooks que dependem do toolchain local (type check, lint, testes específicos do projeto).

4. MCP Servers: ferramentas além do terminal

Por padrão, o Claude tem acesso ao sistema de arquivos, ao bash e ao editor. Não tem acesso a banco de dados, browser, APIs externas ou serviços de cloud. MCP servers preenchem esse espaço.

Cada server expõe um conjunto de ferramentas para o Claude. O Claude as usa da mesma forma que usa Read ou Bash: solicita a ação, o sistema executa, o resultado volta na conversa.

Setup básico

# Adicionar um server
claude mcp add postgres npx @modelcontextprotocol/server-postgres
 
# Listar servers ativos
claude mcp list
 
# Remover um server
claude mcp remove postgres

Níveis de confiança

Use allow quando estiver testando um server novo. Use trust depois que você entende o que o server faz e quer parar de confirmar a cada uso.

# Aprovar por sessão
/mcp allow postgres
 
# Tornar permanente
/mcp trust postgres

Exemplo real: Playwright + Postgres em sequência

Com playwright-mcp e postgres-mcp ativos:

Acesse o painel de analytics em localhost:3000/admin,
extraia os dados da tabela de conversão dos últimos 7 dias
e grave em uma tabela de snapshot no banco de desenvolvimento.

O Claude executa:

1. Abre o browser via Playwright
2. Navega até a URL
3. Extrai os dados da tabela (vê o resultado visual, não só o HTML)
4. Conecta ao Postgres e grava os dados

Sem MCP, esse fluxo exige scripts separados, dois terminais e coordenação manual.

Ecossistema de servers disponíveis

5. Agendamento e Remote Control

@mentions em issues

Instale o GitHub App do Claude Code com:

/install-github-app

O comando instala o app e abre um PR com os workflow files prontos. Você faz merge e está configurado.

Com o app instalado, mencione @claude em qualquer issue ou PR comment:

@claude Implemente a validação de CPF no formulário de cadastro.
Referência: src/forms/registration.ts. Abra um PR quando terminar.

O Claude lê o contexto do issue, abre uma branch, implementa, roda os testes e cria o PR com summary da mudança.

Automação via GitHub Actions

name: Claude Code CI
 
on:
  schedule:
    - cron: '0 3 * * 1'  # toda segunda-feira às 3h
  pull_request:
    types: [opened, synchronize]
 
jobs:
  claude:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Claude Code
        run: |
          claude --mcp-config .claude/mcp-ci.json \
                 --dangerously-skip-permissions \
                 "Audite as dependências do projeto e abra um PR com as atualizações seguras"
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

O --mcp-config permite passar um arquivo de configuração de MCP servers para o CI. Útil quando o pipeline precisa de acesso ao banco de staging ou APIs internas durante a auditoria.

Casos de uso comuns:

• Auditoria semanal de dependências com PR automático
• Code review automático em cada PR aberto
• Geração de relatório de cobertura de testes toda segunda-feira
• Limpeza de branches mergeadas com notificação no Slack

Remote Control

Para acompanhar e intervir em uma sessão rodando em outro ambiente:

# Na máquina remota (servidor, CI, VM)
claude --remote
 
# No seu terminal local
claude --attach <session-id>

Você vê o que o Claude está fazendo em tempo real e pode redirecionar, pausar ou cancelar. Não precisa de acesso SSH ao servidor.

6. SDK e Agent Teams

@anthropic-ai/claude-agent-sdk expõe o mesmo loop agente do Claude Code CLI para TypeScript e Python. O agente que você constrói com o SDK tem acesso às mesmas capacidades: leitura e escrita de arquivos, execução de bash, tool use, MCP servers e hooks. A diferença: o loop roda sob controle da sua aplicação, não do CLI interativo.

npm install @anthropic-ai/claude-agent-sdk

O async iterator

O SDK retorna um async iterator. Cada evento representa uma ação do agente, uma resposta parcial ou o resultado final.

import { query } from "@anthropic-ai/claude-agent-sdk";
 
for await (const event of query({
  prompt: "Refatore esse arquivo para usar async/await em vez de callbacks",
  options: {
    allowedTools: ["Read", "Edit"],
    maxTurns: 10,
  }
})) {
  if (event.type === "tool_use") {
    console.log(`Executando: ${event.name}`);
  }
  if (event.type === "result") {
    console.log("Concluído:", event.content);
  }
}

Processar evento a evento permite exibir progresso em tempo real, cancelar a execução baseado em condições da aplicação ou gravar cada passo num log para auditoria.

Controle de ferramentas disponíveis

// Agente só pode ler, não pode escrever
const readOnlyAgent = query({
  prompt: "Explique a arquitetura desse módulo",
  options: { allowedTools: ["Read", "Bash"] }
});
 
// Agente com acesso a MCP server
const dbAgent = query({
  prompt: "Liste as migrações pendentes",
  options: {
    allowedTools: ["Read", "mcp__postgres__query"],
    mcpServers: [{ name: "postgres", command: "npx @modelcontextprotocol/server-postgres" }]
  }
});

Agent Teams: múltiplos agentes em paralelo

Em vez de um agente único que faz tudo em sequência, você distribui o trabalho:

import { query } from "@anthropic-ai/claude-agent-sdk";
 
// Agente 1: escreve os testes (worktree isolado)
const testAgent = query({
  prompt: "Escreva testes para src/auth/login.ts. Use Vitest.",
  options: {
    allowedTools: ["Read", "Write"],
    cwd: "/tmp/worktrees/tests"
  }
});
 
// Agente 2: implementa a feature (worktree isolado)
const implAgent = query({
  prompt: "Implemente login com OAuth em src/auth/login.ts",
  options: {
    allowedTools: ["Read", "Edit", "Bash"],
    cwd: "/tmp/worktrees/impl"
  }
});
 
// Rodar em paralelo
const [testResult, implResult] = await Promise.all([
  collectResult(testAgent),
  collectResult(implAgent)
]);

Cada agente opera em um worktree separado do git, então os dois podem editar arquivos ao mesmo tempo sem conflito de merge. Você integra os resultados depois, quando os dois terminam.

A condição necessária é que as tarefas sejam independentes. Se o agente B depende do resultado do agente A, rode em sequência.

Setup completo de referência

Os recursos das duas partes se complementam:

O ponto de entrada prático: comece com um CLAUDE.md e dois ou três hooks básicos (barrar .env, type check automático). Esses dois juntos cobrem a maioria dos casos de segurança e qualidade sem overhead de configuração. O restante você adiciona conforme a necessidade.

@developer.israel · Claude Code em Ação · Parte 2 de 2

Post no Instagram · Perfil @developer.israel