Ferramentas de IA para programadores: OpenClaw + Claude Code corrigindo bugs 24 horas por dia

Um bug de timeout em um callback de pagamento levava, em média, 4,5 horas entre a descoberta e o merge da correção: 2 horas para ser detectado, 30 minutos para ser localizado, 30 minutos para a correção, 20 minutos para os testes e 10 minutos para abrir o PR. A solução desse tipo de bug costuma ser previsível: adicionar backoff exponencial, capturar exceções e registrar logs. Como é um “tipo de problema conhecido” e altamente repetitivo, não vale a pena tratá-lo manualmente caso a caso.

Um fluxo híbrido com OpenClaw + Claude Code resolve esse problema: o OpenClaw monitora o Sentry 24 horas por dia e atribui automaticamente cada bug encontrado; depois de receber a tarefa, o Claude Code cria um branch, altera o código, executa os testes e abre o PR. Em três meses de uso, o sistema capturou automaticamente 127 bugs e corrigiu 89 deles com sucesso (70%); no fim, 72 foram integrados após revisão humana (57%). O tempo de tratamento caiu de 4,5 horas para 15 minutos.

Este artigo apresenta a arquitetura, as etapas de configuração e os resultados práticos desse fluxo híbrido. Não é teoria: são dados reais de três meses de uso em produção.

Guia econômico para “criar lagostas”: ArkClaw torna os agentes de IA realmente acessíveis

O OpenClaw, a famosa “lagosta”, é útil, mas sua configuração desanima muita gente. O ArkClaw, da ByteDance Volcano Engine, derruba essa barreira. Sem precisar lidar com servidores nem configurar tokens, você ganha com um clique um “funcionário de IA” disponível 24 horas por dia, capaz de controlar o navegador, executar scripts e gerenciar calendários.

E o principal é o preço baixo: a mensalidade custa apenas 9,9 yuans; usando meu código de convite ZLKUK54M (cadastre-se aqui), sai por apenas 8,9 yuans. Se você é programador, também pode aderir ao Coding Plan Pro e usar gratuitamente.

OpenClaw vs. Claude Code: não são concorrentes, são complementares

Muita gente me pergunta: afinal, devo usar OpenClaw ou Claude Code?

Para ser sincero, os dois não competem entre si. Eles têm papéis completamente diferentes e funcionam melhor quando combinados.

O OpenClaw é um “agente pessoal de IA” disponível 24/7. Ele fica ativo em segundo plano, recebe webhooks, monitora várias fontes de dados e continua trabalhando enquanto você dorme. A definição oficial é “persistent personal AI”, ou IA pessoal persistente. Ele não é o melhor para escrever código complexo, mas é excelente para “observar” o que acontece, acionar as ações adequadas e coordenar outras ferramentas especializadas.

O Claude Code é um “programador de IA” especializado. Ele não sabe monitorar seu servidor por conta própria, mas analisar código, corrigir bugs e refatorar lógica são justamente seus pontos fortes. Ele consegue compreender profundamente uma base de código e determinar onde alterar e como fazer isso com segurança.

É uma combinação perfeita: um fica responsável por “observar”; o outro, por “executar”.

No OpenClaw Directory, encontrei uma receita chamada “Sentry → Auto-Debug → Open PR”, feita praticamente sob medida para esse cenário. A ideia é:

1. O Sentry detecta um erro e dispara um webhook
2. O OpenClaw recebe o alerta e analisa o stack trace
3. O OpenClaw cria um subagente e chama o Claude Code para corrigir o problema
4. O Claude Code gera a correção e executa os testes
5. Se os testes passarem, um PR é aberto automaticamente no GitHub

Todo o processo é automático, sem intervenção humana. Li no Substack o relato de alguém que descreveu esse fluxo como “overnight code review with no human in the loop until the PR is ready”: o bug aparece à noite, e o PR está pronto pela manhã.

Arquitetura: os principais componentes do fluxo híbrido

Para entender esse fluxo, primeiro é preciso conhecer o mecanismo de “subagentes” do OpenClaw.

O OpenClaw funciona como um grande coordenador. Ele escuta vários tipos de evento, como webhooks, tarefas agendadas e notificações, mas pode delegar a execução concreta a “subagentes”. Um subagente é uma instância temporária de IA, dedicada a uma tarefa específica.

