playbooks

home / skills / everyinc / compound-engineering-plugin / resolve_parallel

resolve_parallel skill

/plugins/compound-engineering/skills/resolve_parallel

This skill resolves all TODO comments in parallel by orchestrating targeted subagents, reducing wait time and accelerating codebase completion.

npx playbooks add skill everyinc/compound-engineering-plugin --skill resolve_parallel

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
1.2 KB
---
name: resolve_parallel
description: Resolve all TODO comments using parallel processing
argument-hint: "[optional: specific TODO pattern or file]"
disable-model-invocation: true
---

Resolve all TODO comments using parallel processing.

## Workflow

### 1. Analyze

Gather the things todo from above.

### 2. Plan

Create a TodoWrite list of all unresolved items grouped by type.Make sure to look at dependencies that might occur and prioritize the ones needed by others. For example, if you need to change a name, you must wait to do the others. Output a mermaid flow diagram showing how we can do this. Can we do everything in parallel? Do we need to do one first that leads to others in parallel? I'll put the to-dos in the mermaid diagram flow‑wise so the agent knows how to proceed in order.

### 3. Implement (PARALLEL)

Spawn a pr-comment-resolver agent for each unresolved item in parallel.

So if there are 3 comments, it will spawn 3 pr-comment-resolver agents in parallel. liek this

1. Task pr-comment-resolver(comment1)
2. Task pr-comment-resolver(comment2)
3. Task pr-comment-resolver(comment3)

Always run all in parallel subagents/Tasks for each Todo item.

### 4. Commit & Resolve

- Commit changes
- Push to remote

Overview

This skill automates resolving all TODO comments across a codebase by analyzing, planning, and executing fixes using parallel subagents. It groups unresolved items, identifies dependencies, and runs per-item resolver tasks concurrently to maximize throughput. The workflow ends by committing and pushing changes to the repository.

How this skill works

The skill scans source files to collect all TODO comments and builds a Todo list grouped by type and dependency. It produces a simple flow plan that indicates which items can run in parallel and which require sequential ordering. For each unresolved item it spawns a pr-comment-resolver task in parallel, waits for results, applies changes, commits, and pushes the updates.

When to use it

  • Large codebases with many independent TODO comments that can be resolved concurrently.
  • When TODO items are mostly self-contained tasks (docs, small refactors, lint fixes).
  • During maintenance sprints to clear backlog items quickly.
  • Before a major release to reduce outstanding comments and improve code quality.
  • When you want automated parallel agents to speed up PR comment resolution.

Best practices

  • Scan and group TODOs by type and dependency before executing any changes.
  • Prioritize dependency-critical items that other tasks rely on and run them first if necessary.
  • Limit parallelism per repo to avoid conflicting edits on the same files.
  • Use small, focused pr-comment-resolver tasks that modify minimal scope and include tests where possible.
  • Review and approve aggregated commits from parallel tasks to catch integration issues.

Example use cases

  • Resolve multiple isolated TODOs that add types or docstrings across many files in parallel.
  • Automate simple refactors (rename, small API adjustments) that do not overlap file edits.
  • Close lint or formatting TODOs across components simultaneously to meet codebase standards.
  • Spawn parallel agents to answer reviewer comments in a PR that contains many independent notes.

FAQ

How are dependencies between TODOs handled?

The skill analyzes dependencies and produces a flow plan; dependent items are scheduled sequentially while independent ones run in parallel.

What prevents conflicting edits from parallel tasks?

Best practice is to detect file overlap and either serialize conflicting tasks or limit parallel workers for those files to avoid merge conflicts.