consolidation

Orchestrate parallel multi-file tasks with worktree isolation and centralized merging.

2|Updated Jan 22, 2026
One-click install
npx skills add https://github.com/abnegate/claudes --skill consolidation-abnegate
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: consolidation
Source: https://github.com/abnegate/claudes/tree/main/skills/consolidation
Command: npx skills add https://github.com/abnegate/claudes --skill consolidation-abnegate

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It solves the problem of coordinating high-quality, multi-file implementations by breaking a non-trivial task into parallel workstreams and merging results with validation.

Core Features & Use Cases

  • Full parallel orchestration: Uses a structured planner/architect wave model to maximize concurrency for independent subtasks.
  • Pre- and post-execution verification: Verifies plans before work starts and checks acceptance criteria after consolidation.
  • Safe consolidation with conflict resolution: Merges worktree branches while preserving intent and wiring tests/build steps.

Use case examples

  • Implementing a feature that touches multiple modules and requires consistent conventions across files.
  • Performing a large refactor spanning several components where parallel changes must be merged correctly.
  • Running batch codebase operations (e.g., cross-cutting updates) that benefit from independent work partitions.

Quick Start

Use the consolidation skill to execute a complex multi-file change end-to-end by first planning, then verifying, then running architect agents in parallel, consolidating their work, reviewing the merged diff, and finally re-verifying acceptance criteria.

Frequently Asked Questions about consolidation

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run parallel code workstreams and merge results safely?

Parallel code workstreams are executed safely by decomposing tasks into subtasks, running implementations concurrently in isolated worktrees, and centrally merging branches while resolving conflicts and verifying acceptance criteria.

What is the best way to orchestrate multi-file refactoring tasks concurrently?

Multi-file refactoring is orchestrated using a structured planner model to maximize concurrency for independent subtasks, followed by centralized code merging and iterative review loops to ensure consistent conventions across files.

How does worktree isolation prevent merge conflicts during parallel execution?

Worktree isolation prevents merge conflicts by assigning independent implementations to separate worktree branches, which are then consolidated through a centralized merge process that preserves intent and wires tests.

Can I verify CI build steps and acceptance criteria after consolidating parallel branches?

Yes, acceptance criteria and CI build steps are verified after consolidation by enforcing post-execution checks and iterative review loops on the merged diff to ensure the final output meets requirements.

Does parallel code orchestration require pre-execution verification before running subtasks?

Pre-execution verification is required to validate structural plans before work starts, ensuring that independent subtasks are correctly partitioned and safe to run concurrently.

When should I not use parallel workstreams for batch codebase changes?

Parallel workstreams are not suitable for batch codebase changes when subtasks lack independence and cannot be safely partitioned, as centralized consolidation requires isolated implementations to merge without breaking intent.