blueprint-sdd-step05-implement

Guide TDD-based implementation workflows with failing tests, plan slices, and commits.

Updated Mar 25, 2026
One-click install
npx skills add https://github.com/sbonoc/stackit-platform-blueprint --skill blueprint-sdd-step05-implement
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: blueprint-sdd-step05-implement
Source: https://github.com/sbonoc/stackit-platform-blueprint/tree/main/.agents/skills/blueprint-sdd-step05-implement
Command: npx skills add https://github.com/sbonoc/stackit-platform-blueprint --skill blueprint-sdd-step05-implement

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill guides software engineers through the process of implementing work items in a disciplined manner, ensuring that tests are written before code and that each slice of work is committed systematically.

Core Features & Use Cases

  • Test-Driven Implementation: Facilitates writing failing tests first and then developing code to pass them, aligned with plan slices.
  • Slice-Based Workflow: Manages implementation across multiple plan slices, maintaining a clear record of progress.
  • Use Case: When tasked with implementing a feature, a developer can use this Skill to follow best practices and ensure traceability with commit history and structured testing.

Quick Start

Use the blueprint-sdd-step05-implement skill to execute Step 6: implement the work item in TDD slices following plan.md — write failing tests first, then make them green, commit each slice to the existing Draft PR branch.

Frequently Asked Questions about blueprint-sdd-step05-implement

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

FAQPage Schema
How do I implement features using TDD slices with proper version control?

Test-driven implementation using TDD slices requires writing failing tests first, then developing code to pass them, and committing each work slice systematically to a Draft PR branch for structured feature delivery and traceable progress.

What is the best way to manage implementation across multiple plan slices?

Managing implementation across multiple plan slices involves breaking down complex features into structured segments, writing tests before code for each slice, and maintaining a clear record of progress through systematic version control commits.

How does slice-based workflow improve test-driven development?

Slice-based workflow improves test-driven development by enforcing disciplined, incremental progress: developers write failing tests for a specific slice, implement code to pass those tests, and commit the completed slice before moving to the next segment.

Do I need a plan.md file to start TDD-based implementation?

Yes, TDD-based implementation follows plan.md to guide work item execution, ensuring that each test and code slice aligns with the predefined project structure and maintains traceability with commit history.

Can I use this implementation workflow for complex feature delivery?

Yes, this implementation workflow is designed for complex feature delivery, guiding software engineers through systematic slicing and structured testing to ensure disciplined, traceable version control practices throughout the development process.

Why should I commit each TDD slice to a Draft PR branch?

Committing each TDD slice to a Draft PR branch ensures systematic version control and traceability, maintaining a clear record of progress as developers incrementally write tests and implement code for complex features.