Communitygithub.com

Lev-it/lev-skills (Desenvolvimento Orientado por Testes)

Desenvolvimento orientado por testes (TDD). Use quando o usuário quiser construir funcionalidades ou corrigir bugs usando testes primeiro, mencionar 'red-green-refactor', ou quiser testes de integração.

O que é lev-skills (Desenvolvimento Orientado por Testes)?

Este skill implementa uma abordagem disciplinada de Desenvolvimento Orientado por Testes (TDD) para agentes de IA como Claude Code, Cursor ou Codex. Ele orienta o agente a escrever testes que verificam o comportamento do sistema através de interfaces públicas (testes em estilo de integração), evitando acoplamento a detalhes de implementação. O skill enfatiza ciclos verticais (um teste → um trecho de implementação por vez), em oposição a 'fatias horizontais' (escrever todos os testes primeiro). O fluxo de trabalho inclui planejamento com o usuário (confirmando interface e comportamentos prioritários), uso de 'balas traçadoras' para validar o caminho, loops incrementais e refatoração após todos os testes passarem. Ele também recomenda verificar arquivos de contexto como `CONTEXT.md` e respeitar decisões de arquitetura (ADRs). É ideal para cenários onde o usuário explicitamente pede TDD, menciona 'red-green-refactor', ou quer testes de integração robustos.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Lev-it/lev-skills/tree/HEAD/.claude/skills/tdd

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Desenvolvimento Orientado por Testes

Filosofia

Princípio central: Testes devem verificar comportamento através de interfaces públicas, não detalhes de implementação. O código pode mudar completamente; os testes não deveriam.

Testes bons são no estilo integração: eles exercitam caminhos reais de código através de APIs públicas. Eles descrevem o que o sistema faz, não como faz. Um bom teste lê como uma especificação — "usuário pode finalizar compra com carrinho válido" diz exatamente qual capacidade existe. Esses testes sobrevivem a refatorações porque não se importam com a estrutura interna.

Testes ruins estão acoplados à implementação. Eles simulam colaboradores internos, testam métodos privados ou verificam através de meios externos (como consultar um banco de dados diretamente em vez de usar a interface). O sinal de alerta: seu teste quebra quando você refatora, mas o comportamento não mudou. Se você renomear uma função interna e os testes falharem, esses testes estavam testando implementação, não comportamento.

Veja tests.md para exemplos e mocking.md para diretrizes de simulação.

Anti-Padrão: Fatias Horizontais

NÃO escreva todos os testes primeiro e depois toda a implementação. Isso é "fatiamento horizontal" — tratar VERMELHO como "escrever todos os testes" e VERDE como "escrever todo o código."

Isso produz testes ruins:

  • Testes escritos em lote testam comportamento imaginado, não real
  • Você acaba testando a forma das coisas (estruturas de dados, assinaturas de funções) em vez do comportamento voltado ao usuário
  • Os testes se tornam insensíveis a mudanças reais — passam quando o comportamento quebra, falham quando o comportamento está correto
  • Você ultrapassa seus faróis, comprometendo-se com a estrutura do teste antes de entender a implementação

Abordagem correta: Fatias verticais via balas traçadoras. Um teste → uma implementação → repita. Cada teste responde ao que você aprendeu no ciclo anterior. Como você acabou de escrever o código, sabe exatamente qual comportamento importa e como verificá-lo.

ERRADO (horizontal):
  VERMELHO:   test1, test2, test3, test4, test5
  VERDE: impl1, impl2, impl3, impl4, impl5

CERTO (vertical):
  VERMELHO→VERDE: test1→impl1
  VERMELHO→VERDE: test2→impl2
  VERMELHO→VERDE: test3→impl3
  ...

Fluxo de Trabalho

1. Planejamento

Ao explorar a base de código, leia CONTEXT.md (se existir) para que os nomes dos testes e o vocabulário da interface correspondam à linguagem de domínio do projeto, e respeite os ADRs na área que você está mexendo.

