Test-Driven Development com red-green-refactor enforced. Trigger em: "tdd", "test-first", "red-green-refactor", "tracer bullet", "behavior test", "integration test", "tdd deep module", "interface design test".
71%
Does it follow best practices?
Run evals on this skill
Adds up to 20 points to the overall score
Low
Low-risk findings worth noting
Fix and improve this skill with Tessl
tessl review fix ./skills/37-tdd-engineer/SKILL.mdSkill que forca o ciclo TDD correto: 1 teste → 1 implementacao → repete. Combate o anti-padrao "escrevo 5 testes, depois 5 implementacoes" — que produz testes ruins (testam shape, nao behavior).
Adaptado de mattpocock/skills/engineering/tdd e integrado ao kit (skill 05 QA + policies/vertical-slices.md).
Esta skill segue GLOBAL.md, policies/execution.md, policies/quality-gates.md, policies/vertical-slices.md, policies/source-driven.md, policies/writing-clarity.md e policies/verification-before-completion.md (cada passo red→green→refactor exige output verificável da mudança de estado).
Tests should verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't.
Bom teste e integration-style: exercita codigo real atraves de API publica. Descreve o que o sistema faz, nao como. Le como spec — "user can checkout with valid cart" diz exatamente que capacidade existe. Sobrevive a refactor.
Para saídas complexas e determinísticas, compare a execução com um resultado esperado validado semanticamente. Separe candidato gerado de fixture aprovada; nunca autoaprove o output do próprio código como oráculo. Falta de fixture é setup, não RED comportamental. Use somente quando acrescentar evidência útil.
Fluxo, ferramentas e referências preservadas em docs/skill-guides/tdd-approved-fixtures.md, carregado sob demanda. A skill 05 complementa com mutação e integração.
Mau teste acopla a implementação: substitui a lógica que deveria exercitar ou inspeciona detalhes privados sem relação com o contrato. Quebrar apenas por renomear uma função interna é sinal desse acoplamento. Verificar o estado persistido pode ser necessário para provar uma invariante de integração; escolha a observação conforme a propriedade testada.
CONTEXT.md ou docs/glossary.md)docs/adr/)tests/ ou __tests__/ (path conforme convencao do projeto)NAO escrever todos os testes primeiro, depois toda a implementacao. Isso e horizontal slicing — tratar RED como "escrever todos os testes" e GREEN como "escrever todo o codigo".
Produz testes ruins:
ERRADO (horizontal):
RED: test1, test2, test3, test4, test5
GREEN: impl1, impl2, impl3, impl4, impl5
CERTO (vertical):
RED→GREEN: test1→impl1
RED→GREEN: test2→impl2
RED→GREEN: test3→impl3
...Esta diretriz ecoa policies/vertical-slices.md — fatia vertical, nao horizontal.
Ao explorar codebase, usar glossario de dominio do projeto para que nomes de teste e vocabulario de interface batam com a linguagem do projeto. Respeitar ADRs na area tocada.
Antes de escrever qualquer codigo:
Pergunta-chave: "Como deve ser a interface publica? Quais comportamentos sao mais importantes testar?"
Voce nao pode testar tudo. Confirmar com usuario quais comportamentos importam mais. Foco em paths criticos e logica complexa, nao todo edge case possivel.
Escrever UM teste que confirma UMA coisa sobre o sistema:
RED: Escrever teste para o primeiro comportamento → teste falha
GREEN: Escrever codigo minimo para passar → teste passaObserve a falha esperada antes da implementação: ela precisa demonstrar o comportamento ausente. Erro de import, ambiente, timeout ou fixture inexistente não é essa demonstração. Em legado, caracterize o contrato atual antes de alterar a estrutura. Quando um teste honesto for impraticável, explique o motivo e escolha outra verificação adequada; não escreva um teste artificial só para produzir vermelho.
Esse é o tracer bullet — primeira evidência do comportamento no nível testado. Só descreva o caminho como end-to-end quando a execução realmente atravessar as integrações correspondentes.
Para cada comportamento restante:
RED: Escrever proximo teste → falha
GREEN: Codigo minimo para passar → passaRegras:
Apos todos os testes passarem, procurar oportunidades de refactor:
Nunca refactore enquanto RED. Chegue ao GREEN primeiro.
Se um refactor quebrar um teste que passava: investigue regressão, alteração autorizada de contrato, teste acoplado à implementação ou falha de ambiente. Corrija ou reverta uma regressão; ajuste um teste acoplado somente com evidência de que o contrato foi preservado. Não atualize expectativas apenas para obter verde. Uma mudança deliberada da interface pública exige testes e consumidores compatíveis com o contrato novo.
Para contratos de domínio, parsing nas fronteiras, repetição de efeitos e uso contextual de métricas, consulte docs/skill-guides/architecture-and-evidence.md. Teste a interface pública e o mecanismo real quando a propriedade depender de banco, fila ou concorrência.
[ ] Teste descreve comportamento, nao implementacao
[ ] Teste usa apenas interface publica
[ ] Teste sobreviveria a refactor interno
[ ] Codigo e minimo para esse teste
[ ] Nenhuma feature especulativa adicionadaPensamentos que indicam STOP — voce esta racionalizando:
| Pensamento | Realidade |
|---|---|
| "Vou escrever os 5 testes agora porque ja sei o que precisa" | Horizontal slicing. Volte ao tracer bullet. |
| "Esse teste vai precisar de mock do DB pra rodar" | Provavelmente esta testando implementacao. Reescreva pra usar interface publica. |
| "Adicionar funcionalidade extra agora porque ja estou aqui" | Nao antecipe. Codigo minimo para o teste atual. |
| "Refactor enquanto vermelho — vai ficar mais limpo" | Nao. GREEN primeiro, refactor depois. |
| "O teste passou na primeira tentativa, sem ter visto vermelho" | Voce pode estar testando algo que ja existia. Garanta que o teste falha sem o codigo novo. |
| "Vou testar metodo privado pra cobrir tudo" | Metodo privado nao e contrato. Teste comportamento via interface publica. |
| "Vou querer esse teste depois entao escrevo agora" | Especulativo. Escreva quando precisar. |
| "Esse cenario e improvavel" | Se e improvavel, nao teste. Se e critico, escreva o teste agora. |
| "Vou pular TDD nesta feature porque e simples" | "Simples" muitas vezes vira complexo. Comece TDD, abandone se ficar obvio que nao agrega. |
Coordenar com skill 38 (Architecture Deepener) para identificar modulos shallow que merecem deepening antes de escrever teste.
TDD opera dentro de uma vertical slice. Sequencia:
/to-issues quebra feature em vertical slicesNAO tentar TDD cross-slice — comportamento de slice X nao deve depender de teste de slice Y.
Apos conclusao:
/build: pode ativar TDD se task descrita como "TDD" ou "test-first"TDD não é uma técnica isolada: é o núcleo técnico do eXtreme Programming, e o livro eXtreme Programming — práticas para o dia a dia (Casa do Código) é enfático em que as práticas só funcionam em sinergia — "muitas vezes uma prática só funciona porque depende das outras". Esta skill cobre o red-green-refactor; o resto do XP é processo compartilhado e vive nas policies:
policies/pair-programming.md. Revezar piloto/copiloto por ciclo de TDD (um escreve o RED, o outro faz o GREEN e refatora) é a forma canônica de parear no kit.policies/continuous-integration.md. O GREEN só "conta" quando o build verde integra no trunk — "não quebre o build" é o análogo XP do verification-before-completion.policies/sustainable-pace.md. Não pular testes para "agilizar": defeito vira retrabalho que quebra o ritmo das próximas iterações.policies/vertical-slices.md + policies/boil-the-lake.md + Senior Dev Override do GLOBAL.md. O "código mínimo para passar o teste atual" da Fase 3 desta skill é YAGNI aplicado ao ciclo.Se for adotar XP num projeto, o livro recomenda começar pelo teste automatizado ("se tiver que escolher uma prática para começar, escolha o teste automatizado") — ou seja, por esta skill — e ir incorporando as policies acima.
Para deep dives consultar:
docs/skill-guides/tdd-deep-modules.md (a criar conforme demanda) — adaptacao de tdd/deep-modules.mddocs/skill-guides/tdd-interface-design.md — interface design para testabilidadedocs/skill-guides/tdd-mocking.md — quando mockar (raramente) e comodocs/skill-guides/tdd-refactoring.md — refactor checklist apos GREENfelvieira/claude-skills-fv
b0cbfa3
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.