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-pipelineHow to use ralphinho-rfc-pipeline
- 1.Define an RFC describing the feature and its constraints
- 2.Decompose the RFC into work units using the unit spec template (id, depends_on, scope, acceptance_tests, risk_level, rollback_plan)
- 3.Classify units by complexity tier (1: isolated edits; 2: multi-file changes; 3: schema/auth/perf/security)
- 4.Assign units to agents and execute the quality pipeline for each: research → implementation plan → implementation → tests → review → merge-ready report
- 5.Queue units for merge respecting dependency order; rebase on latest integration branch before each merge
- 6.Re-run integration tests after each queued merge; evict stalled units and regenerate narrowed scope if needed
- 7.Collect outputs: RFC execution log, unit scorecards, dependency graph snapshot, and integration risk summary
Use cases
- 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
- 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
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.
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.
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.
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.
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
- 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:
iddepends_onscopeacceptance_testsrisk_levelrollback_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
Related skills
More from affaan-m/everything-claude-code and the wider catalog.
security-review
Security checklist and patterns for authentication, input validation, secrets, and sensitive features.
golang-patterns
Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable applications.
coding-standards
Baseline coding conventions for naming, readability, immutability, and quality across projects.
frontend-patterns
React and Next.js patterns for components, state management, performance, and modern frontend practices.
backend-patterns
REST/GraphQL API design, database optimization, and server-side patterns for Node.js, Express, and Next.js.
golang-testing
Go testing patterns: table-driven tests, subtests, benchmarks, fuzzing, and TDD methodology.