home / skills / duc01226 / easyplatform / cook-auto-parallel

cook-auto-parallel skill

safe

This skill orchestrates parallel planning and execution for fullstack development tasks, improving efficiency and token usage.

npx playbooks add skill duc01226/easyplatform --skill cook-auto-parallel

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

Files (1)

SKILL.md

2.2 KB

---
name: cook-auto-parallel
description: "[Implementation] ⚡⚡⚡ Plan parallel phases & execute with fullstack-developer agents"
argument-hint: [tasks]
infer: true
---

**Ultrathink parallel** to implement: <tasks>$ARGUMENTS</tasks>

**IMPORTANT:** Activate needed skills. Ensure token efficiency. Sacrifice grammar for concision.

## ⚠️ Anti-Hallucination Reminder

**Before modifying ANY code:** Verify assumptions with actual code evidence. Search for usages, read implementations, trace dependencies. If confidence < 90% on any change, investigate first or ask user. See `.claude/skills/shared/anti-hallucination-protocol.md` for full protocol.

## Workflow

### 1. Research (Optional)
- Use max 2 `researcher` agents in parallel if tasks complex
- Use `/scout-ext` to search codebase
- Keep reports ≤150 lines

### 2. Parallel Planning
- Trigger `/plan-hard --parallel <detailed-instruction>`
- Wait for plan with dependency graph, execution strategy, file ownership matrix

### 3. Parallel Implementation
- Read `plan.md` for dependency graph
- Launch multiple `fullstack-developer` agents in PARALLEL for concurrent phases
  - Example: "Phases 1-3 parallel" → launch 3 agents simultaneously
  - Pass phase file path: `{plan-dir}/phase-XX-*.md`
  - Include environment info
- Wait for all parallel phases complete before dependent phases
- Sequential phases: launch one agent at a time

### 4. Testing
- Use `tester` subagent for full test suite
- NO fake data/mocks/cheats
- If fail: use `debugger`, fix, repeat

### 5. Code Review
- Use `code-reviewer` for all changes
- If critical issues: fix, retest

### 6. Project Management & Docs
- If approved: use `project-manager` + `docs-manager` in parallel
- Update plan files, docs, roadmap
- If rejected: fix and repeat

### 7. Final Report
- Summary of all parallel phases
- Guide to get started
- Ask to commit (use `git-manager` if yes)

**Example:** Phases 1-3 parallel → Launch 3 fullstack-developer agents → Wait → Phase 4 sequential

## IMPORTANT Task Planning Notes

- Always plan and break many small todo tasks
- Always add a final review todo task to review the works done at the end to find any fix or enhancement needed

Overview

This skill coordinates automated parallel planning and execution for code changes using multiple fullstack-developer agents. It structures work into phased tasks, runs concurrent implementation where safe, and enforces strict verification, testing, and review before merging. Designed for token-efficient, pragmatic automation in complex codebases.

How this skill works

The skill inspects the codebase to build a dependency graph and creates a multi-phase plan. It launches minimal researcher agents if needed, triggers a parallel plan generator, then spins up multiple fullstack-developer agents to execute independent phases concurrently. After implementation it runs a tester agent, performs code review, and produces a final report and onboarding steps.

When to use it

Large changes that can be decomposed into independent, parallelizable phases
Refactors with clear module boundaries and well-covered tests
Feature delivery where multiple teams or agents can work concurrently
Time-sensitive fixes where parallel work reduces wall-clock time
Complex migrations requiring phased, dependency-aware rollout

Best practices

Verify assumptions in code before editing; investigate usages and implementations until confidence ≥ 90%
Keep research limited: use up to 2 researcher agents and short reports
Break work into many small, testable todo tasks and include a final review task
Only parallelize truly independent phases; wait for all parallel phases before dependent phases
Run full test suites with a tester agent and iterate with a debugger until green
Always run a dedicated code reviewer and require fixes before merging

Example use cases

Parallel implementation of independent API endpoints across modules
Large refactor: split into phases for library extraction, interface stabilization, and integration
Migration: run data model migration, adapter updates, and client changes as separate parallel phases
Feature rollout: implement backend, frontend, and infra changes concurrently, then integrate
Emergency patching: parallelize unrelated safe fixes to reduce downtime

FAQ

How many agents run in parallel?

Use multiple fullstack-developer agents for independent phases; limit researcher agents to two and avoid excessive parallelism to save tokens.

What if tests fail after parallel work?

Run the tester agent, then use a debugger agent to fix failures. Repeat testing until the suite is green before code review and merge.