@tank/tdd-workflow

Guide developers through the RED-GREEN-REFACTOR cycle and TDD workflows.

1|1|Updated Feb 20, 2026
One-click install
npx skills add https://github.com/tankpkg/skills --skill tank-tdd-workflow
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: @tank/tdd-workflow
Source: https://github.com/tankpkg/skills/tree/main/skills/tdd-workflow
Command: npx skills add https://github.com/tankpkg/skills --skill tank-tdd-workflow

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a comprehensive guide to Test-Driven Development (TDD), enabling developers to write higher-quality code more efficiently by focusing on testing first.

Core Features & Use Cases

  • TDD Cycle Mastery: Understand and apply the RED-GREEN-REFACTOR loop.
  • Best Practices: Learn the three laws of TDD, AAA pattern, and common anti-patterns.
  • Use Case: A developer starting a new feature can use this Skill to ensure they are writing tests before implementation, leading to robust and maintainable code from the outset.

Quick Start

Review the TDD cycle and its core principles to begin applying test-first development.

Frequently Asked Questions about @tank/tdd-workflow

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is the test-driven development cycle and how does red green refactor work?

Test-driven development uses the red green refactor cycle: write a failing test, write code to make it pass, then refactor. This enforces the three laws of TDD and test-first patterns to produce maintainable software.

How do I use test doubles like mocks, stubs, and spies in unit testing?

Test doubles such as mocks, stubs, and spies isolate code behavior during unit testing. Using them correctly within the AAA pattern prevents common testing anti-patterns and ensures your test suite validates logic rather than implementations.

What is the difference between the test pyramid, property-based testing, and mutation testing?

The test pyramid balances unit and integration test proportions, property-based testing generates varied inputs to find edge cases, and mutation testing evaluates test suite effectiveness by mutating code to check if tests fail.

How do I start writing tests before implementation for a new feature?

Start new feature development using a test-first workflow: define requirements via a failing test, implement minimal code to pass it, and refactor safely. This ensures robust code from the outset by validating logic before implementation.

When should I not use a test-first development approach?

Avoid test-first development when exploring unfamiliar prototypes where rapid feedback matters more than test coverage, or when writing trivial code where forcing failing tests adds unnecessary overhead without improving software quality.