implement-spec

Implement behavioral specifications by completing step 3 in the RED-GREEN workflow.

43|1|Updated Feb 19, 2024
One-click install
npx skills add https://github.com/dogganidhal/noddde --skill implement-spec-dogganidhal
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implement-spec
Source: https://github.com/dogganidhal/noddde/tree/main/.claude/skills/implement-spec
Command: npx skills add https://github.com/dogganidhal/noddde --skill implement-spec-dogganidhal

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a structured, repeatable process to transform a given behavioral specification into a concrete implementation, ensuring tests exist and the implementation aligns with the spec’s steps.

Core Features & Use Cases

  • Orchestrates Step 3 in a RED-GREEN workflow by reading the spec, source, and tests, then guiding code implementation.
  • Enforces a strict, test-driven approach: it prevents implementation until tests are ready and requires updating status to implementing.
  • Supports a thorough reading of dependencies and source contracts to ensure correct code synthesis.
  • Promotes a disciplined, code-only implementation in line with functional programming principles.

Quick Start

Replace Not implemented stubs with working code guided by the provided spec while ensuring tests exist.

Frequently Asked Questions about implement-spec

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

FAQPage Schema
How do I implement code from a behavioral specification using test-driven development?

Test-driven development implementation translates a behavioral specification into working code by reading the spec, existing source, and tests, then generating code that passes those tests. It enforces the RED-GREEN workflow's third step to ensure functional style and strict type discipline.

What is the RED-GREEN workflow for TypeScript pipeline implementation?

The RED-GREEN workflow for TypeScript pipeline implementation is a test-driven process where tests are written first, followed by source code implementation. This step specifically handles the third phase, replacing 'Not implemented' stubs with functional code guided by the spec and test constraints.

How do I generate functional TypeScript code that passes existing tests?

Generating functional TypeScript code that passes existing tests requires carefully reading the behavioral spec, source contracts, and dependencies. The process enforces a non-invasive, code-only implementation approach, ensuring strict type discipline and functional programming principles are met.

Do I need existing tests and a behavioral spec before starting code implementation?

Yes, existing tests and a behavioral spec are required before code implementation begins. The process strictly prevents implementation until tests are ready and the spec exists, requiring a status update to implementing before replacing stubs with working code.

What's the best way to enforce strict type discipline during spec-driven implementation?

Enforcing strict type discipline during spec-driven implementation is achieved by applying a non-invasive, code-only process that reads source contracts and dependencies thoroughly. This ensures the generated TypeScript code satisfies both the behavioral specification and functional programming requirements.

Why does test-driven spec implementation prevent coding before tests are ready?

Test-driven spec implementation prevents coding before tests are ready to enforce a disciplined RED-GREEN workflow. This ensures the final code strictly aligns with the behavioral specification and passes all existing tests without invasive modifications to the source.