tdd

Enforce a test-driven development workflow with 80% Vitest coverage.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill enforces a strict Test-Driven Development (TDD) workflow, ensuring code is written with comprehensive test coverage from the outset, preventing bugs and improving maintainability.

Core Features & Use Cases

  • RED → GREEN → REFACTOR Cycle: Guides the developer through writing failing tests first, then implementing minimal code to pass, followed by refactoring.
  • Interface Scaffolding: Helps define clear input/output types before implementation.
  • Test Case Generation: Provides a structured approach to writing all necessary test cases upfront.
  • Coverage Enforcement: Ensures a minimum of 80% Vitest coverage, with higher requirements for critical code.
  • Use Case: When developing a new API endpoint, use this Skill to ensure all success, error, and edge cases are covered by tests before any implementation code is written.

Quick Start

Use the tdd skill to implement the new codebase-map tool, ensuring all tests are written first.

Frequently Asked Questions about tdd

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

FAQPage Schema
How do I enforce a test-driven development workflow using Vitest?

To enforce a test-driven development workflow with Vitest, follow the RED-GREEN-REFACTOR cycle: write failing tests first, implement minimal code to pass, then refactor. This ensures robust code with a minimum of 80% test coverage for all new code.

What is the RED-GREEN-REFACTOR cycle in test-driven development?

The RED-GREEN-REFACTOR cycle in test-driven development is a process where you write a failing test first, implement the minimal code required to make it pass, and then refactor the code for maintainability. This Skill scaffolds interfaces and generates test cases to guide you through each phase.

How do I ensure 80% code coverage when writing tests for a new API endpoint?

To ensure 80% code coverage for a new API endpoint, use this Skill to define clear input and output types upfront, generate all necessary success, error, and edge case tests before implementation, and enforce a strict minimum of 80% Vitest coverage on the resulting code.

Can I scaffold interfaces and write failing tests before implementing the code?

Yes, you can scaffold interfaces and write failing tests before implementation. This Skill helps define clear input and output types first, provides a structured approach to writing all necessary test cases upfront, and ensures minimal code is written subsequently to pass those tests.

Does this test-driven development approach support testing quality analyzers and tool registry integrations?

Yes, this test-driven development approach supports testing quality analyzers and tool registry integrations. It enforces a strict TDD workflow with interface scaffolding and test case generation, ensuring comprehensive Vitest coverage for these specific integrations and critical code paths.