Skip to content
Skills Library
Management & product · Planning

developing-versions

/developing-versions

Runs a product version (app, game, service, site) from spec to release in thin slices: spec, foundation, one slice per stage, reviews where they pay, triage of notes, hardening. Use when a product or version starts or is planned, a slice is planned or closed, notes arrive mid-version, or before declaring a version finished.

Repository
workproof ↗
Licence
MIT
Last repository change
11.11.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 11.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Runs a product version (app, game, service, site) from spec to release in thin slices: spec, foundation, one slice per stage, reviews where they pay, triage of notes, hardening. Use when a product or version starts or is planned, a slice is planned or closed, notes arrive mid-version, or before declaring a version finished.

Original author description

Runs a product version (app, game, service, site) from spec to release in thin slices: spec, foundation, one slice per stage, reviews where they pay, triage of notes, hardening. Use when a product or version starts or is planned, a slice is planned or closed, notes arrive mid-version, or before declaring a version finished.

How it works

  1. When it applies
  2. Where facts live
  3. Phase 0. Spec
  4. Phase 1. Foundation
  5. Phase 2. One slice per stage
  6. Reviews: only where they pay
  7. Time budgets
  8. Triage
  9. Phase 3. Hardening, sized to the version
  10. Phase 4. Learn
Original SKILL.md headings · 79 lines, 1,308 words
SKILL.md preview
---
name: developing-versions
description: "Runs a product version (app, game, service, site) from spec to release in thin slices: spec, foundation, one slice per stage, reviews where they pay, triage of notes, hardening. Use when a product or version starts or is planned, a slice is planned or closed, notes arrive mid-version, or before declaring a version finished."
---

# Developing versions

If `${user_config.flow_map}` is false, this module is off: ignore this skill.

Ship the smallest useful version with quality, then improve it version by version. Every step, check and document must pay for its time; leave out what does not.

## When it applies

- A new product, or a version: a release that was ordered (1.0, an update). Version 1 holds the main flow and what it needs; the rest goes to the SPEC's "Later" list.
- A version's stages go into the project's open plan, or into a new plan once that one is finished (skill `workproof:working-in-stages`; `work-plan new` refuses while a plan exists). A one-step fix needs no stage. With the proof plans module off, keep the same stages in the project's own plan document.
- A project without a flow map (no `docs/FLOWS.md`) follows the same phases: the SPEC's flow table is its list of flows, each slice's done-when names the test command that proves its flows instead of `check-flows`, and the gate reads that table. Start a map (`check-flows --init`) when the flows outgrow one table.

## Where facts live

| Fact | Home |
|---|---|
| Purpose; the version's flows and their criteria; "Later"; data model and architecture boundaries; technology and why; budgets; threats; risks; slice order with each slice's risk and the milestones | `docs/SPEC.md` (a game: `docs/GDD.md`): current truth only, a page or two per version |
| A criterion | one testable sentence: "When <event>, the <product> shall <response>" |
| Why a decision was taken | `docs/DECISIONS.md`, one line each |

An existing spec or plan document is not rewritten up front; it shrinks as each slice corrects the part it touches. The plan, the flow map and open findings keep their homes (skills `workproof:working-in-stages` and `workproof:mapping-flows`). Templates: `references/templates.md`.

## Phase 0. Spec

1. One short round with whoever decides the product: what it does, its main flow, the version's scope. A new product, or a version that changes the look, also picks from two or three rendered directions of the main screen.
2. The SPEC decides now only what is expensive to change later: the look, the data model, the architecture boundaries, the budgets. The rest is decided in its slice. Budgets are three to five numbers the product can break (launch, a hang, frame time, p95 latency, data at scale); threats take a few lines, sized to the product.
3. A risky product (accounts, money, personal data stored or shared off the device, a security boundary) gets one independent review of the SPEC by a reader who did not write it.
4. The decision maker approves a short summary: the flows and what is out.

## Phase 1. Foundation

- One command builds and one runs the tests; one green test of each kind the project uses.
- The project's instructions hold its three loop budgets (below).
- The version's flows enter the map before their code (skill `workproof:mapping-flows`, then `check-flows --from-cache`).
- The look's tokens and base components; the main flow's thinnest path through every layer, running.
- A spike only for a real unknown; a scale fixture or benchmark only for a budget the product can break.
- An existing product only adds its flows, its spikes and any changed tokens.

## Phase 2. One slice per stage

1. **Contract.** Title: the slice, its flow IDs and its risk. Risky: it touches accounts, money, personal data leaving the device, a security boundary, a stored-data migration or concurrency; small: copy or layout only; normal: the rest. Done-when: "F-... `validated` and `check-flows --check` exits 0; the budgets the slice reaches, by their test". Test names live only in the map.
2. **Core first:** rules, data, services. Tests first where the behavior is known.
3. **Screens** over the core: every state the flow reaches, every language the product ships, the look, labels on new controls.
4. **Proof:** the reached tests and the flow check for the change (skill `workproof:mapping-flows`); each proven flow's `Entry` cell names its files; captures looked at.
5. **Close:** the SPEC corrected if the product changed; the plan text the slice used up deleted; `work-plan done` with the review dispositions and who found each defect in `--result`; the commit.

