# lane-orchestrator

Adopt this skill: https://proskills.md/skills/other/johnarndt-john-lab-john-lab-skills-lane-orchestrator

Page: https://proskills.md/skills/other/johnarndt-john-lab-john-lab-skills-lane-orchestrator
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: john-lab/skills/lane-orchestrator/SKILL.md
size: 4459
sha: 567cf146b0fec882a54e8c198ef27b75f2579f9d
upstream: https://github.com/johnarndt/john-lab/blob/main/john-lab/skills/lane-orchestrator/SKILL.md

````text
---
name: lane-orchestrator
description: "Use when a user wants several AI coding agents to build one hard change in parallel without stepping on each other. Triggers include 'have a reviewer plan it and agents build it', 'split this across agents', 'use a planner model and builder models', 'spin up parallel lanes', 'get an independent review before merging', or 'coordinate multiple Claude sessions on this repo'. Sets up a strategy review first, file-owned lanes in separate worktrees, append-only status logs, frozen contracts, independent reviewers with reproductions, and an explicit spending rule."
---

# Lane orchestrator

Parallel agents go fast and break things in parallel. This skill is the coordination layer: one planner, a few builders with clear ownership, reviewers who did not write the code, and a root that decides. Everything is a file, so any session can resume after a limit or a crash.

## Roles

- **Strategy reviewer** (the strongest model available): reads the goal and the code, then writes the plan. It does not write production code.
- **Lanes** (builder models): each owns a set of files and a written deliverable.
- **Independent reviewers:** fresh sessions that never saw the lane's reasoning. They get the code and the acceptance criteria, and they write reproductions, not opinions.
- **Root** (you, or the coordinating session): assigns ownership, accepts or overrides the reviewer, integrates and decides on release. Only root merges or deploys.

## Workspace

```
coord/
  plan.md                  # strategy review output
  coordinator-notes.md     # root's timestamped decisions, append-only
  contracts/               # shared interfaces, versioned: contracts.v1.ts, contracts.v2.ts
  acceptance.v1.md         # what "done" means, frozen by hash
  lanes/<lane>-status.md   # each lane's append-only log
  reviews/<lane>-<sha>/review.json + repro scripts
  decisions/<date>-<topic>.json
```

Review JSON: `{ "verdict": "accept|blockers", "findings": [...], "positiveEvidence": [...], "acceptanceLimits": [...], "reviewedSha": "..." }`.

## Flow

1. **Strategy review.** The reviewer writes `plan.md`: architecture, lanes, file ownership per lane, the shared contract to freeze first, and the acceptance criteria.
2. **Freeze the contract.** One lane writes the shared types or interfaces within the first short block of work. Root freezes it. Later changes publish `v2` alongside `v1`; nothing is rewritten in place.
3. **Freeze acceptance.** Record a hash of the acceptance file. Later additions are addenda that may tighten but never relax it.
4. **Run lanes.** Each lane gets its own git worktree and branch, starting from the same commit. It edits only its owned files, logs progress and published interfaces to its status file, commits, and stops at its deliverable.
5. **Independent review.** For each finished lane, a reviewer at the frozen SHA writes findings with reproduction scripts. Blockers go back to the lane as a narrow follow-up with the repro attached.
6. **Integrate.** Root merges accepted lanes into an integration worktree, runs the full suite and the acceptance checks, and records a decision file.
7. **Release** only from a clean integration commit, by root, after the owner approves.

## Spending rule

Write it in `plan.md` and in every lane prompt: which accounts pay for development and which pay for product test runs. A sensible default is to build and review on the subscription, and to spend API credits only on runs of the product itself, capped per run and frozen to a code hash. If a lane hits a usage limit, it stops and preserves its work. It never switches to a paid route to keep going.

## Rules learned the hard way

- **Mocks lie.** Tests that mock the data layer passed while the real path read the wrong field. Reviewers must exercise at least one real path per lane.
- **Shared worktrees collide.** File ownership alone is not enough isolation; give each lane its own worktree.
- **Interrupt with evidence, not new scope.** When root interrupts a lane, the message says what was found and that the original objective stands.
- **The reviewer can be wrong.** Root may override the strategy reviewer and records why. Reject any shortcut that would hide failures, such as skipping work because something looks present.
- **Check the layer.** If repeated fixes do not move the result, ask the reviewer whether the failure lives in a different layer than the one being fixed.
````

## File: README.md
upstream: https://github.com/johnarndt/john-lab/blob/main/README.md

````text
# John Lab

