PluginBench
Skill
Pass
Audit score 90

ralphinho-rfc-pipeline

affaan-m/ecc

RFC-driven multi-agent DAG execution for large features with quality gates and merge orchestration.

What is ralphinho-rfc-pipeline?

Breaks down large features into independently verifiable work units managed through a structured pipeline with quality gates, merge queues, and dependency tracking. Use this when a feature is too complex for a single agent pass and requires coordinated multi-unit implementation.

  • Decomposes RFCs into a directed acyclic graph (DAG) of work units with explicit dependencies
  • Assigns units to agents with scope, acceptance tests, risk levels, and rollback plans
  • Enforces quality pipeline stages: research, planning, implementation, testing, review, and merge-ready reporting
  • Manages merge queues with dependency validation and integration test re-runs after each merge
  • Classifies work by complexity tier (isolated edits, multi-file changes, schema/auth/perf/security)
  • Provides recovery workflows for stalled units via scope regeneration and constraint updates

How to install ralphinho-rfc-pipeline

npx skills add null --skill ralphinho-rfc-pipeline
Claude Code
Cursor
Windsurf
Cline

How to use ralphinho-rfc-pipeline

  1. 1.Write an RFC describing the feature or change
  2. 2.Use the pipeline to decompose the RFC into a DAG of work units with the provided unit spec template (id, depends_on, scope, acceptance_tests, risk_level, rollback_plan)
  3. 3.Assign each unit to an agent with its scope and constraints
  4. 4.Execute the quality pipeline for each unit: research → planning → implementation → tests → review → merge-ready report
  5. 5.Queue units for merge respecting dependency order; re-run integration tests after each merge
  6. 6.Monitor the merge queue for dependency failures; evict stalled units and regenerate narrowed scope if needed
  7. 7.Collect outputs: execution log, unit scorecards, dependency graph, and integration risk summary

Use cases

Good for
  • Breaking down a large feature request into parallel work streams with clear handoff points
  • Coordinating multiple agents on a system redesign with schema, auth, and performance changes
  • Managing risky refactors by isolating changes into testable units with rollback plans
  • Ensuring integration safety in multi-unit projects by re-validating after each merge
  • Tracking and visualizing dependencies between work units to prevent merge conflicts
Who it's for
  • Engineering teams managing large feature development across multiple agents
  • Architects decomposing complex system changes into verifiable work units
  • Teams needing structured merge and integration workflows with quality gates
  • Projects with high risk tolerance requiring rollback plans and recovery procedures

ralphinho-rfc-pipeline FAQ

When should I use this skill instead of a single-agent pass?

Use it when a feature is too large for one agent to complete reliably in a single pass, or when changes span multiple systems with integration risk (schema, auth, performance, security).

What happens if a work unit fails its acceptance tests?

The unit is blocked from merging. Review findings, update the implementation plan, and retry. If the unit is stalled, evict it from the active queue, snapshot findings, and regenerate a narrower scope with updated constraints.

Do I need to rebase units before merging?

Yes. Always rebase unit branches on the latest integration branch before merging, and re-run integration tests after each queued merge to catch new conflicts.

What should a rollback plan include?

A rollback plan should document how to safely revert the unit's changes if integration fails, including data migration reversals, feature flag toggles, or schema rollbacks.

How do I track dependencies between units?

Each unit spec includes a `depends_on` field listing unit IDs it depends on. The pipeline enforces that dependent units cannot merge until their dependencies are integrated.

Full instructions (SKILL.md)

Source of truth, from affaan-m/ecc.


name: ralphinho-rfc-pipeline description: RFC-driven multi-agent DAG execution pattern with quality gates, merge queues, and work unit orchestration. 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

  1. RFC intake
  2. DAG decomposition
  3. Unit assignment
  4. Unit implementation
  5. Unit validation
  6. Merge queue and integration
  7. 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

  1. research
  2. implementation plan
  3. implementation
  4. tests
  5. review
  6. 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