skilld
All skills
dimillian avatar

/orchestrate-batch-refactor

@e656bb7 official
by Thomas Ricouarddimillian/skills4k stars
206

Plan and execute large refactor or rewrite efforts efficiently with parallel multi-agent analysis and implementation. Use when a user asks to refactor many files, split workstreams, analyze a target code area, and coordinate sub-agents with clear ownership and dependency-aware execution.

Ask your Agent

Use this Skill: https://skilld.dev/gh/dimillian/skills/orchestrate-batch-refactor

This session only. Nothing lands on disk.

referencesagent-prompt-templates.md

≈340 tokens on demand. Your agent reads this file only when SKILL.md points to it.

Agent Prompt Templates

Use these templates when spawning sub-agents.

Explorer Prompt Template

Analyze the target scope and return decomposition guidance only.

Scope:
- Paths/modules: <fill>
- Goal: <refactor|rewrite|hybrid>
- Constraints: <behavior/API/test constraints>

Return:
1. Intent map (what each area currently does)
2. Coupling and dependency risks
3. Candidate work packets with non-overlapping ownership
4. Validation commands per packet
5. Recommended execution order

Worker Prompt Template

You own this packet and are not alone in the codebase.
Ignore unrelated edits by others and do not touch files outside ownership.

Packet:
- ID: <fill>
- Objective: <fill>
- Owned files: <fill>
- Dependencies already completed: <fill>
- Invariants to preserve: <fill>
- Required checks: <fill>

Execution requirements:
1. Implement only the packet objective.
2. Preserve specified invariants and external behavior.
3. Run required checks and report exact results.
4. Summarize changed files and any integration notes.

Main Thread Synthesis Prompt Template

Merge explorer outputs into a single dependency-aware plan.
Produce:
1. Packet table with ownership and dependencies
2. Parallel execution waves (no overlap per wave)
3. Validation matrix by packet and integration stage
4. Risk list with mitigation actions

Source: SKILL.md on GitHub

Third-party checks

No alerts16d4 checks · Risk SAFE
  • Gen Agent Trust Hub16d

    This skill coordinates large-scale code refactors using a multi-agent approach. It provides structured templates for analyzing scope, planning work packets, and executing changes with clear ownership and validation gates. No malicious behavior or security risks were identified.

  • Socket16d

    No alerts

  • Snyk16d

    Risk: LOW · No issues

  • ZeroLeaks5mo

    Score: 93/100 · 2 sections analyzed

Provenance

Signed by skilld at e656bb7. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 2 months ago.

Dormantupdated 7 months ago

Topics

  • Refactoring
  • multi-agent
  • orchestration
  • parallel-execution
  • code-analysis
  • work-planning
  • dependency-management
  • scope-management

README badge

README badge for dimillian/skills/orchestrate-batch-refactor

What it does

Orchestrates large refactors across multiple files by parallelizing code analysis, synthesizing a dependency-aware work plan, and executing independent work packets with separate sub-agents. Use when refactoring many files or subsystems where scope analysis, decomposition, and coordinated execution prevent conflicts and maintain behavior parity.

Generated from the current SKILL.md.

Frequently asked

When should I use this skill instead of asking a single agent to refactor multiple files?
Use this skill for medium/large scope touching many files or subsystems. Skip it for tiny edits or highly coupled single-file work where parallelization adds overhead without benefit.
Does this skill preserve existing behavior during refactors?
Yes. The skill defaults to behavior-preserving refactors unless you explicitly request behavior change. Each work packet includes invariants to preserve and required validation checks.
How does this skill handle dependencies between files being refactored?
The skill builds a dependency-aware work graph, sequences packets by dependency level, and runs only independent packets in parallel. Packets explicitly declare their dependencies so the orchestrator respects them.
What happens if two work packets edit overlapping file sets?
The skill prohibits this by design — one owner per file per execution wave. If packet boundaries cause repeated merge conflicts, the skill stops and triggers re-planning.
Do I need to provide templates or can the skill generate work packets on its own?
The skill includes reference templates in `references/work-packet-template.md` and `references/agent-prompt-templates.md`. You can use these directly or adapt them for your codebase structure.

Generated from the current SKILL.md. These answers refresh after source changes.