Eleven Claude skills taken from the workflows I use to build, ship and market my own products. Each one is a plain `SKILL.md` you can read before installing. Each has an article on [johnarndt.net/skills](https://johnarndt.net/skills) about where it came from.

## Install

In Claude Code:

```
/plugin marketplace add johnarndt/john-lab
/plugin install john-lab@john-lab
```

To use a single skill, copy its folder into `~/.claude/skills/` (personal) or `.claude/skills/` in a repository. In the Claude apps, download a skill's ZIP from [johnarndt.net/skills](https://johnarndt.net/skills) and upload it under Customize → Skills.

## Skills

| Skill | What it does | Article |
|---|---|---|
| [`feature-audit`](john-lab/skills/feature-audit/SKILL.md) | Inventory every user story, test each, fix, retest, all tracked in one CSV. No fixing before testing. | [Read](https://johnarndt.net/skills/feature-audit) |
| [`lane-orchestrator`](john-lab/skills/lane-orchestrator/SKILL.md) | One planner, parallel builders in their own worktrees, reviewers who didn't write the code, and a spending rule. | [Read](https://johnarndt.net/skills/lane-orchestrator) |
| [`safe-cutover`](john-lab/skills/safe-cutover/SKILL.md) | Snapshot DNS, prove parity, cut over behind a health gate with automatic rollback, keep the old host warm. | [Read](https://johnarndt.net/skills/safe-cutover) |
| [`cve-triage`](john-lab/skills/cve-triage/SKILL.md) | Sort advisories into exploitable, mitigated and noise by how the code really uses each package, then patch in batches. | [Read](https://johnarndt.net/skills/cve-triage) |
| [`store-submission-kit`](john-lab/skills/store-submission-kit/SKILL.md) | A per-app folder with reviewer notes, device recordings and precise rejection replies for the App Store and Google Play. | [Read](https://johnarndt.net/skills/store-submission-kit) |
| [`verify-release-readiness`](john-lab/skills/verify-release-readiness/SKILL.md) | Connect the intended source, current live state, required gates, deployed components, and observed behavior in a dated release report. | [Read](https://johnarndt.net/skills/verify-release-readiness) |
| [`recover-document-job`](john-lab/skills/recover-document-job/SKILL.md) | Retrieve the existing result before retrying, then separate replay evidence, source checks, and present spending. | [Read](https://johnarndt.net/skills/recover-document-job) |
| [`writers-room`](john-lab/skills/writers-room/SKILL.md) | A scout, critics, a showrunner, a copywriter and a blind persona panel turn sources into a teleprompter script. | [Read](https://johnarndt.net/skills/writers-room) |
| [`podcast-room`](john-lab/skills/podcast-room/SKILL.md) | Pitchers, a showrunner with a facts ledger, one segment at a time, and a transcript diff on every recording. | [Read](https://johnarndt.net/skills/podcast-room) |
| [`video-character-swap`](john-lab/skills/video-character-swap/SKILL.md) | Replace one person in real footage with a character from reference images, keeping every other person, the background, graphics and audio original. Ships with its scripts. | [Read](https://johnarndt.net/skills/video-character-swap) |
| [`hundred-to-ten`](john-lab/skills/hundred-to-ten/SKILL.md) | Write 100, score them on a rubric, cut 20% a round through a new lens each time, and keep the best 10. | [Read](https://johnarndt.net/skills/hundred-to-ten) |

## Status

Version 0.1.0. These are drafts. The workflows behind them have been run on real products, but the packaged skills are new. Try each one on a small task you can check before relying on it, and please open an issue when one triggers at the wrong time or gets something wrong.

## What these skills do and don't do

- Every skill except `video-character-swap` is instructions only: no hooks, scripts, MCP servers or network calls of their own. They use whatever tools your Claude session already has.
- `video-character-swap` includes Python and shell scripts you run yourself. Its one-time setup downloads SAM2.1 weights from Hugging Face; the video edit runs on Sunra and costs credits, which the skill quotes and waits for your OK on. Read `scripts/` before running them.
- They don't grant permissions. Skills that touch releases, DNS, app stores or payments stop at a report or draft and leave sign-ins, payments, sends and deploys to you.
- No credentials belong in any skill, and none are included.

## Related

Business-operations skills (feedback inbox, signup alerts, claim audit and more) live in the Soxoa Ops plugin at [johnarndt/soxoa-claude-plugins](https://github.com/johnarndt/soxoa-claude-plugins).

## License

MIT. See [LICENSE](LICENSE).
````