home / skills / ratacat / claude-skills / resolve_parallel

resolve_parallel skill

safe

This skill analyzes and resolves all TODO comments in parallel, speeding code cleanup while ensuring dependency-aware prioritization across tasks.

npx playbooks add skill ratacat/claude-skills --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
---

## Arguments
[optional: specific TODO pattern or file]

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 TODO comments across a codebase by analyzing, planning, and executing fixes in parallel. It breaks down unresolved items, creates a prioritized plan with dependency-aware flow, and spawns parallel resolver agents to implement each change. Finally, it commits and pushes the resolved changes to the remote repository.

How this skill works

The skill scans files for TODO patterns or a provided specific pattern and collects all unresolved items. It builds a dependency-aware plan and outputs a mermaid flow diagram that shows which items can run in parallel and which must run sequentially. For implementation, it spawns a parallel pr-comment-resolver task for each item, runs them concurrently, then commits and pushes the combined changes.

When to use it

You have many TODO comments across a repository and want to resolve them efficiently.
Multiple independent fixes can be applied concurrently without risking conflicting changes.
You need an explicit dependency plan before making changes that may affect each other.
You want automated commit and push after batch resolution.

Best practices

Provide a specific TODO pattern if your project uses a custom marker to avoid false positives.
Run the analyze and plan steps first to identify dependencies before spawning parallel tasks.
Prioritize renames or structural changes that other TODOs depend on to avoid rework.
Limit parallelism to a safe level for the repository and CI constraints to reduce merge conflicts.
Review each resolver agent’s proposed change before final commit when possible.

Example use cases

Resolve isolated documentation TODOs across many modules in parallel.
Apply multiple small bugfix TODOs that do not touch the same files concurrently.
Handle bulk TODO-to-task conversions where each item can be implemented independently.
Perform a coordinated change where one structural rename runs first and dependent TODOs run in parallel afterward.

FAQ

How does the skill avoid conflicting edits?

It creates a dependency-aware plan and only runs truly independent items in parallel; dependent items are ordered so structural changes occur before dependents.

Can I restrict which files or patterns are processed?

Yes. You can supply a specific TODO pattern or file list to focus analysis and avoid processing unrelated comments.