skills.rest
NeverSight
NeverSightOFFICIAL
Explore all skills by this author →
Website𝕏@neversightaiGitHub

tdd

Write integration-style tests for public interfaces to drive red-green-refactor cycles.

69|11|Updated May 16, 2026
Search Tags:#tdd#integration testing#test-driven development#red-green-refactor#behavior testing#mocking guidelines
One-click install
npx skills add https://github.com/NeverSight/NeverC --skill tdd-neversight
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/NeverSight/NeverC/tree/main/.agents/skills/tdd
Command: npx skills add https://github.com/NeverSight/NeverC --skill tdd-neversight

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you avoid fragile, implementation-coupled tests by teaching you to verify behavior through public interfaces while driving development with a disciplined red-green-refactor loop.

Core Features & Use Cases

  • Behavior-first integration testing: Write tests that describe observable capabilities and survive internal refactors.
  • Vertical slice workflow (tracer bullets): Implement the minimal code needed to make each new test pass, one behavior at a time.
  • Test quality guardrails: Identify and prevent common anti-patterns like horizontal slicing and over-mocking internals.
  • Refactor safely after green: Extract duplication and deepen modules only after the full suite is passing.

Quick Start

Start a loop by writing a single integration-style test for one public behavior, make it pass with the smallest possible implementation, and repeat for the next behavior before refactoring.

Frequently Asked Questions about tdd

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

FAQPage Schema
What is test-driven development and how does the red-green-refactor cycle work?▼

Test-driven development drives feature design by writing failing integration tests for public behavior, implementing minimal code to pass them, and refactoring only after the suite reaches a fully green state.

How do I write integration tests that verify behavior without coupling to internal implementation?▼

To write behavior-focused integration tests, target observable capabilities through public interfaces and avoid over-mocking internals, ensuring your tests survive internal refactors and prevent horizontal slicing anti-patterns.

How do I start building a new feature using a tracer bullet vertical slice workflow?▼

Start the tracer bullet workflow by writing a single integration-style test for one public behavior, implement the smallest possible code to make it pass, and repeat for the next behavior before refactoring.

When should I refactor code during the test-driven development cycle?▼

Refactor code only after reaching a fully green test suite, extracting duplication and deepening modules at that point to ensure the behavior validated by your integration tests remains intact.

What are common test-driven development anti-patterns and how can I prevent fragile tests?▼

Common TDD anti-patterns include horizontal slicing and over-mocking internals; prevent fragile tests by applying behavior-first design and using vertical slice iteration to validate public interfaces incrementally.

Do I need mocking guidelines to fix bugs with test-driven development?▼

Mocking guidelines help fix bugs with TDD by restricting mocks to avoid over-mocking internals, ensuring your integration tests validate actual behavior through public interfaces rather than implementation details.

Related Skills

Explore More Software Engineering Skills→
mia-cxmia-cx

tdd

Guide developers through red-green-refactor loops for features and bug fixes.

Official
Intermediate
mycelium-iomycelium-io
112

tdd

Execute test-driven development workflows through red-green-refactor cycles.

Official
Intermediate
brujackbrujack
5

tdd

Guide red-green-refactor cycles with integration-style tests through public interfaces.

Community
Intermediate
tae0ytae0y
14

testing

Verify behavior through public APIs in unit and integration tests.

Community
Intermediate