SkillRepo
Sign InSign Up
Catalog
affaan-m/ralphinho-rfc-pipeline

affaan-m

ralphinho-rfc-pipeline

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.

NewUpdated Sep 27, 2026

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
Files1
1 files · 1.0 KB

Select a file to preview

Overall Score

72/100

Grade

B

Good

Grades are signals, not a certification. Always review a skill yourself before use.

Safety

85

Quality

65

Clarity

75

Completeness

60

Summary

A high-level orchestration skill that guides multi-agent RFC execution by decomposing large features into a directed acyclic graph (DAG) of work units with dependencies, acceptance tests, and risk metadata. The skill structures parallel execution across research, planning, implementation, testing, and review phases per unit, then manages merge queue integration with rebase discipline and final system verification.

Detected Capabilities

RFC parsing and decompositionDAG construction and dependency resolutionWork unit specification and templatingMulti-stage quality pipeline orchestrationMerge queue and branch rebase managementIntegration test orchestrationRollback planning and unit recoveryLogging and observability (execution logs, scorecards, dependency graphs)

Trigger Keywords

Phrases that agents use to match this skill to user intent.

split rfc into unitsorchestrate multi-agent featuremanage merge queueplan complex featuredecompose feature dependencies

Referenced Domains

External domains referenced in skill content, detected by static analysis.

github.com

Use Cases

  • Decompose large feature RFCs into independently testable work units with explicit dependencies
  • Orchestrate multi-agent parallel work on a single feature while maintaining test coverage and merge queue discipline
  • Manage complex feature delivery with risk-aware unit prioritization and rollback planning
  • Coordinate RFC-driven execution across research, implementation, testing, and review stages
  • Execute system changes that require integration verification after merging multiple agent-built branches

Quality Notes

  • Skill defines clear structural components (unit spec template, complexity tiers, quality pipeline stages) that provide a reproducible framework for decomposition
  • Merge queue rules are explicitly stated with critical safety constraints (dependency validation, rebase enforcement, integration test re-runs)
  • Recovery procedures are documented for stalled units, showing operational resilience planning
  • No executable code or shell commands in the skill — it is a pure orchestration and workflow specification
  • Limitation: the skill provides workflow structure but lacks detailed algorithmic guidance for DAG analysis, unit splitting heuristics, or priority resolution when dependencies conflict
  • No examples of actual RFC input or expected decomposition outputs — concrete walkthrough would improve clarity
  • Acceptance test format and integration test strategy are mentioned but not detailed; specification of what constitutes a passing test would strengthen completeness
Model: claude-haiku-4-5-20251001Analyzed: Sep 27, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Version History

  1. v3.0

    Contract changed: description

    ✦ AIDescription narrowed to specify RFC decomposition, work unit dependencies, and merge-queue orchestration.

    triggering2026-09-27

    LATEST
  2. v2.0

    Contract changed: description

    ✦ AIClarifies skill activation context in description.

    triggering2026-09-09

    View This Version
  3. v1.2

    Content updated

    ✦ AINo behavioral changes detected.

    2026-07-14

    View This Version
  4. v1.1

    Content updated

    ✦ AIAdds LICENSE file.

    2026-04-20

    View This Version
  5. v1.0

    Seeded from github.com/affaan-m/everything-claude-code

    2026-03-16

    View This VersionInitial version

Use affaan-m/ralphinho-rfc-pipeline in your dev environment

Start a Developer trial

Command Palette

Search for a command to run...