O problema: a IA não consegue enxergar os próprios bugs
Construir e auditar são estados mentais incompatíveis. Quando a IA está construindo, ela é otimista: imagina um único caminho feliz e foca em "fazer funcionar". Nesse modo ela fica cega aos próprios erros. Auditar exige o contrário: pessimismo, imaginar todas as formas em que algo pode falhar.
Se você pede à IA para construir e revisar ao mesmo tempo, as duas tarefas sofrem: ela constrói pela metade e audita pela metade. A solução não é um prompt mais esperto — é separar as duas fases em turnos distintos.
As 3 fases do protocolo
C — Construir. A IA constrói com energia criativa: pesquisa o padrão da concorrência, arquitetura limpa, e se autotesta enquanto avança. Ao terminar, ela para e te entrega um relatório (o que fez, quais decisões tomou, o que NÃO fez e por quê). Ainda não audita.
A — Auditar (e aqui está o debug de verdade). Em um turno NOVO (cabeça fresca, pessimista), a IA relê todo o próprio trabalho e faz o debug: caça bugs reais (vazamentos de memória, condições de corrida, falhas de segurança, acessibilidade quebrada) e, acima de tudo, corrige as brechas, vazios e inconsistências que o modo construtor deixou. Ela não apenas "encontra erros": refina tudo e deixa lendário. Cada achado é corrigido com um teste de regressão que fixa a correção — sem o teste, a correção não está completa.
R — Refletir. A IA escreve as lições da auditoria: o que escapou no modo construtor e por quê. Esse documento cresce a cada ciclo e se torna a memória institucional do projeto — na próxima vez ela já não comete o mesmo erro.
O loop completo · como ele se fecha de verdade (não só C-A-R)
Na prática, o C-A-R não termina em "refletir": ele se fecha alimentando todo o seu ecossistema, para que o conhecimento não se perca e o próximo ciclo comece melhor. Este é o loop real, tal como se aplica depois de cada boa passada de desenvolvimento — e reúne tudo o que você viu na série:
- Construir → a IA cria e te entrega o relatório dela.
- Smoke test → você roda os testes que fixam o trabalho; tudo no verde antes de seguir.
- Auditar / debug → turno novo: caçar bugs, corrigir brechas, vazios e inconsistências, refinar até deixar lendário (cada correção com seu teste).
- Refletir → a IA escreve as lições (o que escapou e por quê).
- Push para o GitHub → você salva o ponto bom na nuvem (sua rede de segurança).
- Atualizar o grafo → se você usa Graphify, reconstrói o grafo para que reflita o que é novo.
- Salvar o protocolo na memória → você o deixa no seu
CLAUDE.mdpara que a IA NUNCA o esqueça.
Como se aplica, passo a passo
- Peça à sua IA para construir a funcionalidade e, ao terminar, te dar um relatório (que ainda não audite)
- Leia o relatório e aprove
- Em uma mensagem nova, escreva "prossiga com a auditoria"
- A IA relê tudo com olhos de auditor e corrige cada bug com seu teste
- Ela te entrega a auditoria com a lista de achados corrigidos
- A IA salva as lições para não repetir os erros
O prompt mestre (copie e cole)
Cole isto no início do seu projeto (no arquivo de instruções da sua IA: CLAUDE.md, .cursorrules, as instruções do seu agente no NeuralOS, ou simplesmente no começo do chat). A partir daí, sua IA aplicará o C-A-R por padrão.
A partir de agora aplique o protocolo CONSTRUIR-AUDITAR-REFLETIR (C-A-R) em todo trabalho não trivial (features novas, refactors, mudanças multi-arquivo). Só pule em correções triviais de uma linha ou quando eu pedir explicitamente. === FASE 1 · CONSTRUIR === Construa com energia criativa. Pesquise o padrão da concorrência antes de escrever código. Arquitetura com limites limpos. Autoteste-se enquanto avança. Quando terminar, PARE e me entregue um relatório: - Arquivos criados/modificados e decisões-chave - Quais melhorias você adicionou acima do padrão - Resultados de testes (type-check, build, tests) - O que você NÃO fez e por quê (limite de escopo) Depois ESPERE. Não audite neste turno. Não misture a auditoria com a construção. === FASE 2 · AUDITAR (turno separado · requer minha aprovação) === Espere até eu dizer "prossiga com a auditoria". Então: 1. Releia cada arquivo com cabeça de AUDITOR (fresca, pessimista) 2. Catalogue os achados: - CRÍTICOS: bugs reais (vazamentos de memória, condições de corrida, falhas de segurança, acessibilidade quebrada, semântica errada, corrupção de dados) - MELHORIAS: robustez, desempenho, polimento de UX 3. Corrija cada achado com um TESTE DE REGRESSÃO que o fixe — sem o teste, a correção não está completa 4. Rode testes agressivos de casos de borda: unicode, valores limite, spam de eventos, operações concorrentes, rotas de cancelamento 5. Valide quádruplo: type-check + build + tests existentes + tests novos, TUDO no verde antes de fechar === FASE 3 · REFLETIR (junto à auditoria) === Escreva um documento de lições: cada achado com sua causa raiz (o que escapou de mim no modo construtor?), meta-lições, e um checklist atualizado para a próxima construção. Este documento cresce a cada ciclo e é a memória do projeto. REGRAS: - Nunca auditar no mesmo turno em que constrói. - Nunca afirmar "sem bugs" sem ter rodado uma auditoria real sobre o código novo. - Nunca pular o teste de regressão de uma correção da auditoria. - Causa raiz, nunca remendos. Se um valor chega vazio, encontre POR QUÊ; não tape com um valor padrão.
Monte O SEU protocolo conforme o que você já tem
O prompt acima é a base. Mas o protocolo fica mais poderoso quando você soma as ferramentas da série. Use o prompt que corresponde ao seu setup — do menos ao mais completo. A ideia: fazer sua IA fechar o loop com TUDO o que você tem.
=== FECHAMENTO DO LOOP · GITHUB === Depois que a auditoria ficar no verde (type-check + build + smoke tests todos passando), antes de dar o trabalho por concluído: 1. Lembre-me de rodar o smoke test se ainda não fizemos. 2. Faça um commit com uma mensagem clara que descreva o que conseguimos. 3. Faça push para o GitHub para salvar o ponto bom na nuvem. Nunca feche um ciclo sem deixar o progresso respaldado.
=== CONTEXTO PROFUNDO PARA A AUDITORIA === Antes de auditar, consulte o grafo de conhecimento (Graphify) ou o RAG do projeto para entender como aquilo que toquei se conecta com o resto. Audite entendendo o impacto em TODO o sistema, não só no arquivo que mudei. Pergunte-se: quais outras partes dependem disto? o que pode ter quebrado em cascata? === FECHAMENTO DO LOOP · FULL-STACK === Quando a auditoria ficar no verde, feche o ciclo completo, nesta ordem: 1. Smoke test → tudo no verde. 2. Commit + push para o GitHub (salvar o ponto bom). 3. Reconstrua / atualize o grafo de conhecimento (Graphify) para que reflita as mudanças novas, assim a próxima auditoria tem contexto fresco. 4. Salve as lições da auditoria no documento de memória do projeto. 5. Garanta que o protocolo C-A-R continue escrito no CLAUDE.md para não esquecê-lo. Este loop se aplica depois de cada sprint ou passada significativa de desenvolvimento.
Quais recursos você precisa para aplicá-lo?
- Uma IA de construção de código: Claude Code, OpenAI Codex, Cursor, ou NeuralOS (que já traz agentes e a Forja de Apps integrados)
- Um arquivo de instruções onde colar o prompt mestre (
CLAUDE.md,.cursorrules, ou as instruções do agente) - Disciplina para esperar: aprovar a construção e pedir a auditoria em uma mensagem à parte
- Opcional, mas recomendado: um grafo de conhecimento do projeto para que a auditoria tenha contexto completo (veja o recurso do Graphify abaixo)
Leve a auditoria ao próximo nível
A fase de auditar fica muito mais poderosa se sua IA entender como todo o projeto se conecta, não só o arquivo que ela tocou. É para isso que existe o Graphify: transforma seu repo em um grafo de conhecimento que a IA consulta antes de auditar.
Construtor de grafos de conhecimento multimodal para assistentes de IA (Claude Code, Codex, OpenCode). Transforma seu repo inteiro em um grafo interativo que explica o que o código faz e por que foi projetado assim.
Graphify · grafos de conhecimento para sua IA (guia completo)Aprenda a dar à sua IA um mapa completo do seu projeto para auditar melhor.