tdd-process_skill

Overview

⚪ TDD: PLANNING This skill enforces a strict test-driven development state machine with red-green-refactor cycles for Python projects. It guides test-first development, ensures meaningful failures, requires minimum implementations, and verifies compilation and linting before advancing. Use it to adopt disciplined TDD workflows and generate repeatable, verifiable cycles.

How this skill works

⚪ TDD: PLANNING The skill defines the TDD lifecycle: PLANNING (write failing test), RED (implement the minimal fix), GREEN (verify tests pass), REFACTOR (improve design while keeping green), and VERIFY (run full suite, lint, and build). It inspects test intent, produces test specifications (not full production code), and mandates evidence at each transition: test outputs, compile and lint results, and justifications for minimal changes.

When to use it

• When you want to adopt strict test-first development for a new feature
• When converting legacy code to small, testable increments
• When teaching or enforcing disciplined TDD practices in a team
• For small-to-medium Python tasks where iterative verification is valuable
• When you need reproducible evidence of test-driven progress

Best practices

• Always write tests before implementation; tests should express behavior, not design
• Make failures meaningful: adjust tests or helpers until the failure pinpoints the behavior
• Implement only what the failing test demands — prefer hardcoded stubs for single-case failures
• Run tests, compilation, and lint on every small change and show outputs as evidence
• Keep planning outputs as test specifications; avoid sharing production implementation in plan mode

Example use cases

• Start TDD for a new function: plan tests, run to get red, implement minimal code, then refactor
• Enforce classroom TDD exercises: students submit cycles with test outputs and justifications
• Migrate a bug fix into a TDD cycle to produce a focused regression test before fixing
• Create bite-sized features in Python modules with proof-of-correctness at each step
• Validate library API contracts via failing tests, then implement minimal surface to satisfy them