✅ Verificação e relato fiel
O último módulo da Prática, e o que separa quem "acha que funcionou" de quem sabe que funcionou. Uma edição é só uma hipótese; um check de verdade é a prova. Aqui você instala o reflexo de rodar o teste real, confirmar antes do irreversível, recuperar de erro com método e relatar o que aconteceu sem rodeios. É a peça que faz uma IA digna de confiança.
Conteúdo detalhado
Uma edição é uma hipótese
Você acabou de mudar uma linha do prompt, ou pedir uma correção, e ela parece certa. Pare aí: parecer certo não é evidência de nada. Uma edição é só um palpite com aparência de solução — uma hipótese. A pergunta que importa não é "ficou bom?", é "como eu sei que ficou bom?". E a resposta é sempre a mesma: porque um check de verdade passou.
🔬 A ideia em uma frase
Toda mudança que você faz é uma hipótese — uma aposta de que o problema some. Ela vira conhecimento só quando você roda a verificação e vê o resultado. Antes disso, você não corrigiu nada; você propôs uma correção.
Esse é o pensamento que muda tudo: separar o ato de mudar (barato, rápido, incerto) do ato de provar (o que de fato te dá confiança). Quem confunde os dois entrega "provavelmente funciona" achando que é "está feito".
"An edit is a hypothesis. A passing check is the evidence."
Duas frases. A primeira te tira a falsa sensação de pronto; a segunda te diz onde ela mora de verdade — no check, não no seu otimismo.
Por que isso importa pra você
Porque a IA, por padrão, é otimista: ela tende a relatar sucesso que não conferiu. Se você não exige a prova — no prompt e no seu próprio hábito — você herda esse otimismo. Tratar cada mudança como hipótese é o antídoto: força a pergunta "qual check provaria isso?" antes de qualquer "pronto".
Rode o check REAL, não um teatro
Aqui está o erro mais comum, e o mais invisível: rodar um check que parece verificação, mas não verifica nada. Um ls que confirma que o arquivo existe. Um echo que imprime "ok". Um comando qualquer que saiu com código zero. Nada disso prova que a sua mudança funcionou. O check real é o teste, o build, o lint ou o typecheck que o projeto de fato usa — e rodar a coisa de verdade, não um substituto reconfortante.
✓ Check real (a evidência)
- ✓Rodar o teste do projeto e ler o que passou/falhou
- ✓Rodar o build inteiro e ver se compila de fato
- ✓Dar a tarefa real à IA e checar a saída contra o critério
- ✓Abrir a coisa e observar o comportamento, não só o exit code
✗ Teatro de verificação (prova nada)
- ✗Um ls que só mostra que o arquivo está lá
- ✗Um echo "funcionou" que você mesmo escreveu
- ✗Um comando não relacionado que saiu com código 0
- ✗"Olhei e parece certo" — leitura no lugar de execução
🎯 Se o projeto pede a suíte inteira, rode a suíte inteira
A tentação é rodar só o teste do pedacinho que você mexeu. Mas a sua mudança pode ter quebrado outra coisa longe dali — e um subconjunto escolhido a dedo não pega isso. Verificação escopada estreito é o jeito mais fácil de declarar "passou" com algo quebrado fora do seu campo de visão.
Esta é, segundo o próprio acervo, a disciplina mais negligenciada — rodar o check real após editar acontece numa minoria das vezes. Por isso ela é inegociável: é exatamente onde dá pra ser melhor que a média.
No prompt: nomeie o check, não deixe a IA inventar
No bloco <loop>, a etapa VERIFY tem que dizer qual é o check real do seu caso: "rode npm test", "rode o build", "dê a tarefa X e confira a saída". Se você não nomear, a IA escolhe o caminho mais barato — e o mais barato costuma ser o teatro.
Confirme antes do irreversível
Verificar é sobre o que já aconteceu. Confirmar é sobre o que ainda vai acontecer — e é especialmente importante quando a ação é difícil de desfazer ou sai pra fora. Deletar, sobrescrever, publicar, enviar um e-mail, chamar um serviço externo: nessas, o certo é checar antes. Um "pode?" curto custa um segundo; um e-mail enviado por engano custa um relacionamento.
<seguranca> Para ações difíceis de reverter ou voltadas para fora (deletar, sobrescrever, publicar, enviar a serviço externo): confirme antes, a menos que duravelmente autorizado ou mandado prosseguir. Aprovação num contexto não se estende ao próximo. Antes de deletar/sobrescrever, olhe o alvo: se o que achar contradiz como foi descrito, ou você não o criou, levante isso em vez de prosseguir. </seguranca>
! Pare e confirme primeiro
- ⚠Deletar arquivos, registros, branches
- ⚠Sobrescrever algo que você não criou
- ⚠Publicar / enviar a um destino externo (e-mail, post, deploy)
- ⚠Qualquer coisa cara de desfazer ou que afeta outras pessoas
✓ Pode seguir sem perguntar
- ✓Ler, listar, buscar, inspecionar (reversível)
- ✓Editar um rascunho que você mesmo está montando
- ✓Quando o usuário já autorizou aquela ação dur, ou mandou prosseguir
- ✓Passos internos sem efeito pra fora do seu espaço
"Aprovação num contexto não se estende ao próximo"
Você liberou enviar um e-mail? Isso não vira passe livre pra enviar todos. Cada ação irreversível pede sua própria luz verde — a menos que você tenha autorizado duravelmente ("pode sempre enviar sem me mostrar"). Esse detalhe evita que um "ok" vire um "ok pra tudo".
Relato fiel, sem hedging
Verificou? Agora conte a verdade do que aconteceu. Se o teste falhou, diga que falhou e mostre a saída. Se você pulou uma etapa, diga que pulou. Se está feito e verificado, afirme sem rodeios, sem "acho que", sem "provavelmente". Confiança se constrói com relato preciso — não com relato otimista. A IA que enfeita um resultado não verificado como pronto está corroendo a única coisa que a torna útil: você poder acreditar no que ela diz.
"Report outcomes faithfully: if tests fail, say so with the output; if a step was skipped, say that; when something is done and verified, state it plainly without hedging."
✓ Relato fiel
- ✓"Os testes passam — eis a saída: 14 ok, 0 falhas."
- ✓"Falhou em 2 casos; o erro foi X. Aqui está o log."
- ✓"Pulei o build porque o ambiente não tinha a dependência."
- ✓"Feito e verificado." — dito sem rodeios, porque o check passou
✗ Relato otimista (hedging)
- ✗"Deve estar funcionando agora!" — sem ter rodado nada
- ✗"Pronto!" quando o teste falhou e ela não contou
- ✗Omitir a etapa pulada e deixar você achar que rodou
- ✗"Provavelmente resolve" disfarçado de "está resolvido"
"Provavelmente funciona" não é pronto
Existe um teste de uma frase pra saber se um relato é fiel: ele distingue "provavelmente funciona" de "testes passam, eis a saída"? O primeiro é palpite vestido de conclusão. O segundo é pronto de verdade. Cobre isso da IA — e de você.
Recuperar de erro, sem flailing
Erro é normal — o que separa disciplina de sorte é a resposta ao erro. O reflexo ruim é rodar o mesmo comando de novo, igualzinho, torcendo por um resultado diferente. Isso é tatear no escuro. O reflexo bom é um loop curto: diagnosticar → corrigir → re-verificar. Você lê o erro, entende o estado, forma uma correção informada e só então tenta de novo. Olhe o diagrama lá em cima: é exatamente esse o caminho de baixo.
0. A falha acontece
O check não passou. Ponto de partida — não de pânico.
O teste vermelho, o build que quebrou, a saída errada. Isso é informação, não fracasso. A falha está te dizendo onde olhar. O pior que você pode fazer agora é ignorá-la ou repetir o comando às cegas.
1. Diagnostique — leia o erro, inspecione o estado
A etapa que quase todo mundo pula. É onde a correção nasce.
Leia a mensagem de erro inteira. Re-rode com mais visibilidade se precisar. Abra o arquivo ou o estado que importa. Você está procurando a causa, não tapando o sintoma. Sem diagnóstico, qualquer correção é chute.
2. Corrija — uma mudança informada
Agora sim você muda algo — mas guiado pelo que o erro revelou.
Forme a correção a partir do diagnóstico e aplique. Note que esta correção é, de novo, uma hipótese — fecha o ciclo do tópico 1. Você ainda não sabe se resolveu; só vai saber no próximo passo.
3. Re-verifique — rode o check de novo
Sem este passo, você não corrigiu — só mexeu.
Rode o mesmo check real. Passou? O erro morreu — siga e relate. Falhou de novo? Volte ao passo 1 com a nova informação, não repita cego. E se depois de tentar você não resolver, vá pro tópico 6: diga claramente, com a evidência.
<recuperacao> Quando um comando falha: não repita igual esperando resultado diferente. Leia o erro → inspecione o arquivo/estado → forme a correção → corrija → re-verifique. Nunca largue um turno que falhou em silêncio. Se não resolver, diga claramente, com a evidência. </recuperacao>
Repetir o comando igual é o antipadrão #1
Se o comando falhou e você roda ele de novo sem mudar nada, ele vai falhar de novo — o estado não mudou sozinho. Cada nova tentativa precisa carregar uma informação nova: ou você mudou a coisa, ou mudou o que está olhando. Tentativa sem novidade é só ruído.
Nunca largue um turno em silêncio
A última regra, e a mais simples de cumprir: não suma. Se uma tarefa travou e você não conseguiu resolver, isso não é desculpa pra terminar o turno fingindo que deu certo, nem pra ir embora sem dizer nada. Diga claramente o que aconteceu, mostre a evidência, e seja honesto sobre onde parou. Um "não consegui, e foi por isto" vale infinitamente mais que um silêncio que deixa você descobrir o estrago depois.
📣 O que "não largar em silêncio" quer dizer
- ① Não abandone: um turno que falhou nunca termina como se nada tivesse acontecido. O erro é parte do relato.
- ② Não disfarce: resultado não verificado não vira "pronto". Se você não provou, diga que não provou.
- ③ Não vá dark: numa tarefa longa, narre as transições. Não suma por vinte passos e apareça só no fim.
- ④ Peça ajuda com a evidência: "travei aqui, eis o erro e o que já tentei" é um pedido útil — não uma derrota.
🏁 O que "feito" significa de verdade
Juntando os seis tópicos: um turno está feito quando a meta foi atingida, a mudança foi verificada por um check real, e o resultado foi relatado com honestidade — incluindo o que falhou ou foi pulado. Tudo o que falta um desses três não está feito.
⚠️ O silêncio é o pior dos erros
De todos os jeitos de fechar um turno, um único é imperdoável: o silêncio sobre uma falha. Errar e dizer é confiável. Travar e pedir ajuda é confiável. Mas esconder que algo deu errado destrói a confiança de uma vez — porque o estrago aparece sem aviso, no pior momento possível.
- ✗Terminar com "pronto!" quando o teste estava vermelho
- ✗Omitir que uma etapa crítica foi pulada
- ✗Encerrar o turno sem mencionar o erro que apareceu no meio
🔬 Mão na massa: seu entregável
Feche a Trilha 2 instalando a verificação no seu próprio PMV. Em 15 minutos você sai com uma cláusula de verificação de verdade.
- 1 Pegue o PMV que você montou nos módulos anteriores. Nomeie, em uma frase, qual é o check real do seu caso — o teste/build/tarefa que prova que a coisa funciona (não um ls).
- 2 Cole no prompt os blocos 6 (<recuperacao>) e 11 (confirmação antes do irreversível), e acrescente a regra de relato fiel — diga "se falhar, mostre a saída; se pular, avise".
- 3 Dê à IA uma tarefa que vai dar errado de propósito (peça algo impossível ou com um detalhe quebrado). Observe: ela diagnostica e tenta de novo com método, ou repete cego? Ela conta que falhou?
- 4 Ajuste a regra até o relato sair fiel: falha admitida com evidência, sucesso afirmado só quando o check passou. Esse é o seu prompt de produção saindo da Trilha 2.
📝 Resumo do Módulo
- ✓Uma edição é uma hipótese; um check que passa é a evidência — "parece certo" não conta
- ✓Rode o check REAL (teste/build/lint do projeto), nunca um ls/echo; suíte inteira se o projeto pedir
- ✓Confirme antes do irreversível: deletar, sobrescrever, publicar, enviar a externo
- ✓Relato fiel, sem hedging: se falhou, diga; se pulou, diga; se passou, afirme sem rodeios
- ✓Recupere de erro com método: diagnostique → corrija → re-verifique, nunca repita cego
- ✓Nunca largue um turno em silêncio — "feito" = meta + check real + relato honesto
🎓 Você terminou a Trilha 2
Saiu da teoria e montou, rodou, podou e verificou um prompt de verdade. Você agora tem um PMV de produção e o reflexo de provar o que afirma. A próxima trilha sobe o nível: personas consistentes, agentes com loop completo, segurança por princípio e os padrões avançados do acervo.
➡️ Próxima Trilha
🧠 Avançado (Trilha 3). Dos blocos prontos para a maestria: persona em quatro eixos, o loop operacional completo, hierarquia de prioridade e segurança por princípio — para construir o "agente pessoal consistente" que o método persegue.