Railway - Plataforma de deploy moderna, sem ops complexas, no ar em minutos

Começar agora →Anúncio

Pense assim: o OpenClaw é o gerente de projeto, e o Claude Code é o programador. O gerente recebe a demanda, ou seja, o alerta do Sentry, analisa e a encaminha ao programador, o subagente. O programador realiza o trabalho e relata o resultado.

A arquitetura completa é esta:

┌─────────────────────────────────────────────────────────────┐
│                        Mundo externo                        │
│  ┌──────────┐  ┌──────────┐  ┌─────────────────────────┐   │
│  │  Sentry  │  │  GitHub  │  │  Slack/Discord/Telegram │   │
│  └────┬─────┘  └────▲─────┘  └──────────▲──────────────┘   │
└───────┼─────────────┼───────────────────┼──────────────────┘
        │             │                   │
        │ webhook     │ create PR         │ notify
        │             │                   │
┌───────▼─────────────┴───────────────────┴──────────────────┐
│                      OpenClaw Gateway                       │
│  ┌──────────────────────────────────────────────────────┐  │
│  │             Agente principal do OpenClaw             │  │
│  │  • Escuta o webhook do Sentry 24 horas por dia       │  │
│  │  • Analisa o tipo e a gravidade do erro              │  │
│  │  • Decide: correção automática / ação humana / ignorar│  │
│  └─────────────────────┬────────────────────────────────┘  │
│                        │ spawn                             │
│                        ▼                                   │
│  ┌──────────────────────────────────────────────────────┐  │
│  │             Subagente Claude Code                    │  │
│  │  • Clona o código mais recente                       │  │
│  │  • Analisa a causa raiz do bug                       │  │
│  │  • Escreve a correção                                │  │
│  │  • Executa testes de validação                       │  │
│  │  • Faz push do branch e cria o PR                    │  │
│  └──────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────┘

O ponto principal é: o OpenClaw não altera o código diretamente. Ele apenas “decide” e “coordena”; as mudanças reais ficam a cargo do subagente Claude Code. Isso mantém a segurança, pois o OpenClaw controla as permissões, e a qualidade da correção, pois o Claude Code é especializado nesse trabalho.

O fluxo de dados é o seguinte:

1. Webhook do Sentry → OpenClaw (evento de erro, stack trace e dados do ambiente)
2. OpenClaw → subagente Claude Code (instruções de correção e contexto)
3. Subagente Claude Code → GitHub (código corrigido e descrição do PR)
4. GitHub → OpenClaw (status do PR e resultado do CI)
5. OpenClaw → Slack (notificação para revisão humana)

A capacidade do OpenClaw de gerenciar estado é importante aqui. Ele pode registrar o status de cada bug: “recebido”, “em análise”, “em correção”, “aguardando revisão” e “integrado”. Assim, mesmo que o fluxo seja interrompido, ele pode continuar a partir do ponto em que parou.

Configuração prática: do monitoramento à abertura automática do PR

Agora que os conceitos estão claros, vamos à configuração.

Etapa 1: configurar o webhook do Sentry

Entre no Sentry e acesse Project Settings → Integrations → Webhooks. Adicione a URL do webhook do OpenClaw:

https://your-openclaw-gateway.com/hooks/sentry?sessionKey=bug-fix-pipeline

Depois, crie uma regra em Alert Rules: quando error count > 5 in 5 minutes, dispare o webhook.

Etapa 2: configurar o agente de monitoramento do OpenClaw

Crie no OpenClaw um agent específico para tratar eventos do Sentry. O arquivo de configuração será semelhante a este:

name: sentry-bug-monitor
hooks:
  sentry:
    path: /hooks/sentry
    defaultSessionKey: bug-fix-pipeline

steps:
  - id: parse-error
    command: json.parse stdin
    description: "Interpretar os dados de erro do Sentry"

  - id: classify
    command: llm-task "Analisar o tipo e a gravidade do erro"
    args:
      error: $parse-error.stacktrace
      message: $parse-error.message
    schema: error-classification.json

  - id: decision
    command: state.set "action" $classify.recommended_action

  - id: auto-fix
    command: subagent.spawn
    args:
      type: claude-code
      task: "Corrigir o bug: ${parse-error.title}"
      context: $parse-error
      repo: $parse-error.project.repo
    condition: $classify.severity == "medium" && $classify.auto_fixable == true

  - id: notify-human
    command: slack.send "#alerts"
    args:
      message: "Erro grave encontrado; é necessária intervenção humana: ${parse-error.url}"
    condition: $classify.severity == "critical"

