ralphinho-rfc-pipeline

Decompose large features into verifiable work units via RFC-driven DAG orchestration.

Updated Apr 4, 2026
One-click install
npx skills add https://github.com/mitul-bhatia/Vibes --skill ralphinho-rfc-pipeline-mitul-bhatia
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ralphinho-rfc-pipeline
Source: https://github.com/mitul-bhatia/Vibes/tree/main/.github/skills/ralphinho-rfc-pipeline
Command: npx skills add https://github.com/mitul-bhatia/Vibes --skill ralphinho-rfc-pipeline-mitul-bhatia

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Large features often require splitting into independently verifiable work units and coordinated governance across teams using an RFC-driven pattern. This skill provides a repeatable approach to decompose initiatives, coordinate across units, and apply quality gates throughout the lifecycle.

Core Features & Use Cases

  • RFC intake, DAG decomposition, unit assignment, implementation, validation, and merge-ready reporting.
  • Quality gates, merge queues, and recovery strategies to handle stalls and failures.
  • Use cases include handling large, multi-team features that need staged reviews, cross-team validation, and reliable integration.

Quick Start

Decompose a large feature into verifiable work units and run them through RFC-driven orchestration with quality gates.

Frequently Asked Questions about ralphinho-rfc-pipeline

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

FAQPage Schema
How do I decompose large features into independently verifiable work units?

Decomposing large features into verifiable work units uses RFC-driven multi-agent DAG orchestration to split initiatives into independently testable units. Each unit requires an id, depends_on, scope, acceptance_tests, risk_level, and rollback_plan before assignment and implementation.

What is RFC-driven multi-agent orchestration for workflow management?

RFC-driven multi-agent orchestration is a pattern that coordinates large features by routing them through intake, DAG decomposition, unit assignment, implementation, validation, and merge-ready reporting stages with enforced quality gates.

How do I set up quality gates and merge queues for cross-team features?

Quality gates and merge queues for cross-team features are established by defining verification steps and recovery strategies within the orchestration workflow, handling stalls and failures while ensuring reliable integration across teams.

Can I use DAG orchestration for multi-team features requiring staged reviews?

DAG orchestration suits multi-team features requiring staged reviews by decomposing initiatives into work units with defined dependencies and risk levels. It coordinates cross-team validation and applies quality gates throughout the lifecycle.

Do I need to define a rollback plan for every work unit in a DAG pipeline?

Every work unit in a DAG pipeline requires a rollback plan. The specification mandates that each unit includes an id, depends_on, scope, acceptance_tests, risk_level, and rollback_plan to ensure independently verifiable and recoverable implementation.

Why does multi-agent workflow orchestration use RFC intake for feature decomposition?

Multi-agent workflow orchestration uses RFC intake to establish a repeatable governance approach for decomposing large initiatives. This ensures coordinated assignment, validation, and integration across teams before implementation begins.