plan
Turn a clarified requirements artifact into a concrete, executable implementation plan — a decisive architecture blueprint and a phased build sequence with exact file paths. Use after requirements are pinned down (e.g. by `clarify`) and before writing code, whenever a multi-step change needs a design and a task breakdown. Its output feeds `implement`.
- License 许可
- MIT
- 最近更新
- 2026-11-06
- Stars
- ★ 44
- Forks
- 4
01 前言 Front Matter
- name
- plan
- description
- Turn a clarified requirements artifact into a concrete, executable implementation plan — a decisive architecture blueprint and a phased build sequence with exact file paths. Use after requirements are pinned down (e.g. by `clarify`) and before writing code, whenever a multi-step change needs a design and a task breakdown. Its output feeds `implement`.
03 SKILL.md 正文
Plan
Given a clarified requirements artifact, produce an implementation plan concrete enough that someone
with no prior context could execute it. The bar: exact file paths and names, one committed
architecture decision, and a phased build sequence implement consumes step by step — no abstract
advice, no "add appropriate error handling". This is a peer phase: it grounds itself in the code via
explore, picks ONE approach and commits, then hands a plan to implement. It does not clarify
requirements (that's clarify, upstream) and does not write production code (that's implement,
downstream). It does not invoke either.
Process
- Ground in the codebase first. Read the clarified artifact (
clarify's requirements + success criteria), then callexplore(dispatch a sub-agent when available; otherwise inline) and consume its essential-files list andfile:linecitations as the starting set for the existing patterns, conventions, and integration points this work touches. Cite each finding aspath/to/file.ext:line— the blueprint is built on what's actually there, not what you assume. - Decide the architecture and commit. Survey the realistic approaches, then pick ONE and write the decision plus a one-paragraph rationale grounded in the patterns from step 1. Do not hedge with "Option A or B" — a plan is a decision. Record approaches you rejected in one line each only if a reader would otherwise wonder why; don't relitigate.
- Choose the test seams up front. Pick where behavior gets verified, preferring a single highest seam (one integration/end-to-end point) over many low ones. Decide what's tested and what isn't, and capture it in an explicit Testing Decisions section. New behavior gets a test; a bug fix gets a test that fails without the fix.
- Design the components. For each unit of work name the file(s), its single responsibility, and its dependencies on other units. Split by responsibility, not by technical layer; files that change together live together; follow the established structure rather than restructuring it.
- Write the Implementation Map — every concrete create/modify action with its exact path:
Create src/x.ext/Modify src/y.ext:120-150/Test tests/x_test.ext. No file is named only in prose; if it changes, it's in the map. - Sequence the build into phases. Order the work so each phase produces something verifiable,
following dependency order (data/contracts → logic → wiring/config). Emit it as the Build
Sequence checklist below — this is the executable artifact
implementworks through. - Pin the critical details. State the concrete error-handling behavior, state/data shape, and
verification command for each phase. Add an Out of Scope section listing what this plan
deliberately does not touch, so
implementdoesn't wander. - Self-review with fresh eyes. Walk every Success criterion in the clarified artifact and point to the task that satisfies it — list and fix any gap. Scan for placeholders (TBD, TODO, "handle edge cases", a test step with no assertion) and remove them. Confirm names/signatures used in a later task match what an earlier task defines. Fix inline; don't re-review.
Task template
Each unit of work in the Build Sequence follows this shape:
### Task N: <imperative title, no "and">
- **Description:** what this builds and why it's one unit.
- **Acceptance criteria:** 3–5 testable assertions (each checkable by a test, command, or observation).
- **Verification:** the exact command(s) to run and the expected result.
- **Dependencies:** task numbers this needs first (or "none").
- **Files:** Create/Modify/Test with exact paths (mirrors the Implementation Map).
- **Size:** XS · S · M · L · XL.
- [ ] step(s) — one concrete action each (write failing test, implement, run, commit)
Break a task down if it spans more than ~2 hours, needs 4+ acceptance criteria, touches independent subsystems, or has "and" in the title — each of those is two tasks wearing one hat.
Red flags
- Hedging between approaches instead of committing to one decision with a rationale.
- A file named only in prose, or a path written as a placeholder rather than the real one.
- "Add appropriate error handling / validation / edge cases" — say the concrete behavior instead.
- A test step with no assertion, or a "see Task N" cross-reference instead of the actual content.
- Missing Testing Decisions or Out of Scope sections, or many low test seams where one high one fits.
- A Success criterion from the clarified artifact with no task that satisfies it.
- Clarifying requirements, writing production code, or invoking
clarify/implement— all out of scope.
Verification checklist
- [ ] Every blueprint finding cites
file:linefrom a realexploreof the codebase. - [ ] Exactly one architecture approach is chosen, with a grounded rationale — no hedging.
- [ ] Test seams are chosen up front and captured in a Testing Decisions section.
- [ ] The Implementation Map lists every create/modify/test action with an exact path.
- [ ] The Build Sequence is a phased checklist in dependency order, each phase independently verifiable.
- [ ] Every task fits the template and the "break it down if" thresholds; none has "and" in the title.
- [ ] Each Success criterion in the clarified artifact maps to a task; no placeholders remain.
- [ ] An Out of Scope section bounds what the plan deliberately leaves untouched.
- [ ] The skill stayed in scope: no requirement clarification, no implementation, no downstream invocation.
04 同仓库更多 Skills
write-like-me
Write or edit prose in author's voice, or check that a draft sounds like them. Use for blog posts, design and strategy docs, PR descriptions, commits and review comments, chat / agent instructions, peer feedback, or any first-person writing on their behalf, and whenever an agent is producing text that will go out under their name and needs to sound like them, not like a generated reply.
validate
Verify a change is ready to ship by checking it against its acceptance criteria and running the repo's own quality gates in order, then report a pass/fail verdict with the exact failures. Use to decide go/no-go right before shipping — when you want a pass/fail verdict against acceptance criteria and the repo's quality gates (lint/build/test), not a code critique (use `review` for that). It reports — it does not fix (route failures to `pr-fix`/`implement`) and does not ship.
todo
Capture, list, and complete repo-scoped todos
tl
Manage a Relay program as the CEO-facing tech lead: shape goals and contracts, prioritize dependency-aware work, dispatch senior worker agents, and surface every decision without writing production code or merging.
stack-ship
Use only for a standalone stack explicitly launched with `relay --workflow stack-ship`; never invoke inside a tech-lead-managed Relay program. Decompose one goal into small PRs, delegate build and monitor work, surface author decisions, and auto-merge only after human approval.
simplify
Reduce complexity in recently changed code — cut needless abstraction, dead code, and duplication; improve names and structure — WITHOUT changing behavior. Quality only; it does not hunt for bugs (use review for that). Use after implementing a chunk of work, before review, or whenever a diff feels more complicated than the problem it solves. Triggers on "clean this up" / "tidy this" / "refactor this" when code already exists; for an underspecified goal with no code yet, use `clarify`.