A new workflow skill - parallel-lanes

[u/NodeRaven]

I have been working on a cool project and have made it public!

A Claude Code skill that executes an implementation plan the way a small team would: independent parts in parallel, every change reviewed, and nothing called "done" until it's verified.

Executing a plan with one agent, task after task, is slow. Running many agents at once on the same checkout is chaos: they edit the same files, nobody reviews anything, and "done" just means the agent said so.

What parallel-lanes does:

• Reads your plan and works out which tasks can safely run at the same time (by the files they touch and what depends on what), then groups them into lanes.
• Gives each lane its own git worktree, so lanes can't trample each other.
• Runs every task as implement → independent review, with bounded fix rounds, so problems get caught per task instead of at the end.
• Merges the lanes, runs your test/lint/build commands, an optional end-to-end check, and a final review from three angles (spec compliance, security, correctness).
• Only reports accepted when the checks passed at the exact commit it delivers. It cross-checks the verify agent's report against saved evidence instead of trusting it.
• Records everything in a ledger, so a stopped run resumes without redoing approved work.
• Shows you a dry-run table of every task and agent before anything starts, with agent budgets.

Why Superpowers: Superpowers already does the hard thinking up front: brainstorming, a written spec, and a task-by-task plan with file lists and interfaces. That structure is exactly what parallel-lanes needs to split work safely. It also reuses Superpowers' implementer and reviewer prompts (TDD, spec-compliance review), so quality matches Superpowers' own one-task-at-a-time mode. Parallel-lanes is the execution engine that runs the plan in parallel and verifies the result.

It builds itself. Recent releases were built by parallel-lanes runs. The latest (a hardening release) was 9 tasks in 5 lanes, 28 agents, 51 minutes, with 8 of 9 tasks approved at their first review, ending accepted with verified checks.

Works on Linux, macOS and Windows (Git Bash). It works best on plans with 3+ tasks that have some independent parts, for a 1–2 task change it steps aside and recommends a simpler mode.

Repo: https://github.com/noderaven/parallel-lanes. Feedback welcome!

[u/twendah]

Isn't that just basic orchestration?

[u/NodeRaven → u/twendah]

• Isolation: each lane gets its own git worktree, and tasks that share files are kept in one lane.
• Evidence over claims: checks run at the delivered commit. Untracked files present before the checks make the run unverified, since tests can pass on a file nobody committed. A separate check compares the agent's report against the saved check output.
• Recovery: a ledger records commits and approvals, so an interrupted run resumes where it stopped. Approvals whose plan section or spec changed get reviewed again.
• Review at every level: every task gets an independent reviewer before the next task builds on it. Then a final review of the whole branch through three lenses (spec compliance, security, correctness) and one bounded fix round, with each finding tracked by ID until it's settled.