Plan Template

Field	Value
Type	Skill Resource
Source	~/.copilot/skills/plan/references/plan-template.md
Description	Not specified

Source Content

Plan Template

Copy this file and fill every bracketed field. Delete the guidance blockquotes (>) once the section is written. The plan is finished when a fast model with none of your conversation history could pick up any single workstream and execute it to its acceptance criteria.

Contents

• 1. Goal & Definition of Done
• 2. Runtime & Model Routing
• 3. Wave 0 — Shared Contract
• 4. Wave Map
• 5. Workstream Specs
• 6. Parallelizability Check
• 7. Integration & Verification
• 8. Execution Notes

---

1. Goal & Definition of Done

Goal: [One or two sentences — the end state, in plain terms.]

Definition of done (global acceptance criteria): the whole effort is finished when every box is checkable by running the stated command or observing the stated result. No subjective items.

• [Binary criterion — e.g. pnpm test exits 0 across all touched packages.]
• [Binary criterion — e.g. GET /api/health returns 200 with {"auth":"sso"}.]
• [Binary criterion — e.g. the three services each redirect an unauthenticated request to the IdP.]

---

2. Runtime & Model Routing

Runtime: [Claude Code | Codex | other]

Fill the model column for your runtime. The planner writes this plan; executors run the workstreams in parallel; the integrator merges and verifies. Default every executor to the fastest model that can meet its acceptance criteria.

Role	This plan uses	Notes
Planner	[Opus 4.8 / highest-reasoning Codex]	Writes specs + acceptance criteria; run once, up front
Executor (default)	[Sonnet 5 / GPT-5.3-Codex]	One well-specified workstream each, in parallel
Executor (mechanical)	[Haiku 4.5 / fastest capable Codex]	Pattern-copy, high-certainty streams
Integrator	[Sonnet 5 / GPT-5.3-Codex]	Runs the full acceptance suite, resolves seams

Parallel aim: [N] sub-agents at once (target 4). Fan out flat — depth 1; executors do not spawn sub-agents.

---

3. Wave 0 — Shared Contract

Everything the parallel streams depend on. Keep it small — it is serial, and by Amdahl’s law it caps your speedup. Freeze it before Wave 1 starts; it is read-only during the parallel waves.

Owner model: [Planner or one executor]

Deliverables (the frozen interface):

• [Types / schema — e.g. packages/contracts/auth.ts exports Session, Claims.]
• [API contract — e.g. openapi.yaml defines /session; Prism mock serves it.]
• [Scaffolding — e.g. folder layout, shared fixtures, DB migration 0007_add_sso.sql.]

Acceptance criteria:

• [e.g. pnpm typecheck passes on the contracts package.]
• [e.g. the mock server responds to every documented route.]

---

4. Wave Map

Adjust the diagram to your actual waves. Serial parts (Wave 0, integration) are the tax; keep the middle wide. Follow the technical-writing skill (which owns the diagram rules) — distinct shape + muted color per layer — and keep the “what to notice” line.

flowchart TD
    START(("Goal defined")):::endpoint
    subgraph W0["Wave 0 — serial: shared contract"]
        CONTRACT["Types, API schema,<br/>scaffolding, fixtures"]:::serial
    end
    subgraph W1["Wave 1 — parallel: ≤4 independent streams"]
        A["Workstream A"]:::parallel
        B["Workstream B"]:::parallel
        C["Workstream C"]:::parallel
        D["Workstream D"]:::parallel
    end
    subgraph WF["Final — serial: integrate & verify"]
        INT{{"Integration +<br/>full acceptance suite"}}:::gate
    end
    DONE(("Done")):::endpoint

    START --> CONTRACT
    CONTRACT --> A & B & C & D
    A & B & C & D --> INT
    INT --> DONE

    classDef endpoint fill:#f4f0fa,stroke:#6d4fa3,color:#2b2440
    classDef serial fill:#eef2f7,stroke:#4a5b70,color:#22303f
    classDef parallel fill:#e8f1fb,stroke:#2f6096,color:#122c42
    classDef gate fill:#eaf4ee,stroke:#2f7a52,color:#173926

What to notice: the only serial steps are Wave 0 and the final integration gate; everything blue in the middle runs at once. Keep Wave 0 small — the serial fraction is what caps the speedup.

---

5. Workstream Specs

One block per parallel workstream. Duplicate the block as needed. The write-set (Files owned) of any two streams in the same wave must not intersect.

Workstream [A] — [short title]

Field	Value
Wave	[1]
Owner model	[Sonnet 5 / Haiku 4.5 / GPT-5.3-Codex]
Depends on	[Wave 0 contract items, read-only — or a finished prior wave. Never a sibling.]

Outcome: [One sentence, one end-state.]

Files owned (write-set — exact paths, disjoint from every sibling):

• [path/to/file-a.ts]
• [path/to/dir-b/**]

Instructions (exact — leave nothing to invent):

1. [Step, naming the existing pattern to copy — e.g. “Mirror services/foo/auth.ts.”]
2. [Step.]
3. [Step.]

Acceptance criteria (binary, self-checkable by the executor alone):

• [Command + expected result — e.g. pnpm --filter bar test exits 0.]
• [Observable state — e.g. bar redirects an unauthenticated request to /login.]

Out of scope (protects sibling write-sets): [What this stream must NOT touch — e.g. “Do not edit packages/contracts/** (frozen in Wave 0).”]

---

Workstream [B] — [short title]

Duplicate the block above.

---

6. Parallelizability Check

Eyeball the write-sets for overlap before launching. Any intersection means the two streams are not parallel-safe — repartition or move one to a later wave.

Workstream	Wave	Write-set (files/dirs owned)	Reads (from Wave 0 / prior waves)
A	1	[...]	[...]
B	1	[...]	[...]
C	1	[...]	[...]
D	1	[...]	[...]

Pairwise test result: [Confirm no two same-wave rows share a write-set path, and no row reads a same-wave sibling’s output. Note any pair that had to be serialized and why.]

---

7. Integration & Verification

Owner model: [Integrator]

Merge order: [How the streams come together — e.g. “Merge worktrees A–D onto the integration branch in any order; each is independent.”]

Integration steps:

1. [e.g. Wire the per-service handlers into the shared router.]
2. [e.g. Remove the Wave 0 mock; point clients at the real contract implementation.]

Full acceptance suite (the global definition of done, re-run end to end):

• [Every global criterion from §1, run against the integrated system.]
• [Cross-stream check that no single workstream could verify alone — e.g. an end-to-end SSO login across all three services.]

Rollback: [How to back out if integration fails — e.g. “Revert the integration branch; each worktree remains independently recoverable.”]

---

8. Execution Notes

• Isolation: [Same checkout with disjoint files | one git worktree per workstream | mocked contract.]
• Concurrency: launch up to [4] executors in a single message so they run at once. Fan out flat — depth 1.
• On a struggling executor: tighten the spec, don’t escalate the model. If a stream needs judgment mid-flight, it was under-specified — return it to the planner.
• Reporting: each executor returns only the compact result of its workstream (files changed + acceptance-criteria status), not its full transcript.