Antes de escrever qualquer código:

  • Confirmar com o usuário quais mudanças de interface são necessárias
  • Confirmar com o usuário quais comportamentos testar (priorizar)
  • Identificar oportunidades para módulos profundos (interface pequena, implementação profunda) — execute o skill /codebase-design para o vocabulário e as verificações de testabilidade
  • Listar os comportamentos a testar (não etapas de implementação)
  • Obter aprovação do usuário sobre o plano

Pergunte: "Qual deve ser a aparência da interface pública? Quais comportamentos são mais importantes de testar?"

Você não pode testar tudo. Confirme com o usuário exatamente quais comportamentos são mais importantes. Concentre o esforço de teste em caminhos críticos e lógica complexa, não em todos os casos de borda possíveis.

2. Bala Traçadora

Escreva UM teste que confirme UMA coisa sobre o sistema:

VERMELHO:   Escrever teste para o primeiro comportamento → teste falha
VERDE: Escrever código mínimo para passar → teste passa

Esta é sua bala traçadora — prova que o caminho funciona ponta a ponta.

3. Loop Incremental

Para cada comportamento restante:

VERMELHO:   Escrever próximo teste → falha
VERDE: Código mínimo para passar → passa

Regras:

  • Um teste de cada vez
  • Apenas código suficiente para passar no teste atual
  • Não antecipar testes futuros
  • Manter os testes focados em comportamento observável

4. Refatorar

Depois que todos os testes passarem, procure candidatos a refatoração:

  • Extrair duplicação
  • Aprofundar módulos (mover complexidade para trás de interfaces simples)
  • Aplicar princípios SOLID onde for natural
  • Considerar o que o novo código revela sobre o código existente
  • Executar testes após cada etapa de refatoração

Nunca refatore enquanto estiver VERMELHO. Chegue ao VERDE primeiro.

Checklist Por Ciclo

[ ] Teste descreve comportamento, não implementação
[ ] Teste usa apenas interface pública
[ ] Teste sobreviveria a uma refatoração interna
[ ] Código é mínimo para este teste
[ ] Nenhuma funcionalidade especulativa adicionada

Individual skills in this repo

This repo contains 11 individual skills — each has its own dedicated page.

Lev-it/lev-skills

Ask which skill or flow fits your situation. A router over the user-invoked skills in this repo.

Lev-it/lev-skills

Premium brand-kit image generation skill for creating high-end brand-guidelines boards, logo systems, identity decks, and visual-world presentations. Trained for minimalist, cinematic, editorial, dark-tech, luxury, cultural, security, gaming, developer-tool, and consumer-app brand systems. Optimized for intentional logo concepting, refined composition, sparse typography, strong symbolic meaning, premium mockups, art-directed imagery, and flexible grid layouts.

Lev-it/lev-skills

Compact the current conversation into a handoff document for another agent to pick up.

Lev-it/lev-skills

Ink terminal renderer for json-render that turns JSON specs into interactive terminal UIs. Use when working with @json-render/ink, building terminal UIs from JSON, creating terminal component catalogs, or rendering AI-generated specs in the terminal.

Lev-it/lev-skills

Interactive QA session where user reports bugs or issues conversationally, and the agent files GitHub issues. Explores the codebase in the background for context and domain language. Use when user wants to report bugs, do QA, file issues conversationally, or mentions "QA session".

Lev-it/lev-skills

Facilitate a structured sprint retrospective — what went well, what didn't, and prioritized action items with owners and deadlines. Use when running a retrospective, reflecting on a sprint, creating action items from team feedback, or learning how to run effective retros.

Lev-it/lev-skills

Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes — Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/PRD asked for?). Runs both reviews in parallel sub-agents and reports them side by side. Use when the user wants to review a branch, a PR, work-in-progress changes, or asks to "review since X".

Lev-it/lev-skills

Teach the user a new skill or concept, within this workspace.

Lev-it/lev-skills

Turn the current conversation into a PRD and publish it to the project issue tracker — no interview, just synthesis of what you've already discussed.

Lev-it/lev-skills

Move issues through a state machine of triage roles — categorise, reproduce, grill if needed, and write agent-ready briefs.

Lev-it/lev-skills

Create product backlog items in Why-What-Acceptance format — independent, valuable, testable items with strategic context. Use when writing structured backlog items, breaking features into work items, or using the WWA format.

Habilidades Relacionadas