# Create Parallel Implementation Plans

Large code changes are hard to divide across agents without dependency conflicts. This skill creates clear plans with task order, validation steps, and parallel execution groups.

## Install

```bash
npx skillstore add am-will/swarm-planner
```

## Metadata

- - Slug: am-will-swarm-planner
- - Version: 1.0.0
- - Author: am-will
- - GitHub username: am-will
- - License: MIT
- - Repository: https://github.com/am-will/codex-skills/tree/main/skills/swarm-planner/
- - Ref: main
- - Supported tools: Claude, Codex, Claude Code
- - Risk level: low
- - Risk factors: network, filesystem
- - Quality score: 77
- - Quality tier: bronze
- - Public page: https://skillstore.pages.dev/skills/am-will-swarm-planner
- - Manifest: https://skillstore.pages.dev/api/skills/am-will-swarm-planner/manifest

## Capabilities

- Investigates a codebase before proposing implementation tasks.
- Creates task plans with explicit depends\_on relationships.
- Separates work into parallel execution waves.
- Defines validation steps for each planned task.
- Requests clarification when architecture or scope is ambiguous.
- Uses a subagent review step to check dependency gaps.

## Use Cases

- Split a Feature Across Agents: Break a feature into ordered tasks that several agents can execute without blocking each other.
- Plan a Refactor Safely: Map dependencies, validation checks, and execution waves before changing shared code.
- Prepare Agent Work Packages: Create clear task descriptions, locations, and validation criteria for delegated coding work.

## Prompt Templates

### Plan a Small Change

```
Use swarm-planner to create a dependency-aware plan for adding [feature] to this project. Ask questions if scope is unclear.
```

### Plan With Constraints

```
Use swarm-planner to plan [change]. Respect these constraints: [constraints]. Include validation steps and parallel execution groups.
```

### Plan a Multi-Agent Refactor

```
Use swarm-planner to inspect the codebase and create a multi-agent refactor plan for [area]. Identify dependencies, risks, and review checkpoints.
```

### Plan With Documentation Review

```
Use swarm-planner for [project goal]. Fetch current documentation for relevant dependencies, then create a plan with task waves and validation criteria.
```

## Limitations

- It creates plans only and does not implement the planned changes.
- It depends on available tools for documentation lookup and subagent review.
- Plan quality depends on accurate project context and user scope.
- It may create a Markdown plan file in the current working directory.

## Best Practices

- Provide the goal, affected systems, constraints, and expected validation before invoking the skill.
- Let the skill inspect the repository before asking it to finalize task dependencies.
- Review the generated plan before assigning tasks to agents.

## Anti Patterns

- Do not use it when you need immediate code implementation instead of planning.
- Do not skip clarification when architecture, scope, or ownership is unclear.
- Do not treat generated execution waves as final without human review for high-risk changes.

## Security Audit

- - Safe to publish: true
- - Audited at: 2026-06-28T09:00:39.97\+00:00
- - Summary: Static shell-execution and weak-cryptography findings are false positives from Markdown backticks, example task IDs, empty arrays, and the word description. No malicious intent, prompt injection, executable payload, credential access, or exfiltration pattern was found in SKILL.md. The skill has low operational risk because it asks agents to fetch documentation and save a plan file in the current workspace.

## Stats

- - Views: 144
- - Downloads: 7
- - Favorites: 0
- - Popularity score: 0