MÓDULO 6.2 · PRÁTICA

🏁 Exercício: execução, gates, revisão e entrega

Etapas 5 a 8. Com a preparação pronta, agora é executar o loop, passar pelos portões, submeter a mudança a um revisor independente e entregar um pull request que se sustenta sozinho.

6
Etapas
75
Minutos
Aplicado
Nível
Hands-on
Tipo
0%0 de 6
5

⌨️ Etapa 5 — Execute a implementação

Agora sim o agente escreve código — dentro do loop que você definiu, com o plano aprovado antes. Aprovar o plano custa dois minutos e evita refazer uma hora de implementação na direção errada.

🧪 Faça agora — disparar o loop

Objetivo: executar a etapa 5 sem improviso.

Leia, nesta ordem: AGENTS.md, docs/exercicio/spec.md, docs/exercicio/loop.md.
Siga o loop exatamente como está escrito.

Comece pelo passo 1: apresente o PLANO em no máximo 10 linhas
(o que vai mudar, em quais arquivos, e como cada critério de aceitação
será verificado) e PARE. Não escreva código antes da minha aprovação.

Leia o plano com estas três perguntas: (1) ele toca só os arquivos previstos? (2) cobre todos os critérios? (3) inventou alguma abstração que ninguém pediu? Aprove ou corrija. Depois:

Plano aprovado <com ajustes: ...>. Prossiga com os passos 2 e 3 do loop.
Ao terminar: cole a saída REAL e completa de <comando de teste> e rode
"git diff --stat" para eu ver o tamanho da mudança.

Como verificar: confira o --stat contra o limite do AGENTS.md e rode você mesmo o comando de teste. Nunca aceite o resumo do agente como evidência — rode.

⚠️ Atenção

Se o loop bater o teto (3 tentativas) ou repetir a mesma falha duas vezes, pare — como combinado. Isso não é fracasso do exercício: é o controle funcionando. Anote no registro o que foi tentado e decida você o próximo passo.

Plano antes

Aprovação sua

--stat

Confira o tamanho

Rode você

O teste, de verdade

Parar

É o controle certo

6

🚦 Etapa 6 — Aplique os quality gates

Rode a bateria do módulo 3.3 sobre a sua mudança. Aqui você descobre quais portões o seu repositório ainda não tem — e essa lista é um dos produtos mais valiosos do exercício.

🧪 Faça agora — a passagem pelos portões

<comando de build>     # ☐ passou
<comando de lint>      # ☐ passou
<comando de teste>     # ☐ passou · cole a saída no registro
git diff --stat        # ☐ dentro do limite de arquivos
git diff -- <pasta de testes>   # ☐ VAZIO (nenhum teste existente alterado)
git diff -- <arquivo de dependências>  # ☐ VAZIO (nenhuma dependência nova)
git log -p | grep -iE "senha|password|secret|token|api[_-]?key"  # ☐ nada

Como verificar: anote no registro quais destes gates já são automáticos no seu CI e quais você acabou de rodar na mão. Cada verificação manual é um item de backlog: ela deveria estar no pipeline, não na sua memória.

✓ Sinal de boa execução

  • Diff dentro do limite combinado
  • Testes existentes intocados; testes novos cobrindo o comportamento novo
  • Zero dependências adicionadas
  • Você consegue explicar cada arquivo alterado

✗ Bandeiras vermelhas no diff

  • Um teste antigo "ajustado" junto da correção
  • Exceção capturada e engolida em silêncio
  • Arquivo de configuração alterado sem motivo aparente
  • Abstração nova para um único uso

Todos os gates

Sem exceção

Manual hoje

Automático amanhã

Teste intocado

Confira com git diff

Explique tudo

Arquivo por arquivo

7

🔍 Etapa 7 — Revisão independente

Abra uma sessão nova, sem o histórico da implementação. Esta é a etapa que mais surpreende quem faz o exercício: o revisor encontra coisas que o implementador defendia com convicção dez minutos antes.

🧪 Faça agora — o revisor

Você é o revisor independente. Não implementou nada disto e não deve confiar
em nenhuma afirmação de quem implementou.

Especificação: docs/exercicio/spec.md
Diff: <cole a saída de "git diff origin/<base>...HEAD">

Leia os arquivos relacionados antes de concluir e responda:
1. a mudança cumpre TODOS os critérios de aceitação? o que ficou faltando?
2. algo fora do escopo declarado foi alterado?
3. algum comportamento existente muda para quem consome?
4. o tratamento de erro cobre os casos previstos na spec?
5. os testes provam o comportamento novo ou apenas executam o código?
6. existe algo aqui que passa nos testes e ainda assim está errado?

Formato: no máximo 7 achados, cada um com
[bloqueante | importante | menor] · arquivo:linha · por que é problema · como verificar.
Se não houver bloqueante, diga isso explicitamente.