A slice starts from a green main; after another lane merges, the flows that merge reached run first.

- **A slice's proof is short:** unit, property and loopback tests that finish in seconds, written with the code. The rule for long and repeated runs and for a flaky test is in skill `workproof:working-in-stages` (step 1): they belong to hardening, never to a slice's done-when. Here that covers soak, leak and sustained-rate runs, long latency or throughput measurements and fuzzing; the exception is a spike whose measurement picks the architecture. A defect a hardening run finds outside the current flow joins hardening unless it blocks the next slice.
- **After a merge,** run the tests the merge reaches (the changed packages and those that depend on them); the whole suite runs at each milestone.

## Reviews: only where they pay

- **A risky slice:** one independent review of its contract and core, started in the background once the core's tests are green, while the screens go on; its findings become `[defect]` stages.
- **Everything else:** one pass per milestone over the slices since the last pass; at hardening, one over what no pass covered.
- **The brief:** `references/templates.md`. It forbids building and running tests, which a reviewer agent may otherwise do: this review runs beside the session, whose own runs hold the build folder and the machine.
- A review pass whose findings were all declined or style for two versions is cut at the retrospective.

## Time budgets

- Wall clock, build included. Targets: the reached unit cases after an edit under 30 s; a slice's reached UI flows under 5 minutes; the gate before a release or a merge under 10 minutes. A loop already over its target keeps its measured time as its budget until a stage brings it down.
- A loop that grows past its budget becomes a `[defect]` stage, taken right after the current slice: profile it first, then apply the remedy.

## Triage

- **A failure:** a core test red means the core. Core green and a UI test red: reproduce it at the core's boundary with the UI's input (a unit test, or a route test for a service); red there means the core lacked a test and both get fixed; green means the screens. All green but wrong on the real target: a missing test, written at the lowest level that shows the defect.
- **A note from the decision maker** becomes a stage tagged with its class: `[defect]` fixed now, with a test that failed before; `[change]` updates the SPEC and reopens or adds a slice; `[refinement]` (look, wording, feel) built at once when it fits one build, otherwise kept for hardening; `[idea]` goes to "Later" and enters only on their word, with what it displaces said.

## Phase 3. Hardening, sized to the version

- **Version 1 or a store release:** the full runs the project asks for at a finish; budgets measured on the real target; the review pass, with the threats across the whole surface in its brief; dependencies and secrets; accessibility, languages, privacy and store rules.
- **An update:** the same, limited to what the update reached.
- **Gate:** no flow `broken`, `revalidate` or `no proof`; each `device only` flow walked on the real device; open findings empty or each accepted by the decision maker; their walk of the build.

## Phase 4. Learn

The closing report gives stages by tag, defects by who found them, findings per review pass and the slowest loop against its budget. What found nothing is cut and what let a defect through is tightened.
Files in this package (2)
  • SKILL.md 8 KB
  • references/templates.md 1 KB

Versions

The database has no other skills named developing-versions.

Database snapshot: 13.11.2026 · package version 49b22b4883cf (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100build-feature
    Builds one roadmap slice from its spec. Gates first, and stops when a load-bearing decision is still unmade; then builds, self-checks, ticks the spec's build plan and moves the roadmap. Use to build or resume a slice ("build 03", "continue the checkout slice").
  • 90slice-handoff
    Close out a finished slice of an epic before the next one starts. Sorts everything the slice left open (follow-up tickets, deferred bugs, unautomated scenarios) into the next slice, before release, or later; keeps one Carry-over comment on the epic; runs every test in the epic…
  • 100eventmodeling-planning-slices
    Lists the delivery slices of an event model and writes the delivery status of each slice. For each slice, it reports the events that the slice uses and produces, its upstream and downstream slices, and its contract (precondition and postcondition). Use it when someone asks to…
  • 100version-start
    Open a version from the closed Story Map: read the Product Brief and the current release of the Story Map from Confluence, set its open questions aside, have the maintainer confirm each card as a Story or an Epic, create the fix version named after the product and its number…
  • 100task-close
    Close a whole finished task: verify the spec done-conditions, set TASK_STATE.md to its final closed state, and move the folder from active/ to archive/. Use when all slices are closed, the work is merged or explicitly waived, and the task is ending. Do not use for one slice (use…
  • 100slice-closure
    Decide whether the current slice is ready to close, separating slice completion from task completion, and record the result in slice notes and TASK_STATE.md. Use when a slice was implemented, validated or reviewed and may be ready to close. Do not use before slice…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.