Há alguns pontos importantes:

• A etapa classify usa um LLM para analisar o tipo do erro e decidir se ele é adequado para correção automática
• decision faz o roteamento conforme a gravidade: itens de prioridade média e corrigíveis automaticamente seguem para o Claude Code; os graves são encaminhados à equipe
• subagent.spawn é a instrução que cria o subagente; aqui, o type definido é claude-code

Etapa 3: configurar o subagente Claude Code

A tarefa do subagente é corrigir o código. O OpenClaw envia todo o contexto necessário, incluindo o stack trace, os arquivos relacionados e as informações do ambiente.

O fluxo de trabalho do subagente é:

# 1. Clonar o código mais recente
git clone $REPO_URL /tmp/fix-workspace
cd /tmp/fix-workspace

# 2. Criar o branch de correção
git checkout -b auto-fix/$ERROR_ID

# 3. Analisar o problema com o Claude Code
claude-code --context $ERROR_CONTEXT --prompt "Analise a causa raiz deste bug"

# 4. Escrever a correção
claude-code --prompt "Escreva o código da correção e inclua testes"

# 5. Executar os testes
npm test

# 6. Fazer commit e push
git add .
git commit -m "fix: auto-fix for $ERROR_TITLE [skip ci]"
git push origin auto-fix/$ERROR_ID

# 7. Criar o PR
gh pr create --title "Auto-fix: $ERROR_TITLE" --body "..."

O principal valor do Claude Code aqui é a “compreensão do código”. Ele não faz alterações cegas baseadas apenas no stack trace. Em vez disso, ele:

Alibaba Cloud - Escolha dos desenvolvedores, 15% de desconto exclusivo em Lighthouse

Ganhar 15% off →Anúncio

• Lê os arquivos relacionados e compreende a lógica de negócio
• Analisa o caminho de propagação do erro e encontra a verdadeira causa raiz
• Escreve uma correção compatível com o estilo do projeto
• Gera testes unitários para validar o resultado

Etapa 4: automatizar o PR no GitHub

Depois que o PR é criado, o OpenClaw continua monitorando o webhook do GitHub:

- id: watch-pr
  command: github.watch-pr $auto-fix.pr_number

- id: ci-status
  command: poll "github.checks $auto-fix.pr_number"
  until: $ci-status.completed == true
  timeout: 30m

- id: notify-review
  command: slack.send "#dev"
  args:
    message: |
      O PR de correção automática está pronto: ${auto-fix.pr_url}
      Status do CI: ${ci-status.conclusion}
      Revise e faça o merge

Assim, você recebe no Slack uma mensagem com o link do PR e o resultado do CI. Basta abrir, revisar o código e fazer o merge se estiver tudo certo. Durante todo o processo, você não precisa clonar o projeto, escrever a correção nem executar os testes manualmente.

Técnicas avançadas para tornar o fluxo mais inteligente

Depois que a configuração básica estiver funcionando, você pode adicionar alguns recursos para aprimorar o fluxo.

Classificação dos bugs

Nem todo bug merece uma correção automática. Acrescentei um mecanismo simples de regras à etapa classify:

• P0 (Critical): sistema fora do ar ou perda de dados → notificação humana imediata
• P1 (High): recurso essencial indisponível → notificação + tentativa de correção automática, com confirmação humana antes do envio
• P2 (Medium): falha em recurso não essencial → correção totalmente automática
• P3 (Low): caso de borda ou sugestão de otimização → registro no backlog para tratamento semanal em lote

Pontos de verificação humana

Algumas correções podem estar tecnicamente certas, mas ser inadequadas para o negócio. Por isso, adicionei uma etapa de approval:

- id: propose-fix
  command: claude-code.generate-fix

- id: human-approval
  command: slack.interactive
  args:
    message: "A IA propõe a correção abaixo. Aprovar o envio?"
    buttons: ["Aprovar", "Rejeitar", "Solicitar alterações"]
  timeout: 4h

