Przejdź do treści
Biblioteka skilli
Zarządzanie i produkt · Planowanie

handoff

/handoff

Przygotowuje spec odwrotnej inżynierii do budowy: zatwierdza ADR, wybiera silnik budowy i zapisuje plan w kolejności zależności.

Repozytorium
rspec ↗
Licencja
MIT
Ostatnia zmiana repozytorium
11.11.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
2
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 11.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.

Co robi i kiedy

Przygotowuje spec odwrotnej inżynierii do budowy: zatwierdza ADR, wybiera silnik budowy i zapisuje plan w kolejności zależności.

Oryginalny opis (EN)

This skill should be used when the user runs /rspec:handoff or asks to get the reverse spec ready to build, plan the build, or hand the spec to a coding agent. Gets the ADRs approved, picks the build engine (sdlc or Claude Code), writes <spec>/build-plan.md in dependency order and adds a build section to CLAUDE.md.

Jak działa

  1. 0. Open unknowns
  2. 1. ADR approval gate
  3. 2. Build engine
  4. 3. Build plan
  5. 4. Cutover plan (modernize track only)
  6. 5. Production readiness (when goal is production, which the modernize track defaults to)
  7. 6. CLAUDE.md section
  8. 7. Finish
Sekcje z nagłówków SKILL.md, w oryginale · 65 linii, 1 570 słów
Podgląd SKILL.md
---
name: handoff
description: >
  This skill should be used when the user runs /rspec:handoff or asks to get the
  reverse spec ready to build, plan the build, or hand the spec to a coding agent.
  Gets the ADRs approved, picks the build engine (sdlc or Claude Code), writes
  <spec>/build-plan.md in dependency order and adds a build section to CLAUDE.md.
metadata:
  version: "0.12.0"
---

# /rspec:handoff

Requires stage `tech`, a finished audit (`<spec>/audit/summary.md`; run `/rspec:audit` first) and a settled verify (`<spec>/verify/summary.md`, or `reference.run.kind` `none`; run `/rspec:verify` first). Without verify, every criterion stays at level 1 or below: say so in the build plan's header. Run `python3 ${CLAUDE_PLUGIN_ROOT}/scripts/progress.py . --build-order` first; on resume, do only what `pending` lists; `build-plan` pending at this point while a plan exists means the engine is sdlc and a slice not yet started has more than 10 criteria (e.g. the engine changed after the plan was cut): keep the slices already mapped in `build.slices` as they are, re-cut the rest after them, and number on (`adr-approval`, `build-engine`, `build-plan`, `cutover-plan`, `claude-md`; with `production`, also write the readiness checklist if missing).

