swarm-planner_skill

Overview

This skill creates dependency-aware implementation plans optimized for parallel multi-agent execution. It inspects project structure, external libraries, and constraints to produce atomic, reviewable tasks with explicit dependencies and validation criteria. Plans are saved as markdown and reviewed by a subagent before final delivery.

How this skill works

The skill inspects the codebase to identify architecture, patterns, dependencies, and relevant files, then uses Context7 for up-to-date documentation on any external libraries or APIs. It generates a task graph where each task has an id, depends_on list, location, description, and validation steps. After saving the plan to a topic-based markdown file, a subagent reviews the plan for missing dependencies, ordering issues, and gaps; actionable feedback is incorporated before yielding the final plan.

When to use it

• When you need a parallel-executable implementation plan for a code change, feature, or integration.
• When multiple agents will execute tasks concurrently and explicit dependencies are required.
• When external libraries or APIs are involved and current documentation must be consulted.
• When you want atomic, testable work items with clear validation criteria.
• When you want a pre-execution review to catch ordering and dependency mistakes.

Best practices

• Always run the initial codebase exploration to determine architecture and surface ambiguity.
• Use Context7 to fetch version-specific docs for any external dependency before planning tasks.
• Stop and ask user clarification questions when architecture, scope, or constraints are unclear.
• Keep tasks small and atomic so single agents can execute them without cross-task coordination.
• Ensure every task includes explicit validation steps and file locations for traceability.

Example use cases

• Planning a new API feature across backend, database migration, and CI so each agent can work in parallel.
• Preparing a refactor where dependent modules must be updated in a safe, ordered sequence.
• Coordinating integration of a third-party SDK with version-specific API calls and tests.
• Breaking down a complex bugfix into independent verification, patch, and test tasks for parallel execution.
• Creating release preparation steps that include docs, tests, and deployment checks with explicit dependencies.