Parallel Build Planner: File Leases & Waves for Multi-Agent

Running two or three coding agents at once is easy. Getting a working app out of it isn't: they edit the same files, build against adapters nobody wrote, and each passes its own tests while the feature never connects end to end. This skill writes the plan that prevents all three.

What it does

• Writes SESSION-NN.md prompts. Each is self-contained, with front matter that's a contract: Owns (the exact paths it may write, which is also its git add pathspec), Reads, Depends on, Concurrent with and Resources.
• Adds 2–6 checkpoints per session. Each is a real commit where the tree builds and the tests pass, so a dead session resumes from checkpoint four, not zero.
• Writes STATE.md: a wave plan (which sessions run in parallel, and why it's safe), dependency graph, capability readiness and design decisions.
• Writes RUN.md: copy-paste launch lines per wave for separate terminals, git worktrees, background agents or subagents.
• Writes EXECUTE.md: the protocol every session follows, so even an agent without this skill installed stays in its lease, commits correctly and hands off cleanly.
• Writes PROGRAM-CONFIG.md: stack, module registry with import edges derived from real code, and test commands that actually scope.

How it works

1. Ingest your spec, PRD, RFC, bug list or plain-English intent, plus prior state and review findings (each one gets a disposition; none get silently dropped).
2. Analyse the codebase and verify every symbol, path and flag the plan will name.
3. Plan capabilities first, leases second. Trace each user journey end to end, then cut 3–8 coherent sessions by column, not by layer.
4. Run the seam preflight on every consumer session: does the producer exist, does its output fit, is the meaning preserved, what proves the real path?
5. Run the D1–D7 preflight before calling the plan ready: coverage, fact origins, ownership, leases, dependencies, early integration, runtime wiring.

Frameworks & tools

Any language or stack. Requires git for checkpoint commits. Works with any parallelism: terminals, worktrees, background agents or subagents.

Why this beats prompting it yourself

"Break this into tasks" gets you layer-wise tickets (all backend, then all frontend) that only integrate at the very end. This skill enforces opinions earned the hard way: only three legitimate reasons to split a session, no verification-only or "foundations" sessions, literal path-by-path lease checks, an early end-to-end journey through the real transport, and riskiest-premise-first scheduling.

Use cases

• Run 2–5 Claude Code, Codex or Cursor agents in parallel on one feature.
• Turn an App Blueprint (or any spec) into an executable build plan.
• Plan a large refactor so parallel work never collides.
• Give each git worktree a session whose merge can't conflict.

Known limitations

Plans only; it doesn't execute sessions (Parallel Build Orchestrator does that). Needs a git repo. Best for features of 1–8 sessions. Very large programs should be planned one feature at a time.