ralphinho-rfc-pipeline

Decompose large feature RFCs into verifiable work units with dependency graphs.

2|Updated Mar 12, 2026
One-click install
npx skills add https://github.com/sayasaya8039/ZWG_Terminal --skill ralphinho-rfc-pipeline-sayasaya8039
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ralphinho-rfc-pipeline
Source: https://github.com/sayasaya8039/ZWG_Terminal/tree/main/.claude/skills/ralphinho-rfc-pipeline
Command: npx skills add https://github.com/sayasaya8039/ZWG_Terminal --skill ralphinho-rfc-pipeline-sayasaya8039

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the problem of large, complex features that are too big for a single agent pass to handle reliably, which often leads to incomplete work, integration conflicts, and hard-to-trace bugs in multi-agent development workflows.

Core Features & Use Cases

  • RFC Decomposition: Automatically break down large feature RFCs into independent, verifiable work units with clear dependency graphs.
  • Quality-Gated Execution: Run each work unit through a standardized pipeline of research, implementation, testing, and review before it is eligible for merging.
  • Merge Queue Management: Enforce dependency rules, automatically rebase unit branches on the latest integration branch, and re-run integration tests to prevent broken merges.
  • Failure Recovery: Automatically evict stalled units, snapshot findings, and regenerate narrowed scopes to retry work with updated constraints.
  • Use Case: When implementing a cross-service payment feature that requires changes to the API, database, and frontend, use this Skill to split the work into isolated units, track dependencies, and integrate changes safely without breaking existing functionality.

Quick Start

Use the ralphinho-rfc-pipeline skill to decompose the new user onboarding RFC into tracked work units with dependency graphs and enforced 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 split large feature requests into manageable work units for multi-agent execution?

To split large features for multi-agent execution, you use RFC decomposition to break down complex requests into independent, verifiable work units with clear dependency graphs. This prevents incomplete work and integration conflicts during cross-service changes.

What is the best way to track dependencies when implementing cross-service schema updates?

The best way to track dependencies for cross-service schema updates is using DAG orchestration. It maps work units into a directed acyclic graph, enforcing dependency rules and automatically rebasing branches on the latest integration branch to prevent broken merges.

How do quality gates work in a multi-agent software development pipeline?

Quality gates in a multi-agent pipeline enforce a standardized sequence of research, implementation, testing, and review for each work unit. A unit only becomes eligible for merging after passing these automated validation checks to ensure reliable feature delivery.

Can I automate failure recovery when a work unit stalls during feature integration?

Yes, you can automate failure recovery for stalled work units during feature integration. The pipeline automatically evicts stalled units, snapshots findings, and regenerates narrowed scopes to retry work with updated constraints for reliable execution.

When do I need DAG orchestration for software development workflows?

You need DAG orchestration for software development workflows when handling high-risk feature implementations like security modifications or cross-service changes that exceed a single agent pass. It provides strict dependency tracking and integration validation to ensure reliable delivery.