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

spike

/spike

Prowadzi spike jako wywiad z użytkownikiem: przygotowuje pytania, zadaje je partiami i zapisuje odpowiedzi do rozstrzygnięcia celów.

Repozytorium
JoDi-SDD ↗
Licencja
MIT
Ostatnia zmiana repozytorium
12.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
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 12.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 robi i kiedy

Prowadzi spike jako wywiad z użytkownikiem: przygotowuje pytania, zadaje je partiami i zapisuje odpowiedzi do rozstrzygnięcia celów.

Argumenty

/spike <spike ID | topic> [new information]
Oryginalny opis (EN)

Run a spike as an interview with the user. Prepares a briefing and questions with the spike-researcher agent, asks them in small batches, records answers and any information the user adds as it comes, and keeps going until the spike's goal questions are resolved. Use for any spike spec, any PLAN.md Phase 0 spike, or whenever the user adds information about an active spike.

Jak działa

  1. Autonomous rules
  2. 1. Open the spike
  3. 2. Prepare
  4. 3. Take in information
  5. 4. Ask
  6. 5. Resolve
Sekcje z nagłówków SKILL.md, w oryginale · 66 linii, 1 209 słów
Podgląd SKILL.md
---
name: spike
description: Run a spike as an interview with the user. Prepares a briefing and questions with the spike-researcher agent, asks them in small batches, records answers and any information the user adds as it comes, and keeps going until the spike's goal questions are resolved. Use for any spike spec, any PLAN.md Phase 0 spike, or whenever the user adds information about an active spike.
argument-hint: <spike ID | topic> [new information]
---

# Spike

Input: $ARGUMENTS

A spike is resolved together with the user. You and the spike-researcher agent find everything that can be looked up; the user supplies what only they know or decide. Keep the loop going across turns until the spike is resolved or the user stops. The spike file is the single record: anything learned that is not in it is lost.

**Runtime mode.** Run `jsdd mode` first. The decision points below are marked with their gate, like (gate `spike.question`). When you reach one, `jsdd gate <gate>` gives its policy. `ask`: a person decides, as the step says; in `manual` mode every gate asks. `auto`: pass it by the gate's rule in "Autonomous rules" below (in `autopilot` mode a person runs this skill before the run starts, so its gates ask, or park where `jsdd gate` says so), and record the decision as `auto: <gate>` with what passed it, never as a person's; when the rule cannot pass it, park. `park`: ask nobody and guess nothing. Run `jsdd park <ID> <gate> "<what a person must decide>"`, release your claims, run `jsdd status --write`, and stop (inside `/jsdd:auto`, go to its pull request step). In a mode other than `manual`, `autopilot`, and `autonomous`, stop and tell the user that this skill does not support it.

## Autonomous rules

In `autonomous` mode (see `/jsdd:auto`), a run takes a spike only when the charter's `types` lists `spike`, and resolves only what the docs, the code, and research can answer. Nobody is asked anything.

- **Dependencies** (gate `depends.override`): park.
- **Questions** (gate `spike.question`, parks in every preset): prepare as in step 2, but tell the `spike-researcher` to settle every question it can from the repository and current documentation, and to list as questions for the owner only what needs a person (a preference, a budget, a priority, a fact only the team knows). Take its answers in as step 3 does, as **facts** with sources. When a question for the owner is left, write it under "Questions for you" and park at `spike.question` naming it; the spike stays `in-progress` with everything researched so far.
- **Resolve** (step 5): only when every goal question is answered by facts. A recommendation that follows from facts alone (one option meets a stated constraint and the others do not) is written with its sources and recorded as a DEC row whose why ends with "(auto: spike.question, researcher)". A choice between options that each meet the constraints is the owner's: park at `spike.question` with the options and the recommendation, and record nothing in `docs/decisions.md`.
- **Finish** commits as `[<ID>] Spike (auto)`; there is no report to a person. Then `/jsdd:auto` goes to `/jsdd:verify <ID>`.

## 1. Open the spike

- If the input starts with the ID of a spike spec, open `specs/<ID>-*/spec.md`.
- Otherwise find the matching spike in the `BACKLOG.md` "Spikes" section, by topic. Check `jsdd status` for an existing spec on it. If there is none, create one with `jsdd new spike "<title>"` and fill in the frontmatter (`phase: 0`, `depends_on` with the spec IDs of the spikes it depends on, if they exist, and `refs` with the BACKLOG and PLAN items), Why, and Goal questions (one checkbox per question from BACKLOG.md, numbered G1, G2, …).
- Claim it: `jsdd claim <ID>`. Keep the claim for as long as the interview runs in this session. If another session holds it, do not interview: write any notes the user gave into the spike's Inbox (change only that section), tell the user who holds the spike, and stop. If the claim is shown as stale and the user confirms that session is gone, take it over with `jsdd release <ID> --force` and claim again.
- If a spec in `depends_on` is not `done`, say so and ask whether to go ahead (gate `depends.override`).
- Read the ND rows in `docs/decisions.md` "Still open" that the spike settles (named in its Why or its BACKLOG entry).
- Any text after the ID is new information from the user: take it in (step 3) before anything else.

