ralphinho-rfc-pipeline

Decompose large features into RFC-style work units with DAG decomposition and quality gates.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/Maelwalser/claude-config --skill ralphinho-rfc-pipeline-maelwalser
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ralphinho-rfc-pipeline
Source: https://github.com/Maelwalser/claude-config/tree/main/skills/ralphinho-rfc-pipeline
Command: npx skills add https://github.com/Maelwalser/claude-config --skill ralphinho-rfc-pipeline-maelwalser

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

RFC-driven multi-agent DAG execution with quality gates and merge queues. Use when a feature is too large for a single agent pass and must be split into work units.

Core Features & Use Cases

  • RFC intake
  • DAG decomposition
  • Unit assignment
  • Unit implementation
  • Unit validation
  • Merge queue management
  • Quality gates across units
  • Independent verifiability and merge readiness

Quick Start

Outline a RFC, decompose into verifiable work units, and assign them to agents for implementation and validation.

Frequently Asked Questions about ralphinho-rfc-pipeline

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

FAQPage Schema
How do I split large features into independently verifiable work units for multi-agent execution?

DAG decomposition breaks large features into RFC-style work units that are independently verifiable and merge-ready. It enables multi-agent execution by managing dependencies and applying quality gates across units.

What is RFC-driven pipeline orchestration and when do I need it for product development?

RFC-driven pipeline orchestration coordinates multi-agent feature splits through RFC intake, DAG decomposition, and unit assignment. You need it when a feature is too large for a single agent pass and requires structured validation and merge-ready reporting.

How do I manage dependencies and quality gates across decomposed work units in a pipeline?

You manage dependencies and quality gates by modeling decomposed work units as a DAG. The pipeline validates each unit independently before entering the merge queue, ensuring merge readiness and end-to-end dependency tracking.

Can I use DAG decomposition for features that require merge-ready reporting and unit validation?

Yes, DAG decomposition supports merge-ready reporting and unit validation by assigning work units to agents for implementation and validation. Each unit passes through quality gates to ensure independent verifiability before entering the merge queue.

What's the best way to orchestrate multi-agent feature splits with merge queue management?

The best way to orchestrate multi-agent feature splits is through RFC intake followed by DAG decomposition and unit assignment. This approach validates units through quality gates and manages the merge queue to ensure independent verifiability and merge readiness.

When should I not use RFC-driven DAG decomposition for feature splitting?

You should avoid RFC-driven DAG decomposition when a feature is small enough for a single agent pass. It is designed for large features requiring structured unit assignment, dependency management, and quality gates across multiple work units.