close-spec

Solid

When a spec under specs/<feature>/ is done shipping (a write-spec build, or any planned task that produced a spec), archive it to specs/done/ and rewrite it from a build-plan into a durable rationale — the why, the principles, the invariants — pointing back to the real code for the how. Use when implementation has landed and the plan no longer matches what shipped, or the user says a feature/spec is finished. Pairs with [write-spec](../write-spec/SKILL.md) (the plan this closes) and [review](../review/SKILL.md) (run before closing).

Testing & QA 41 stars 4 forks Updated yesterday Apache-2.0

Install

View on GitHub

Quality Score: 84/100

Stars 20%
54
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
50
License 10%
100
Description 5%
100

Skill Content

# Close Spec A spec is a **build plan** while you're building and a **rationale record** once you've shipped. Closing flips it from one to the other. The plan was a ladder of slices and predictions; the record is the layer of meaning the code can't hold — why this exists, what it must never break, what you tried that failed. The code is the single source of truth for *how*; the closed spec is the source of truth for *why*, and a map into the code. Do not summarize the implementation. Anyone can read the code. If a paragraph restates what a function does, cut it and point at the function instead. ## Workflow 1. **Confirm it shipped.** The feature is merged or working in-tree and its tests/screenshot gates are green. If slices remain unverified, it isn't done — finish or [review](../review/SKILL.md) first. 2. **Diff plan against reality.** Read the spec's README and slices, then read what actually landed. Note every place the build diverged from the plan: dropped slices, renamed seams, a mechanic that turned out different, an assumption that broke. The divergences are the most valuable thing to record — they're exactly what a future reader would otherwise re-derive. 3. **Move it.** `specs/<feature>/` → `specs/done/<feature>/` (use `git mv`). Single-file specs: `specs/<feature>.md` → `specs/done/<feature>.md`. 4. **Rewrite the README as a record**, not a plan. Keep: - **Overview & purpose** — what shipped and the problem it solves, in present ...

Details

Author
dzhng
Repository
dzhng/duet-agent
Created
3 months ago
Last Updated
yesterday
Language
TypeScript
License
Apache-2.0

Similar Skills

Semantically similar based on skill content — not just same category

Code & Development Solid

write-spec

Break large features into independently verifiable, human-reviewable slices under specs/<feature>/. Use for risky or multi-step feature work that needs upfront questioning, API seams, browser-playable checkpoints, HTML visualizations, screenshot gates, staged implementation plans, recursive fog-of-war reslicing, or proactive research into reference implementations/best practices before slicing. Pairs with your project's verification harness and screenshot gates (the browser checkpoints), [refactor-clean](../refactor-clean/SKILL.md) (review the materialized spec so the plan describes one-owner architecture, not the feature bolted on), [screenshot-critique](../screenshot-critique/SKILL.md) and [compare-screenshots](../compare-screenshots/SKILL.md) (the visual gates), and a code-review pass (audit each slice before it lands).

41 Updated yesterday
dzhng
Testing & QA Solid

implement-spec

Implement an existing spec through committed passes. Use for long or multi-pass specs that need maintenance checkpoints to periodically clean code, handoffs, priorities, and plan bloat before drift accumulates.

41 Updated yesterday
dzhng
Code & Development Solid

spec

Write a feature spec — the "what & why" of a Kandev product feature, before coding. Use for a product feature, or from `/fix` to amend/create the concise behavioral repair spec required before implementation. Do not use for incident postmortems, behavior-preserving refactors, or infra-only work.

494 Updated today
kdlbs