tdd

Enforce a tests-first workflow with red-green-refactor cycles.

103|9|Updated Jan 3, 2026
One-click install
npx skills add https://github.com/smartfrog/opencode-froggy --skill tdd-smartfrog
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/smartfrog/opencode-froggy/tree/main/skill/tdd
Command: npx skills add https://github.com/smartfrog/opencode-froggy --skill tdd-smartfrog

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Test-Driven Development enforces a tests-first mindset to ensure requirements are validated, regressions are caught early, and code remains observable and verifiable.

Core Features & Use Cases

  • Red-Green-Refactor workflow guiding development from failing tests to passing implementations.
  • Mandatory tests accompany every feature or bug fix to guarantee correct behavior.
  • Supports unit, integration, and end-to-end testing with emphasis on black-box verification and readability.

Quick Start

Run a failing test first, then implement the minimal code to pass.

Frequently Asked Questions about tdd

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

FAQPage Schema
How do I enforce a tests-first workflow for feature development?

Test-Driven Development requires writing a failing test before implementing minimal code to pass. This Red-Green-Refactor cycle validates requirements, maintains deterministic behavior, and catches regressions early across unit, integration, and end-to-end contexts.

What is the Red-Green-Refactor cycle in unit testing?

The Red-Green-Refactor cycle is a testing workflow where you write a failing test, implement minimal code to pass it, then refactor. It maintains black-box verification and ensures observable behavior remains deterministic throughout development.

Can I use test-driven development for both bugfix cycles and new features?

Yes, test-driven development applies to both bugfix cycles and feature development. It mandates writing failing tests to reproduce bugs or define features first, guaranteeing correct behavior and preventing regressions across unit, integration, and end-to-end testing.

Does test-driven development support integration and end-to-end testing?

Test-driven development supports integration and end-to-end testing. It emphasizes black-box verification and readability across all testing contexts, ensuring requirements are validated and code remains observable and verifiable at multiple levels.

Why should I write failing tests before writing implementation code?

Writing failing tests before code enforces a tests-first mindset that ensures requirements are validated and regressions are caught early. It maintains deterministic observable behavior and guarantees tests accompany every feature or bug fix.