## 2. Prepare

Do this in the first session, and again whenever no question in "Questions for you" is open while goal questions remain.

- Launch the `spike-researcher` agent with the spike file path (and, when preparing again, a focus on the goal questions still open).
- Write its Briefing and Researched sections into Briefing, keeping the sources. Write its questions into "Questions for you", numbered after the existing ones (Q1, Q2, …), each one a checkbox. Put its "Things to try" into Follow-ups or ask the user whether to run them now.
- If the status is `draft`, set it to `in-progress`. Add a changelog line and run `jsdd status --write`.

## 3. Take in information

Information arrives as answers to questions, text after the ID, notes in the Inbox section, or anything the user says about the topic during the session. For each piece:

- Append it to the Log: date, source (answer to Q3, note from the user, inbox, research), and the content, condensed but keeping the user's specifics (names, numbers, links, wording of constraints) exact.
- Update Findings under every goal question it affects, labelling each point as a **decision** (by the user), a **fact** (with source), or an **assumption** (to be confirmed).
- Tick the questions it answers. If the user skips one, tick it and append `(skipped: <reason>)`.
- New questions it raises: look up facts yourself, or launch spike-researcher with that focus for anything substantial, and log the result. Add questions only the user can answer to "Questions for you".
- If it contradicts something earlier in the Log, point out the conflict and ask which holds.
- Remove processed items from the Inbox.
- Tick a goal question once its Findings answer it completely.

## 4. Ask

- Show one progress line: goal questions answered n of m, questions for the user still open k.
- Ask the next 3 or 4 open questions, highest priority first (gate `spike.question`). Use AskUserQuestion for questions with real options (the suggested option first, labelled Recommended). Ask open-ended questions in chat as a short numbered list, with the context the user needs to answer.
- Never ask what the docs or research can answer.
- Once per session, remind the user that they can add anything at any time, in chat, after the ID (`/jsdd:spike <ID> <notes>`), or in the spike's Inbox section.

Then wait. When the user replies, go back to step 3.

## 5. Resolve

When every goal question is ticked:

- Draft "Recommendation and decisions" (one row per decision, alternatives, and why) and Follow-ups, and show them to the user for agreement. Revise until they agree.
- Write each agreed decision to `docs/decisions.md`: move its ND row from "Still open" to "Decided" as a `DEC-nn` row, with the same reasoning, and tick the BACKLOG item (`/jsdd:verify` checks both).
- Tick the first deliverable, release the spike (`jsdd release <ID>`), run `jsdd status --write`, and suggest `/jsdd:verify <ID>` to close the spike and update BACKLOG.md and PLAN.md.

If the user stops before that, leave the file consistent (Log and Findings up to date, Inbox processed, status `in-progress`), release the spike, and report what is left.

Wersje

RepozytoriumWynikLicencja
Ta strona · JoDi-27/JoDi-SDD90MIT
DroBov1Tya/dusk_code100MIT
hashintel/labs100MIT
kjgarza/marketplace-claude100MIT
cryndoc/polisade-orchestrator100Apache-2.0
srstomp/pokayokay100MIT
uta2000/feature-flow100MIT
juanchaopan/dev-workflow90MIT
petekp/claude-code-setup81MIT

Migawka bazy z 13.11.2026 · wersja paczki 3aca2ed0ff6d (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

  • 100conduct-spike
    Prowadzi interaktywnie spike ograniczony czasowo: zmniejsza niepewność przez dyskusję, badania agenta i małe prototypy, a wynik zapisuje w pozycji roboczej spike'a.
  • 100spike-test-setup
    Prawdopodobnie konfiguruje testy skokowe obciążenia (spike test) w ramach testów wydajności.
  • 100dx-create-spike
    Zakłada w GitHubie spike, czyli ograniczony czasowo research na jedno pytanie, zanim zespół zaangażuje się w pracę.
  • 100spike-contract
    Formułuje spike tak, by jego wynikiem była decyzja: pytanie, najtańszy eksperyment, kryterium liczbowe i zmierzony wynik.
  • 90pfb-spike
    Bada możliwą funkcję przed specyfikacją przez wywiad i eksperymenty, a werdykt Go, warunkowy Go lub No-Go zapisuje w pliku.
  • 100ai-feasibility-spike
    Pomaga przetestować funkcję AI na prawdziwym modelu przed PRD i opisać wynik jako notatkę o decyzji lub dowód walidacji.

Uwagi i zgłoszenia

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