PluginBench
Skill
Pass
Audit score 90

ralphinho-rfc-pipeline

affaan-m/everything-claude-code

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

What is ralphinho-rfc-pipeline?

A structured pattern for decomposing large features into independently verifiable work units, executing them in parallel across multiple agents, and integrating them through quality gates and merge queues. Use this when a feature is too complex for a single agent pass and requires coordinated, staged delivery.

  • Decomposes features into a directed acyclic graph (DAG) of work units with explicit dependencies
  • Assigns units to agents with scope, acceptance tests, risk level, and rollback plans
  • Enforces a quality pipeline: research → plan → implement → test → review → merge-ready
  • Manages a merge queue that prevents merging units with unresolved dependencies and re-runs integration tests after each merge
  • Handles unit stalls by evicting, snapshotting findings, and regenerating narrowed scope
  • Produces RFC execution logs, unit scorecards, dependency graphs, and integration risk summaries

How to install ralphinho-rfc-pipeline

npx skills add https://github.com/affaan-m/everything-claude-code --skill ralphinho-rfc-pipeline
Claude Code
Cursor
Windsurf
Cline

How to use ralphinho-rfc-pipeline

  1. 1.Define an RFC describing the feature and its constraints
  2. 2.Decompose the RFC into work units using the unit spec template (id, depends_on, scope, acceptance_tests, risk_level, rollback_plan)
  3. 3.Classify units by complexity tier (1: isolated edits; 2: multi-file changes; 3: schema/auth/perf/security)
  4. 4.Assign units to agents and execute the quality pipeline for each: research → implementation plan → implementation → tests → review → merge-ready report
  5. 5.Queue units for merge respecting dependency order; rebase on latest integration branch before each merge
  6. 6.Re-run integration tests after each queued merge; evict stalled units and regenerate narrowed scope if needed
  7. 7.Collect outputs: RFC execution log, unit scorecards, dependency graph snapshot, and integration risk summary

Use cases

Good for
  • Breaking down a large feature request into parallel work streams that multiple agents can tackle simultaneously
  • Implementing schema or authentication changes that span multiple services with coordinated rollout
  • Managing performance or security refactors that require staged integration and validation
  • Coordinating multi-file behavior changes across a codebase with clear dependency ordering
  • Recovering from stalled work units by narrowing scope and retrying with updated constraints
Who it's for
  • Teams using multi-agent coding workflows (Claude Code, Cursor)
  • Projects with large features that exceed single-agent capacity
  • Organizations needing structured RFC-to-implementation pipelines
  • Teams managing complex integrations with explicit dependency tracking

ralphinho-rfc-pipeline FAQ

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

Use this when a feature is too large for one agent to handle in a single pass, requires parallel work across multiple agents, or has complex dependencies that benefit from staged integration and validation.

What happens if a work unit fails or stalls?

Evict the unit from the active queue, snapshot findings, regenerate a narrowed unit scope with updated constraints, and retry. This prevents blocking the entire pipeline.

Can I merge a unit if its dependencies haven't been merged yet?

No. The merge queue enforces that a unit cannot merge if it has unresolved dependency failures. Always rebase on the latest integration branch before merging.

What are the three complexity tiers?

Tier 1: isolated file edits with deterministic tests. Tier 2: multi-file behavior changes with moderate integration risk. Tier 3: schema, auth, performance, or security changes requiring careful coordination.

What outputs does the pipeline produce?

RFC execution log, unit scorecards, dependency graph snapshot, and integration risk summary—all useful for tracking progress and post-mortems.

Full instructions (SKILL.md)

Source of truth, from affaan-m/everything-claude-code.


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