speckit-implement-parallel

Executes spec-kit tasks.md as dependency-ordered waves of parallel subagents with graphify blast-radius context.

Updated Jul 8, 2026
One-click install
npx skills add https://github.com/NarenKarthikBM/specseyal --skill speckit-implement-parallel-narenkarthikbm
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: speckit-implement-parallel
Source: https://github.com/NarenKarthikBM/specseyal/tree/main/.claude/skills/speckit-implement-parallel
Command: npx skills add https://github.com/NarenKarthikBM/specseyal --skill speckit-implement-parallel-narenkarthikbm

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Serial, single-agent implementation of a spec-kit tasks.md is slow and loses structural context; this Skill runs the dev-orchestrator wave model, dispatching one subagent per task in parallel within each dependency wave, each pre-loaded with a graphify blast-radius so it never re-explores the repository. ## Core Features & Use Cases - Wave-based parallel dispatch: Reconstructs the task DAG from tasks.md (or its ## Execution Waves section), dispatches one subagent per task in the same turn, holds the barrier, reviews, then unlocks the next wave. - Roster-bound assembled agents: Every dispatch reads its task's row from the approved workforce roster (agents/assignment.md), carrying base agent, injected skills, and elevated grants into the prompt and the trace. - Proportional review and full observability: Applies full or light review depth per wave based on cross-wave file conflicts and outcomes, commits each wave before marking tasks [X], and appends one implementer trace record per task to traces.jsonl plus one line per wave to implement.log.md. - Use Case: After running /speckit-tasks-graph and approving a workforce roster for a feature, invoke this Skill to implement all tasks across parallel waves with per-wave commits, gate re-verification, and an auditable completion report. ## Quick Start Run /speckit-implement-parallel in a spec-kit feature directory that has tasks.md, graphify-context.md, and an approved agents/assignment.md roster, optionally passing a story or task filter as the argument.

Frequently Asked Questions about speckit-implement-parallel

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run spec-kit tasks in parallel instead of serially?

Invoke /speckit-implement-parallel instead of /speckit-implement. It rebuilds the task DAG, dispatches one subagent per task within each wave in the same turn, reviews the wave, and only then unlocks the next wave.

What is the difference between speckit-implement and speckit-implement-parallel?

speckit-implement executes tasks serially in one agent, while speckit-implement-parallel runs the dev-orchestrator wave model with true parallel subagent dispatch, graphify blast-radius context, per-wave commits, and roster-bound agent identities.

What prerequisites does parallel implementation need before running?

It requires a spec-kit .specify/ structure with tasks.md, a graphify-context.md (run /speckit-graphify-context if missing), and an approved workforce roster at agents/assignment.md. The before_implement gate and per-wave gate re-verification enforce roster approval.

How does the skill decide between full and light wave reviews?

Review depth is full if the wave has a cross-wave file conflict in the DAG annotations or a non-success outcome; otherwise it is light. A light check that finds anything but clean success escalates immediately to full review, and the applied depth plus trigger is logged per wave.

What happens when a parallel task fails during a wave?

A partial result is patched inline or re-dispatched with a corrected prompt. For a failure, the orchestrator diagnoses it: a serial or blocking task stops the run, while one failed parallel task lets the others continue and is reported in the completion report.

When should I not use wave-based parallel implementation?

Skip orchestration when the feature has fewer than three tasks with no real parallelism; the guardrails direct you to implement inline instead. Same-file or shared-file tasks are also never co-scheduled and are serialized into their own waves.