skills.rest
wolvesfield
wolvesfieldOFFICIAL
Explore all skills by this author →
GitHub

tdd-contract

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
One-click install
npx skills add https://github.com/wolvesfield/CIPHER-MCP --skill tdd-contract
Or copy as Structured Prompt for Agent▼
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.

Related Skills

Explore More Software Engineering Skills→
ReinaMacCredyReinaMacCredy
223

test-driven-development

Enforce the Red-Green-Refactor cycle with failing tests before implementation.

Community
Intermediate
robit-manrobit-man

qa-protocol

Implements a multi-stage QA protocol for marketing assets across channels and generates approval reports.

Community
Advanced
ai-enhanced-engineerai-enhanced-engineer
3

unit-test-standards

Enforce Python unit test naming conventions and 80% coverage thresholds.

Official
Intermediate
cipherstashcipherstash
17

testing-anti-patterns

Detect testing anti-patterns that verify mocks instead of real behavior.

Community
Basic