Início / Trilha 2 / Módulo 2.7
MÓDULO 2.7 Trilha 2 — Prática

✅ 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.

📋6 tópicos
~35 min
🎯Prático
🔬Verificação
o ciclo da verificação — uma edição é uma hipótese; um check que passa é a evidência EDIT você muda algo = uma hipótese ainda não provada VERIFY rode o teste/build REAL = a evidência não um ls / echo NARRATE relate o que houve = sem rodeios passou / falhou / pulou testa passou ✓ falhou ✗ loop de recuperação — diagnostique, não repita cego ① diagnostica leia o erro inspecione o estado ② corrige forme a correção aplique a mudança ③ re-verifica rode o check de novo o erro sumiu? ④ não deu? diga claramente nunca em silêncio re-testa

Conteúdo detalhado

1

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 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".

Do Fable Mindset — verbatim an edit is a hypothesis
"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".

💡
Edição = palpite
ainda não provada
🧾
Check = prova
a evidência real
🚫
"Parece certo"
não conta
"Como eu sei?"
a pergunta-chave
2

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.

🧪
Teste de verdade
o do projeto
🎭
Nada de ls/echo
não é prova
🧰
Suíte inteira
se o projeto pede
📖
Leia o resultado
não só o exit code
3

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.

Bloco 11 da biblioteca — confirmação antes do irreversível cole no <seguranca>
<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".

4

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.

Regra de ouro — relato fiel bloco 7 da biblioteca, verbatim
"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ê.

5

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.

Bloco 6 da biblioteca — recuperação de erro cole no <loop> ou solto
<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.

6

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.

🎯
Meta atingida
o objetivo do turno saiu
+
Check real passou
a evidência, não o palpite
+
🗣️
Relatado com fidelidade
o que houve, sem hedging

⚠️ 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
📣
Sempre fale
nada de silêncio
🧾
Com a evidência
erro + o que tentou
🏁
Feito = 3 coisas
meta + check + relato
🤝
Confiança
vem da fidelidade

🔬 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. 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. 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. 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. 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.