tdd-contract

Name: tdd-contract
Availability: InStock
Author: wolvesfield

Enforce Test-Driven Development protocols for code reviews and implementation tasks.

Updated Aug 27, 2026

Search Tags:#testing #tdd #development #quality assurance #code review #refactoring

Ready to run

npx skills add https://github.com/wolvesfield/CIPHER-MCP --skill tdd-contract

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: tdd-contract
Source: https://github.com/wolvesfield/CIPHER-MCP/tree/main/core/skills/tdd-contract
Command: npx skills add https://github.com/wolvesfield/CIPHER-MCP --skill tdd-contract

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill ensures that all implementation work adheres to the principles of Test-Driven Development (TDD), preventing common pitfalls and guaranteeing code quality and reliability.

Core Features & Use Cases

TDD Protocol Enforcement: Guides developers through the Red-Green-Refactor cycle.
Gate Procedure: Implements a strict TDD gate for code reviews and deliverable validation.
Iron Laws: Defines non-negotiable rules for effective TDD, such as testing behavior over mocks.
Use Case: When an Implementer submits code, Fleet uses this skill to verify that tests were written first, that they fail before implementation, and that they test actual behavior, not mocks.

Quick Start

Use the tdd-contract skill to validate TDD compliance for a new code module.

Frequently Asked Questions about tdd-contract

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

FAQPage Schema

How do I enforce Test-Driven Development protocols during code reviews?▼

Test-Driven Development protocols are enforced by applying a strict gate procedure to code reviews, verifying that tests were written first and fail before implementation begins. This validates deliverable compliance.

What is the Red-Green-Refactor cycle and how does it guide implementation?▼

The Red-Green-Refactor cycle guides implementation by first writing failing tests, writing code to make them pass, and then refactoring. This ensures behavior-focused development and reliable code quality.

How do I validate that tests focus on behavior instead of mocks?▼

Validate behavior over mocks by applying non-negotiable Iron Laws during deliverable validation, ensuring tests check actual behavior rather than relying on mock implementations for coverage.

Can I use TDD compliance checks for new code modules without external dependencies?▼

Yes, TDD compliance checks apply directly to new code modules without requiring external dependencies, enforcing the Red-Green-Refactor cycle and adherence to coverage thresholds.

Why does TDD require tests to fail before implementation is written?▼

TDD requires tests to fail before implementation to guarantee the test actually validates the new behavior, preventing false positives and ensuring robust code quality.

What's the best way to guarantee code quality and reliability during refactoring?▼

Guarantee code quality during refactoring by enforcing Test-Driven Development protocols, ensuring tests are written first, focus on behavior, and meet coverage thresholds before deliverable validation.