skills.rest
escoffier-labs
escoffier-labsOFFICIAL
Explore all skills by this author →
WebsiteGitHub

taste

Enforces red-green-refactor workflow requiring a minimal failing test before implementation code.

65|5|Updated May 13, 2026
Search Tags:#code quality#tdd#bug prevention#software development#regression testing#test-first development#production reliability
One-click install
npx skills add https://github.com/escoffier-labs/brigade --skill taste-escoffier-labs
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: taste
Source: https://github.com/escoffier-labs/brigade/tree/main/registry/skills/taste
Command: npx skills add https://github.com/escoffier-labs/brigade --skill taste-escoffier-labs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Developers often skip writing tests first, especially under pressure like production outages or tight deadlines, leading to untested code that breaks in production, or tests that only confirm existing behavior instead of defining expected requirements.

Core Features & Use Cases

  • Enforces the strict red-green-refactor test-first loop for all code changes including features, bugfixes, refactors, and behavior modifications.
  • Provides clear guardrails against common rationalizations for skipping tests, even when users urge speed over process.
  • Use case: When fixing a critical production bug, this skill ensures you write a failing test that reproduces the bug first, so you can verify the fix actually resolves the issue without introducing new regressions.

Quick Start

Use the taste skill to write a failing test that reproduces the current production bug before writing any implementation code for the fix.

Frequently Asked Questions about taste

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

FAQPage Schema
How do I enforce test-first development during a critical production incident?▼

Test-first development requires writing a minimal failing test that reproduces the bug before writing any fix code. This ensures the implementation actually resolves the issue without introducing new regressions under pressure.

What is the red-green-refactor loop for bug prevention?▼

The red-green-refactor loop is a test-first development practice where you write a failing test, implement minimal code to pass it, and refactor only when the test suite is fully green. It prevents shipping untested, broken code to production.

Why does writing tests after implementation fail to prevent production bugs?▼

Tests written after implementation often confirm existing behavior rather than defining expected requirements. Test-first development forces you to specify desired behavior upfront, preventing code that breaks in production from passing retrospective tests.

How do I stop skipping tests when fixing bugs under tight deadlines?▼

To stop skipping tests under tight deadlines, apply strict test-first guardrails that require a minimal failing test reproducing the bug before any implementation code. This prevents rationalizations for speed over process from introducing regressions.

Does test-first development apply to refactoring and behavior modifications?▼

Test-first development applies to all code changes including feature implementation, bug fixes, refactoring, and behavior modifications. It requires a fully green test suite before any refactoring occurs to ensure production reliability.

Related Skills

Explore More Software Engineering Skills→
japurcelljapurcell

addy-test-driven-development

Write failing tests, implement minimal code, and refactor for clarity.

Community
Advanced
kaynetikkaynetik
1

tdd-red-green-refactor

Write failing tests before production code to drive minimal fixes.

Community
Intermediate
meiiiemeiiie
4

test-driven-development

Enforce test-first development with RED-GREEN-REFACTOR for existing test runners.

Community
Intermediate
Chang-Shih-YungChang-Shih-Yung

health

Aggregate type checker, linter, and test results into a 0-10 composite score.

Community
Advanced