pipe_impl_skill

Orchestrate a 15-phase software implementation workflow with quality gates and VCS sync.

Updated May 27, 2026
One-click install
npx skills add https://github.com/ormastes/Spipe --skill pipe-impl-skill
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pipe_impl_skill
Source: https://github.com/ormastes/Spipe/tree/main/doc/00_llm_process/skill_command/skills/pipe/impl
Command: npx skills add https://github.com/ormastes/Spipe --skill pipe-impl-skill

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill reduces implementation risk by turning an idea into a fully tested code change through a disciplined, phase-by-phase workflow with explicit prerequisites, quality gates, and safety checks.

Core Features & Use Cases

  • 15-phase orchestrated implementation that converts requirements, research, architecture, design, and system testing into production-ready code.
  • Artifact-driven reruns that automatically skip phases when prerequisite docs/tests already exist, saving time while preserving consistency.
  • Quality and safety gates including stub-prevention, cross-reference validation, duplication checks, coverage targets, doctests, refactoring, and VCS sync.
  • Agent-team execution model for predictable division of labor across research/design/code/review roles.

Quick Start

Use the implementation workflow to complete the feature by ensuring your prior artifacts exist (research, requirements, architecture, design, and system test spec) or letting the workflow generate them inline, then proceed through implementation, tests, refactoring, and final sync.

Frequently Asked Questions about pipe_impl_skill

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

FAQPage Schema
How do I enforce stub prevention and coverage targets during a code implementation workflow?

You can enforce stub prevention and coverage targets by running a multi-phase implementation workflow that applies hard fail-gates using pass_todo reasons and mandates doctest coverage for public functions.

What is the best way to orchestrate a complete software implementation from requirements to git sync?

The best way to orchestrate a full software implementation is using a 15-phase workflow that progresses from requirements and research through testing, refactoring, and final VCS sync.

How does an artifact-driven implementation workflow handle reruns when prerequisite docs already exist?

An artifact-driven implementation workflow automatically skips phases when prerequisite artifacts like research, architecture, design, and system test specs already exist, saving time while preserving consistency.

Can I use this implementation workflow for bug fixes that require heavy changes and system tests?

Yes, this implementation workflow is explicitly applicable to feature development, bug fixes, and heavy changes requiring system tests, cross-reference consistency, duplication checks, and coverage thresholds.

Do I need to manually create a system test spec before starting the implementation phases?

No, you do not need to manually create the system test spec beforehand; the workflow enforces mandatory system test spec creation and will generate prerequisite artifacts inline if they are missing.

Why does the implementation workflow include mandatory refactoring and cross-reference validation phases?

The workflow includes mandatory refactoring and cross-reference validation phases to reduce implementation risk by ensuring duplication checks, code generation consistency, and production-ready quality before final VCS sync.