tdd-enforcement

Guide behavior-driven test design to enforce test-first development workflows.

12|1|Updated Jun 4, 2013
One-click install
npx skills add https://github.com/bostonaholic/dotfiles --skill tdd-enforcement-bostonaholic
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-enforcement
Source: https://github.com/bostonaholic/dotfiles/tree/main/claude/skills/tdd-enforcement
Command: npx skills add https://github.com/bostonaholic/dotfiles --skill tdd-enforcement-bostonaholic

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill ensures teams practice genuine Test-Driven Development by requiring tests to be written before implementation, shaping design through testability, and catching edge cases early.

Core Features & Use Cases

  • Test-first workflow: Define behavior and tests before coding to align on expected outcomes.
  • Architectural alignment: Encourages the FCIS pattern to separate decisions from effects, improving testability.
  • Edge-case coverage: Systematically identify and test critical failure modes during the early stages of development.
  • Refactor safety: Maintains readable, deterministic tests that guide safe refactoring across features, bugs, and migrations.
  • Use Case: When introducing a new feature or performing a refactor that could impact core logic, this skill ensures tests drive the implementation and guard against regressions.

Quick Start

Clarify the desired behavior, then write a failing test and implement the minimal code to make it pass.

Frequently Asked Questions about tdd-enforcement

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

FAQPage Schema
How do I enforce strict test-first development in my software engineering workflow?

This skill enforces genuine test-first development by requiring you to define expected behavior and write failing tests before implementation, ensuring edge cases are captured early and tests guide architecture.

What is the best way to write tests that guide software architecture during a refactor?

The best way to guide architecture during a refactor is to maintain readable, deterministic tests that apply the FCIS pattern, separating decisions from effects to improve testability and guard against regressions.

How do I systematically identify and test edge cases when developing new features?

You systematically identify edge cases by defining the desired behavior upfront and writing failing tests early in development, which catches critical failure modes before implementation begins.

Can I use this TDD workflow for both bug fixes and new feature development?

Yes, you can use this TDD workflow across feature development, bug fixes, and refactors. It applies the define behavior, write failing tests, implement, and refactor cycle to ensure stable, readable tests.

Does test-driven development work without external testing frameworks or dependencies?

Yes, this test-driven development skill operates with no external dependencies, focusing on the core TDD process of defining behavior, writing failing tests, implementing minimal code, and refactoring.

When should I not use a strict test-first approach for writing tests?

You should avoid a strict test-first approach when you cannot clearly define the desired behavior upfront, as the process relies on writing failing tests to drive implementation and guide architectural decisions.