refine-requirements

Capture developer-discovered edge cases and generate updated BR-*, C-*, and F-* requirements.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/foolishimp/ai_sdlc_method --skill refine-requirements
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: refine-requirements
Source: https://github.com/foolishimp/ai_sdlc_method/tree/main/plugins/requirements-skills/skills/refine-requirements
Command: npx skills add https://github.com/foolishimp/ai_sdlc_method --skill refine-requirements

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Requirements are rarely perfect upfront; developers often discover edge cases or missing business rules during implementation, which need to be fed back into the requirements.

Core Features & Use Cases

  • Requirements Refinement Loop: Captures discoveries (edge cases, race conditions, missing rules) made during TDD/BDD implementation.
  • Automated Documentation Update: Updates requirement documents with new BR-, C-, or F-* specifications, including discovery metadata.
  • Knowledge Capture: Ensures developer insights become permanent, preventing re-discovery by future teams.
  • Use Case: During the GREEN phase of TDD, a developer discovers a race condition for user registration. This skill documents the new business rule (BR-015), updates the requirement, adds a test, and modifies the code to handle it.

Quick Start

Refine the 'User Registration' requirement (REQ-F-USER-001) by adding a new business rule (BR-015) for concurrent registration prevention, based on a discovery during TDD.

Frequently Asked Questions about refine-requirements

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

FAQPage Schema
How do I capture edge cases discovered during TDD and update requirements?

Refining requirements from TDD discoveries automates capturing edge cases, race conditions, and business rules found during implementation. The skill records discovery metadata (phase, discoverer, impact) and generates updated BR-*, C-*, and F-* requirement items with traceability, ensuring developer insights integrate into formal specifications without manual re-documentation.

When should I document a race condition found during development?

Document race conditions during the GREEN phase of TDD when you've verified the issue through testing. This skill captures the discovery as a new business rule (e.g., BR-015), updates the requirement baseline, adds corresponding test cases, and modifies code—creating a complete feedback loop that prevents future re-discovery by other teams.

Can I use requirement refinement without an existing baseline?

This skill requires an existing requirement baseline as input. It's designed to refine and extend established BR-*, C-*, and F-* specifications with developer-discovered rules rather than create requirements from scratch. Start with documented baseline requirements before applying refinement.

How does BDD differ from TDD in the refinement workflow?

Both TDD and BDD cycles trigger refinement—the skill applies during either testing methodology to capture discoveries. BDD's scenario-driven approach and TDD's unit-level focus both surface edge cases and missing rules; refinement automates documenting these into updated specifications regardless of which testing discipline you use.

What documentation does the skill generate for a new discovery?

The skill produces updated requirement documents with new BR-*, C-*, or F-* items, discovery metadata (phase, discoverer, impact), and traceability mappings to implementation code and tests. Output artifacts are testable and formally integrated into your SDLC baseline for downstream phases.

Does requirement refinement work with automated test feedback loops?

Yes. The skill integrates into TDD/BDD cycles where test failures or edge-case discoveries trigger refinement. It automates the capture-and-document process, feeding test insights directly into updated BR-*, C-*, and F-* specifications with traceability, closing the feedback loop between testing and requirements management.