ralphinho-rfc-pipeline

Use it when:: A feature is too big for one agent pass and you have an RFC to split among several agents.
It does:: Breaks the RFC into a graph of dependent work units, runs each through research, plan, build, tests and review, then merges them through a queue.
You get:: An execution log, a scorecard per unit, a snapshot of the dependency graph and an integration risk summary.
Keep in mind:: It's a one-page outline of stages and rules, with no scripts or prompts of its own.

TL;DR

An outline for running a large feature as many agent-sized pieces. The RFC is decomposed into a DAG, a graph of work units in which each unit lists what it depends on, its scope, acceptance tests, a risk level and a rollback plan. Units fall into three tiers, from isolated file edits with deterministic tests to schema, auth, performance or security changes. Each unit goes through research, an implementation plan, implementation, tests, review and a merge-ready report. Merges go through a queue: never merge a unit whose dependencies failed, always rebase unit branches on the latest integration branch, and rerun integration tests after each merge. A stalled unit is pulled from the queue, its findings saved, its scope narrowed, and it's retried with the new constraints. The run ends with a final verification of the whole system.

Summarizes the skill at d2ef268.

npx skills add https://github.com/affaan-m/ecc --skill ralphinho-rfc-pipeline

skills.sh page Source on GitHub All skills from affaan-m/ecc

Total Downloads: 5,300 on skills.sh, Nov 9, 2026
Repo stars: 299,776 affaan-m/ecc
First seen: May 19, 2026 on skills.sh

Weekly Downloads

439

+71% over the 8 weeks to Nov 9

Weekly values

Week to	Installs
Sep 21	256
Sep 28	157
Oct 5	137
Oct 12	228
Oct 19	406
Oct 26	398
Nov 2	468
Nov 9	439

Category	category:agents category:engineering category:software-engineering Build agents, orchestrate workers and give agents memory. Test-first work, implementation from specs, git hygiene and scope control. Everything for building software: planning, coding, debugging, design, frameworks, cloud, agents and skills.
Type	type:workflow A multi-step process the agent follows: interview, debug, run a TDD loop, review.
Effect	effect:local Its own steps create or change files, git state or local tools.
Needs	needs:subagents Relies on the agent being able to spawn subagents.
Publisher	by:community Everyone else. Unverified vendor claims default to community.
Topics	multi-agent planning agent-workflows git

SKILL.md

From affaan-m/ecc at d2ef268. Checked daily, last changed Nov 6, 2026.

Frontmatter

name: ralphinho-rfc-pipeline
description: Split an RFC into a multi-agent execution DAG — decompose into work units with dependencies and acceptance tests, run research, plan, implement, test, and review per unit, then merge through a queue with re-based branches and final system verification. Use when a feature is too large for a single agent pass, orchestrating RFC-driven multi-agent execution, or managing merge queues across agent-built units.
metadata:
  origin: ECC

Ralphinho RFC Pipeline

Inspired by humanplane style RFC decomposition patterns and multi-unit orchestration workflows.

Use this skill when a feature is too large for a single agent pass and must be split into independently verifiable work units.

Pipeline Stages

RFC intake
DAG decomposition
Unit assignment
Unit implementation
Unit validation
Merge queue and integration
Final system verification

Unit Spec Template

Each work unit should include:

id
depends_on
scope
acceptance_tests
risk_level
rollback_plan

Complexity Tiers

Tier 1: isolated file edits, deterministic tests
Tier 2: multi-file behavior changes, moderate integration risk
Tier 3: schema/auth/perf/security changes

Quality Pipeline per Unit

research
implementation plan
implementation
tests
review
merge-ready report

Merge Queue Rules

Never merge a unit with unresolved dependency failures.
Always rebase unit branches on latest integration branch.
Re-run integration tests after each queued merge.

Recovery

If a unit stalls:

evict from active queue
snapshot findings
regenerate narrowed unit scope
retry with updated constraints

Outputs

RFC execution log
unit scorecards
dependency graph snapshot
integration risk summary