playbooks

home / skills / duc01226 / easyplatform / code-parallel

code-parallel skill

/.claude/skills/code-parallel

This skill orchestrates parallel and sequential phases from a plan, coordinating agents to maximize efficiency while validating assumptions with code evidence.

npx playbooks add skill duc01226/easyplatform --skill code-parallel

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

Files (1)
SKILL.md
2.5 KB
---
name: code-parallel
description: "[Implementation] ⚡ Execute parallel or sequential phases based on plan structure"
argument-hint: [plan-path]
infer: true
---

Execute plan: <plan>$ARGUMENTS</plan>

**⚠️ MUST READ before implementation:**
- `.claude/skills/shared/anti-hallucination-protocol.md` — Assumption validation, evidence chains, context anchoring
- `.ai/docs/backend-code-patterns.md` — Backend code patterns
- `.ai/docs/frontend-code-patterns.md` — Frontend code patterns

**Core Rule:** Verify every assumption with actual code evidence before making changes. If confidence < 90%, investigate further or ask user.

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

## Workflow

### 1. Plan Analysis
- Read `plan.md` from given path
- **Check for:** Dependency graph, Execution strategy, Parallelization Info, File Ownership matrix
- **Decision:** IF parallel-executable → Step 2A, ELSE → Step 2B

### 2A. Parallel Execution
1. Parse execution strategy (which phases concurrent/sequential, file ownership)
2. Launch multiple `fullstack-developer` agents simultaneously for parallel phases
   - Pass: phase file path, environment info, file ownership boundaries
3. Wait for parallel group completion, verify no conflicts
4. Execute sequential phases (one agent per phase after dependencies)
5. Proceed to Step 3

### 2B. Sequential Execution
Follow `./.claude/workflows/primary-workflow.md`:
1. Use main agent step by step
2. Read `plan.md`, implement phases one by one
3. Use `project-manager` for progress updates
4. Use `ui-ux-designer` for frontend
5. Run type checking after each phase
6. Proceed to Step 3

### 3. Testing
- Use `tester` for full suite (NO fake data/mocks)
- If fail: `debugger` → fix → repeat

### 4. Code Review
- Use `code-reviewer` for all changes
- If critical: fix → retest

### 5. Project Management & Docs
- If approved: `project-manager` + `docs-manager` in parallel (update plans, docs, roadmap)
- If rejected: fix → repeat

### 6. Onboarding
- Guide user step by step (1 question at a time)

### 7. Final Report
- Summary, guide, next steps
- Ask to commit (use `git-manager` if yes)

**Examples:**
- Parallel: "Phases 1-3 parallel, then 4" → Launch 3 agents → Wait → Launch 1 agent
- Sequential: "Phase 1 → 2 → 3" → Main agent implements each phase

## 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 executes development plans by orchestrating parallel or sequential phases according to the plan structure. It verifies assumptions with code evidence, activates required agent roles, runs tests and reviews, and produces a final report with next steps. The goal is safe, efficient multi-agent implementation with clear ownership and minimal conflicts.

How this skill works

The skill reads the plan file, extracts dependency graphs, execution strategy, parallelization hints, and file ownership boundaries. If the plan allows parallel work, it launches multiple fullstack developer agents for concurrent phases, waits for completion, and then runs dependent sequential phases. For strictly sequential plans, it drives a single main agent through each phase, using specialized roles (project manager, UI/UX, tester, debugger, code reviewer) at the right steps. Every assumption must be validated with concrete code evidence before changes.

When to use it

  • Large changes decomposed into phases where some phases have independent file ownership
  • Tight deadlines where parallel execution can reduce overall delivery time
  • Complex feature rollouts that need rigorous testing and code review after each phase
  • Incremental refactors where sequential verification is required to avoid regressions
  • Onboarding scenarios where step-by-step guidance and checkpoints are needed

Best practices

  • Always confirm file ownership and dependency edges in the plan before parallelizing
  • Validate each assumption with code evidence; if confidence < 90%, stop and investigate
  • Break work into many small tasks and include a final review task to catch integration issues
  • Use dedicated tester and debugger agents for full-suite runs—no fake mocks for final validation
  • Run type checking after each phase and require code-reviewer approval before merging

Example use cases

  • Execute a plan where phases 1–3 touch distinct modules: launch three parallel fullstack agents, then run phase 4 sequentially
  • Implement a multi-step UI and backend feature sequentially when shared files prevent safe parallelism
  • Coordinate a release where docs and project updates run in parallel after code is approved
  • Fix a complex regression by running tests, debugging, and code review in an iterative loop until green

FAQ

How do you decide parallel vs sequential?

I parse the plan for dependency graph and file ownership; independent phases with no shared files go parallel, otherwise I run sequentially.

What if tests fail after parallel work?

Run the debugger agent to fix failures, re-run the full test suite, and only proceed after passing tests and code-reviewer sign-off.