- id: submit-if-approved
  command: github.create-pr
  condition: $human-approval.choice == "Aprovar"

Assim, a IA não toma decisões por conta própria em operações sensíveis.

Novas tentativas e rollback em caso de falha

Nem sempre o Claude Code consegue corrigir o problema na primeira tentativa. Se os testes falharem, o processo pode tentar novamente:

- id: fix-attempt
  loop: 3
  sub-lobster: claude-code-fix
  break-on: $fix-attempt.tests_passed

- id: escalate-if-failed
  command: slack.send "#dev-escalation"
  condition: !$fix-attempt.tests_passed

Se todas as três tentativas falharem, a equipe recebe uma notificação para assumir o caso.

Suporte a vários repositórios

Nossa empresa tem mais de dez microsserviços, cada um em seu próprio repositório. O OpenClaw pode configurar o mapeamento de vários projetos:

projects:
  payment-service:
    repo: github.com/acme/payment
    sentry_project: payment-api
    auto_fix: true

  user-service:
    repo: github.com/acme/users
    sentry_project: user-api
    auto_fix: false  # A correção automática ainda está desativada neste projeto

Assim, uma única instância do OpenClaw pode atender vários projetos.

KiloClaw - OpenClaw gerenciado para empresas: orquestração de agentes IA e roteamento inteligente

Começar →Anúncio

Avaliação dos resultados e cuidados

Depois de três meses usando esse sistema, obtive os seguintes dados:

• Total de bugs capturados: 127
• Correções automáticas concluídas: 89 (70%)
• Correções que passaram nos testes: 78 (61%)
• Correções integradas após revisão humana: 72 (57%)

Em outras palavras, quase 60% dos bugs não exigiram trabalho manual; pela manhã, bastava verificar o PR e clicar em merge.

A economia de tempo foi ainda mais clara. Antes, o fluxo típico de um bug era: descoberta, em média 2 horas → localização, 30 minutos → correção, 30 minutos → testes, 20 minutos → abertura do PR, 10 minutos. No total, 4,5 horas.

Agora: descoberta em tempo real → correção pela IA em 10 minutos → revisão humana em 5 minutos. O tempo caiu de 4,5 horas para 15 minutos.

Mas, falando com franqueza, o sistema também tem limitações:

Cenários indicados:

• Bugs repetitivos de tipos conhecidos, como referência nula, condição de limite e timeout de API
• Erros de execução com stack trace claro
• Projetos com estrutura organizada e boa cobertura de testes

Cenários não indicados:

• Problemas de arquitetura, que exigem decisões humanas
• Bugs complexos que dependem da coordenação entre vários sistemas
• Lógica de negócio complexa, que exige contexto do negócio para tomar decisões
• Código legado sem cobertura de testes, pois não há segurança para integrar a alteração feita pela IA

Controle de riscos:

• Nunca dê à IA permissão de escrita no ambiente de produção
• Todas as correções automáticas devem passar por um PR e pelo processo normal de revisão
• Mantenha logs de auditoria completos para saber exatamente o que a IA alterou
• Avalie regularmente a qualidade das correções e ajuste os prompts do modelo

Conclusão

Em essência, o fluxo híbrido com OpenClaw + Claude Code automatiza duas etapas: o “monitoramento” e a “correção”. O OpenClaw cuida do trabalho necessário que não é o seu ponto forte, isto é, observar o sistema 24 horas por dia. O Claude Code faz aquilo em que é especializado: escrever código. Juntos, eles formam uma espécie de “programador júnior que nunca se cansa”: executa o trabalho, mas precisa da sua supervisão.

O principal valor dessa configuração não é “substituir programadores”, e sim eliminar trabalho repetitivo, permitindo que você concentre sua energia no que realmente exige inteligência humana.

Se você sofre com o on-call ou sua equipe vive enfrentando os mesmos bugs, vale a pena testar esse fluxo. Comece pelo caso mais simples, como a correção automática de um tipo específico de erro, e amplie aos poucos.

O futuro do desenvolvimento provavelmente seguirá esse modelo de “decisão humana + execução pela IA”. Quanto antes você adotá-lo, mais cedo poderá encerrar o expediente.