Como verificar: pegue cada achado bloqueante e tente reproduzi-lo você mesmo. Corrija os que se sustentam — voltando ao loop, com as mesmas regras — e registre no registro.md quantos achados eram reais. Essa taxa é a sua medida de confiança no revisor.

💡 Dica prática

A pergunta 6 ("passa nos testes e ainda assim está errado") é a que mais rende. Faça essa pergunta em toda revisão daqui para frente — é o antídoto direto contra o defeito mais perigoso da trilha 4.

Sessão nova

Contexto limpo

Spec + diff

E nada mais

Reproduza

Antes de corrigir

Taxa real

Mede o revisor

8

📦 Etapa 8 — Prepare a entrega

Um PR com evidência é revisado em minutos; um PR sem evidência é aprovado sem leitura — o que é pior do que não ser revisado, porque cria a ilusão de controle.

🧪 Faça agora — corpo do pull request

## O que muda
<2 a 3 linhas, em português, do ponto de vista de quem usa>

## Especificação
docs/exercicio/spec.md  (critérios de aceitação atendidos: <liste>)

## Fora do escopo (não foi alterado de propósito)
- <...>

## Evidência
<saída real do comando de teste — colada, não resumida>
git diff --stat: <n> arquivos, +<n> -<n>
gates: build ✓ · lint ✓ · testes ✓ · sem dependência nova ✓ · sem segredo ✓

## Revisão independente
<achados do revisor e o que foi feito com cada um>

## Risco e reversão
Risco: <baixo/médio> · Como reverter: <comando ou passo>

Como verificar: peça para alguém do time ler só o corpo do PR (sem abrir o diff) e dizer o que a mudança faz e qual o risco. Se a pessoa conseguir, a entrega está pronta. Se não, falta evidência ou falta clareza — e é mais rápido corrigir agora.

Evidência

Colada, não narrada

Fora do escopo

Também se declara

Reversão

Em uma linha

Teste do leitor

Sem abrir o diff

5

📊 Faça a retrospectiva do exercício

Cada intervenção sua durante o exercício é candidata a virar rule, gate ou item do AGENTS.md. É assim que o sistema fica melhor sozinho na próxima tarefa — e é isso que diferencia quem usa IA de quem constrói com IA.

o que eu corrigi cada intervenção sua vira RULE (vale em toda tarefa) vira GATE (o CI impede) vira item do AGENTS.md → próxima tarefa exige menos de você

Como ler: este é o ciclo que faz o método se pagar. Toda vez que você corrige o agente na mão, pergunte para qual das três caixas aquilo vai. Se não for para nenhuma, provavelmente era uma decisão que só um humano toma mesmo — e isso também é informação.

Checagem rápida: durante o exercício você precisou lembrar o agente três vezes de não mexer nos testes. O que fazer com isso?

Intervenção

Vira regra

Repetiu 3x

Automatize

Gate faltando

Vai pro backlog

Próxima vez

Exige menos de você

6

🎒 Monte o seu kit de entregáveis

Você chegou ao fim com artefatos, não com anotações. Junte tudo num lugar só — é isso que transforma dois dias de workshop em mudança permanente de prática.

📦 O que você leva

✓ Modelo de especificação (T1)
✓ AGENTS.md com permissões e limites (T2)
✓ Modelo de loop com três saídas (T2)
✓ Prompt de investigação de falha de CI (T3)
✓ Prompt de revisão independente (T3)
✓ Checklist de quality gates (T3)
✓ Roteiro de modernização de legado (T4)
✓ Auditoria de legibilidade do repositório (T4)
✓ Caçada à duplicação semântica (T4)
✓ Playbooks: feature, bug, legado, incidente (T5)
✓ Esqueleto de skill e conjunto base de rules (T5)
✓ Checklist de governança de uma página (T5)

💡 Última dica prática

Não tente instalar os doze artefatos no time de uma vez. Comece por dois: o AGENTS.md e o prompt de revisão independente. São os que dão resultado visível na primeira semana — e resultado visível é o que compra espaço para os outros dez.

Artefato

Não anotação

Versionado

No repositório

Comece com 2

Não com doze

Resultado

Compra espaço

🏁 Fim do curso

A engenharia de software com IA não elimina a engenharia tradicional — ela aumenta a importância dos fundamentos. Modelos e ferramentas vão mudar rápido. O conhecimento durável está em saber especificar, estruturar contexto, criar harnesses, desenhar loops, automatizar, testar, revisar, controlar arquitetura, limitar autonomia, modernizar com segurança, aplicar governança e transformar regras em verificações executáveis.

O profissional mais valioso não será apenas aquele que sabe pedir código à IA. Será aquele que sabe construir o sistema no qual a IA pode trabalhar com segurança, qualidade, velocidade e controle.

Você executou o fluxo inteiro - spec, harness, loop, implementação, gates, revisão e entrega.
Com evidência - e um registro que mede a sua própria prática.
Com um kit - doze artefatos prontos para o repositório do seu time.