## 0. Open unknowns
Always, on a resume too (it is not in `pending`): run `python3 ${CLAUDE_PLUGIN_ROOT}/scripts/check_spec.py .`. For each `unknowns.yaml: U-<nnn> is open and blocks in-scope …` line (a warning before stage `handoff`, an error from it on, e.g. on a re-run), settle the unknown before anything else, so it ends `resolved` or `accepted`, never still `open`:
- A source answers it: fix the criterion (text and tag), and set `status: resolved` with a one-line `resolution` and the `evidence` (URL or `path:line`).
- Otherwise ask the user (AskUserQuestion, up to 4 per question) whether to build on the criterion as written. Yes: `status: accepted`, `decided_by: "<user name>, handoff <date>"`. No: ask what it should do instead, rewrite the criterion to that (or strike it), decide a deliberate difference from the original as a departure (`/rspec:stories`' departures step), and set `status: resolved` with `resolution: "decided by <user name> at handoff: <what>"` and `evidence: ["<user name>, handoff <date>"]` (plus the `D-<nnn>` when there is one).
- In every case remove the story's `- U-<nnn>:` line from `## Open questions` (write `- none` if it was the last).
Under autopilot, stop on them like any parked decision. From stage `handoff` on, `check_spec.py` reports an open in-scope unknown as an error.

## 1. ADR approval gate
- List every ADR in `<decisions>/` with status `Proposed`: title, the recommended decision in one line, and the main alternative.
- Ask the user to accept, change or reject each (one AskUserQuestion round, up to 4 per round). Update each ADR's `Status` to `Accepted` or `Rejected`, and its Decision section if they changed it.
- Once the ADRs are decided, re-read `<spec>/nfr.md` against the accepted ones and update any NFR an accepted decision rules out (say from which release it applies, or drop it with a reason); under autopilot, log each change.
- Once the ADRs are decided, write the stack from the accepted stack ADR into `<spec>/rspec.json` → `stack` (one line, e.g. "Next.js 15 + TypeScript, SQLite, Vitest") and the accepted deployment target into `deploy` (when it was undecided), so sdlc setup and the build use the same stack.
- Do not continue while any ADR is `Proposed`. Never accept one on the user's behalf. If `autopilot.enabled` is true in `rspec.json`, do not ask: apply the user's rule in `autopilot.rules` (see the Autopilot section of the pipeline skill), record the decision in `<spec>/autopilot-log.md`, and park anything the rule does not cover. With rule `park`, stop here.

## 2. Build engine
Ask once (AskUserQuestion; under autopilot use `autopilot.rules.build_engine`) how the rebuild will be built, and record it in `<spec>/rspec.json` as `"build": {"engine": "<sdlc|claude-code|none>", "slices": {}}`:
- **sdlc** (offer first, as recommended, when the `sdlc:start` command or `sdlc:orchestrator` skill is available in this session): sdlc defines, builds, reviews and ships each slice; `/rspec:pipeline` drives it slice by slice.
- **claude-code**: build directly from the plan, tracking `status` in the story files.
- **none**: no build is started; still write the plan and the CLAUDE.md section, so whoever builds later has them.

If the choice is sdlc, first write the PRD (2a below). Then, if `.sdlc/config.json` is missing, run `/sdlc:setup` now with the Skill tool (`sdlc:setup`); under autopilot, skip this and leave it to the build stage, which pauses for it. Tell it to use the stack in `rspec.json` → `stack` (the accepted ADR's choice) and the deployment target in `deploy` (sdlc setup asks where it deploys), and that the repo holds a reverse-engineered SRS in `<spec>/` (not code), that a PRD already exists at `<docs>/prd.md` (written in step 2a; setup's "a PRD already exists" path: use it as is), and that the API contract is `<contracts>/openapi.json` (in a monorepo: `packages/api-contract/v1/openapi.json`, so the contract check's spec file is `openapi.json`). Follow setup through its own questions, then continue here.

### 2a. PRD (engine sdlc)
Do this before `/sdlc:setup` runs, here or at the build stage: write `<docs>/prd.md`, where `<docs>` is sdlc's docs folder: `docs_dir` in `.sdlc/config.json`, else `docs/sdlc`. Never overwrite an existing `<docs>/prd.md`. Use the sections of sdlc's PRD template, in this order: Problem, Users and audience, Goals and non-goals, Core capabilities, Constraints, Success measures, Voice and brand (only when the product has a UI), Open questions. Each section is a short paragraph plus links into the SRS, never a second summary of it: goals and scope link `<spec>/README.md`, capabilities link `<spec>/features.md` (the MVP release; Drop rows are the non-goals), constraints link `<spec>/nfr.md` and the accepted ADRs. Paths in the links are relative to `<docs>/`.

If sdlc is not available but the user wants it, say how to install it and record `claude-code` until they do.

## 3. Build plan
Write `<spec>/build-plan.md` from `${CLAUDE_PLUGIN_ROOT}/templates/build-plan.md`:
- Take `order` from the progress output: every feature in scope, MVP first, dependencies first. Keep that order.
- Group into releases: `## Release 1: MVP` holds every MVP feature; the Later features follow in releases 2 and up, each a coherent increment a user would notice (e.g. "Planning: cycles and projects"). Group a release around one area or module where the dependencies allow, rather than following `order` blindly across modules; a feature still never comes before one it depends on. A release heading and its one-line goal name no feature IDs.
- Group consecutive features into vertical slices by a criteria budget: without sdlc, about 30 acceptance criteria per slice (one build session can finish and test it); with sdlc, as many as needed so that no slice has more than 10 acceptance criteria (sdlc takes about 10 per change), and a story with more than 10 is a slice of its own, each ending in something a user can try (e.g. "sign in and create a workspace", "create and list issues"). The first slice is the thinnest end-to-end path.
- For each feature list its story file, its criterion IDs (the active ones, from `<spec>/criteria.lock.json`), the `operationId`s and schemas whose `x-features` include it, and the NFRs that name it or `all`. Name the acceptance bundle `<spec>/acceptance/` once at the top. `check_spec.py` warns about a slice that leaves out a criterion ID of its features.
- Under each slice, list its `accepted` unknowns from `<spec>/unknowns.yaml` (any that name one of its criteria or features) as known risks: ID, question and who accepted it; write `Known risks: none` when there are none.
- State the "done when" rule for each slice: every criterion with a level 2 test passes that test against the build; every other criterion has a builder test.

## 4. Cutover plan (modernize track only)
Write `<spec>/cutover-plan.md` from `${CLAUDE_PLUGIN_ROOT}/templates/cutover-plan.md` for the chosen `strategy`:
- rewrite: one cutover after the last slice; the build plan's slices build the new system to parity.
- strangler: one cutover step per slice; order slices so each can be routed to the new system on its own.
- refactor: one step per slice inside the existing codebase, each behind a flag.
The Rollback section is required: trigger, steps, and the point of no return. Data steps follow `<spec>/data-migration.md`.

## 5. Production readiness (when `goal` is `production`, which the modernize track defaults to)
Write `<spec>/production-readiness.md` from `${CLAUDE_PLUGIN_ROOT}/templates/production-readiness.md`:
- Keep every category; keep the Cutover category only in the modernize track (delete it for rspec), Parity with the reference only for a rebuild that has a reference to compare with (product-rebuild), and Client app only when something ships to a device or an app store. Tailor items to this product: name the real SLO targets from the NFRs, the regulations that apply to its users, the roles and tenant boundaries to test.
- Mark an item that cannot apply as checked with `(n/a: <reason>)`, e.g. no personal data stored. Never mark anything else done here; the build proves the rest.
- Tell the user the pipeline will hand the open items to the build after the last slice.

## 6. CLAUDE.md section
- Fill `${CLAUDE_PLUGIN_ROOT}/templates/claude-md-sdlc.md` when the engine is sdlc, else `${CLAUDE_PLUGIN_ROOT}/templates/claude-md.md` (working name, the absolute plugin root path, and `<spec>`, `<contracts>`, `<decisions>`, `<changelog>` from `paths` in the progress output) and add it to `CLAUDE.md` at the project root. Create the file if missing.
- If a `<!-- rspec:handoff -->` … `<!-- /rspec:handoff -->` block already exists, replace only that block. Never change anything else in CLAUDE.md.

Features triaged into or out of scope after handoff are added to or removed from this plan by `rspec:features` Triage, not by rewriting it.

## 7. Finish
- Run `python3 ${CLAUDE_PLUGIN_ROOT}/scripts/check_spec.py .` with stage set to `handoff`; fix errors.
- Set `stage` to `handoff`, add a line to `<changelog>`.
- Reply with: the slices (name and feature count), the accepted decisions, and how to start: with sdlc, "`/rspec:pipeline continue` hands slice 1 to sdlc"; with claude-code, "ask Claude to build slice 1 from <spec>/build-plan.md".

Wersje

RepozytoriumWynikLicencja
Ta strona · tammai/rspec90MIT
lumpen-mya/claude-handoff100MIT
generous-corp/pulp100MIT
Ovid/paad100MIT
Ovid/paad100MIT
Ovid/paad100MIT
webdevnerdstuff/claude-marketplace100MIT
terencebristol/terencebristol-toolkit100MIT
verkyyi/claude-fleet100MIT

Migawka bazy z 13.11.2026 · wersja paczki 1d340196e176 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90to-build-brief
    Zamienia zatwierdzoną decyzję w specyfikację do budowy dla agenta, w wersji kodu lub projektu, bez narracji i z testowalnymi punktami.
  • 100spec-generator
    Przeprowadza wywiad o projekcie i tworzy gotowy SPEC.md oraz CLAUDE.md dla Claude Code, a opcjonalnie prywatną specyfikację.
  • 100spec-unit
    Pisze specyfikację jednego etapu budowy na podstawie kontekstu projektu i planu, pytając o niejasne decyzje.
  • 90sdlc-plan
    Zamienia zatwierdzoną specyfikację w plan techniczny z punktami styku, ryzykiem, alternatywami, strategią testów i wdrożenia.
  • 100spec
    Przeprowadza wywiad o funkcji lub projekcie, a potem pisze specyfikację, którą można zbudować.
  • 82write-spec
    Pisze specyfikację docs/SPEC.md na podstawie plików odkryć lub wywiadu z właścicielem i zapisuje decyzję o budowie jako ADR.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.