spike
/spike
Prowadzi spike jako wywiad z użytkownikiem: przygotowuje pytania, zadaje je partiami i zapisuje odpowiedzi do rozstrzygnięcia celów.
- Autor
- JoDi-27 ↗
- Repozytorium
- JoDi-SDD ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 12.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 12.11.2026, bez odwołań do wycofanych modeli i API.
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
- Autonomous rules
- 1. Open the spike
- 2. Prepare
- 3. Take in information
- 4. Ask
- 5. Resolve
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
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · JoDi-27/JoDi-SDD | 90 | MIT |
| DroBov1Tya/dusk_code | 100 | MIT |
| hashintel/labs | 100 | MIT |
| kjgarza/marketplace-claude | 100 | MIT |
| cryndoc/polisade-orchestrator | 100 | Apache-2.0 |
| srstomp/pokayokay | 100 | MIT |
| uta2000/feature-flow | 100 | MIT |
| juanchaopan/dev-workflow | 90 | MIT |
| petekp/claude-code-setup | 81 | MIT |
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.