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

create-tickets

/create-tickets

Dzieli zdecydowane punkty fazy P1 albo jeden temat na zgłoszenia i zapisuje pliki dopiero po zatwierdzeniu.

Repozytorium
ThinkMap ↗
Licencja
MIT
Ostatnia zmiana repozytorium
05.11.2026

Ocena i bezpieczeństwo

100/ 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ść35 / 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 05.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

Dzieli zdecydowane punkty fazy P1 albo jeden temat na zgłoszenia i zapisuje pliki dopiero po zatwierdzeniu.

Wyzwalacze z opisu

go ahead

Argumenty

/create-tickets <P1 | P1-F02> [owner]
Oryginalny opis (EN)

Break the decided points of a whole phase (P1) or one topic (P1-F02) into tickets. Shows the proposed breakdown as one table first and writes the ticket files only after an explicit "go ahead". Use it when `thinkmap status` suggests generating tickets, or when the person asks to create tickets, plan the work, or break a phase down.

Jak działa

  1. 1. Load the scope
  2. 2. Gate 1 — propose the breakdown, then wait
  3. 3. Gate 2 — write the files (only after an explicit go)
  4. 4. Check and report
Sekcje z nagłówków SKILL.md, w oryginale · 100 linii, 871 słów
Podgląd SKILL.md
---
name: create-tickets
description: Break the decided points of a whole phase (P1) or one topic (P1-F02) into tickets. Shows the proposed breakdown as one table first and writes the ticket files only after an explicit "go ahead". Use it when `thinkmap status` suggests generating tickets, or when the person asks to create tickets, plan the work, or break a phase down.
argument-hint: "<P1 | P1-F02> [owner]"
allowed-tools: Bash(node "$THINKMAP_CLI" *), Read, Write, Edit, Glob, Grep
---

# /create-tickets — from "decided" to "tickets exist"

> Added to this project from the Thinkmap catalogue (dashboard → Tooling → Add). `$THINKMAP_CLI` is set by the
> Thinkmap plugin when a session starts. If `echo "$THINKMAP_CLI"` prints nothing, the plugin is not active in
> this session: run the same commands as `npx github:dsngeu/ThinkMap <command>` instead.

Arguments: `$ARGUMENTS` — a phase ID (`P<n>`: every topic of the phase in one go) or a topic
ID (`P<n>-F<nn>`: one topic, for additions to a phase that already has tickets), plus an
optional default owner (leave `owner:` empty when none is given).

Two gates. Nothing is written before the second one.

## 1. Load the scope

```
node "$THINKMAP_CLI" json
```

From the graph take the phase (or the topic's phase), its topics (`type: feature`), their
points, and the existing tickets of the phase (`type: ticket`, `id` starting with `P<n>-T`).
If the ID does not exist, say so and list the phases. Read the format rules first:
`docs/plan/FORMAT.md` (§1 for where files go, §6 for the ticket body).

Points to cover: every `decided` point in scope that no existing ticket lists in
`implements` (the graph gives `implementedBy` per point). `caution` points are not covered by
a ticket; they go into the *Notes* of the tickets they concern. `open` and `suggestion` points
are not ticketed — list them at the top of the table as "still open, left out"; if the whole
scope is still open, stop and say the phase needs decisions first (`/plan-status P<n>`).

## 2. Gate 1 — propose the breakdown, then wait

First a short **readiness check**: how many decided points are in scope, how many are already
covered by a ticket (they get no new one), and which `open` / `suggestion` points are left
out. If nothing is left to cover, say "nothing to split" and stop. Also read the project's
`CLAUDE.md` for its definition of done and the architecture docs the topics touch.

Then show **one table** for the whole scope (all topics of the phase together), in build
order, nothing written yet:

| ID | Title | Topic | Implements | Depends on | Size | Owner |
|---|---|---|---|---|---|---|

Under the table:

- **Cautions → tickets:** each caution in scope and the tickets whose *Notes* carry it — every
  caution lands in at least one ticket.
- **Decided points with no ticket:** ID and why (already built, docs only, covered by another ticket).
- **Left out (open / suggestion):** ID and text.

Rules for the proposal:
- IDs continue the phase's numbering: the next free `P<n>-T<nn>` after the highest existing
  ticket of the phase (`P1-T06` after `P1-T05`), counting `done` and `dropped` tickets and any
  number already named in a `Built: … ticket P<n>-T<nn>` line, never reusing an ID.
- One ticket = one unit of work one session can finish: usually 1–4 decided points of the
  same topic. Size it S / M / L and split anything larger than L.
- A point that is two deliverables becomes two tickets — typically backend and frontend,
  with the UI ticket depending on the API ticket.
- `depends_on` only for real build order (a ticket needs another's output), never "nice to
  do first". Keep chains short.
- Every uncovered decided point appears in exactly one ticket's *Implements*, or under
  "Decided points with no ticket" with a reason.

End with: "Say **go ahead** to write these N ticket files, or tell me what to change." Then
**stop and wait**. Adjust the table for as long as the person wants. If the person decides an
open point during this, record it in its topic as a decided point first, then include it.

## 3. Gate 2 — write the files (only after an explicit go)

For each row create `<NN-slug>/tickets/<ID>-<F<nn>>-<slug>.md` inside the phase folder, where
`F<nn>` is the short ID of the ticket's topic (`P2-T05-F04-sprint-model-api.md` for a ticket of
`P2-F04`) (the folder
already has `tickets/`; if it is missing, run `node "$THINKMAP_CLI"
phase P<n> <slug>` rather than making it by hand). Front matter: `id`, `type: ticket`,
`title`, `status: planned`, `parent: <topic id>`, `implements: [...]`, `depends_on: [...]`
when any, `owner` when given, `labels` copied from the topic, `updated: <today>`. Body as in
FORMAT.md §6: *Goal* from the points' `What:`/`Why:` lines, *Acceptance criteria* from their
`Expected:` lines (one checkbox each, plus "Tests pass" and any check the project's definition
of done requires, such as an isolation or permission test for a new endpoint), *Out of scope* for anything you
deliberately left out, *Notes* naming the cautions and the point IDs, an empty *Handoff log*.

Then, in each covered point, set its `Built:` line to `Built: Not yet — ticket <ID>` (add the
line if the point has none). Change nothing else in the topic files by hand; write each topic's
`## Tickets` list with the tool (it also renames older ticket files that lack the topic):

```
node "$THINKMAP_CLI" tickets --write
```

## 4. Check and report

```
node "$THINKMAP_CLI" validate
node "$THINKMAP_CLI" status P<n>          # or the topic: status P<n>-F<nn>
```

Fix anything the validator reports. Report: the files written, the status output's *NEXT
FREE TICKETS* list, and that each ticket is claimed with `/implement-ticket <ID>`. Do not
commit; humans commit.

Wersje

W bazie nie ma innych skilli o nazwie create-tickets.

Migawka bazy z 13.11.2026 · wersja paczki 6ab07166a88d (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-tickets
    Pisze samodzielne bilety pionowe do specyfikacji, sprawdza je ślepym czytaniem, zbiera akceptację i dopiero potem publikuje.
  • 100to-tickets
    Dzieli specyfikację lub plan na bilety z kryteriami akceptacji i blokerami, pokazuje podział i publikuje go po zgodzie.
  • 100implement-ticket
    Obsługuje jeden ticket Thinkmap w dwóch bramkach: najpierw brief tylko do odczytu, a po zgodzie budowę i zamknięcie zgłoszenia.
  • 100post-hoc-points
    Szacuje punkty historyjek dla zamkniętych zgłoszeń Jira na podstawie śladów pracy i publikuje je jako komentarze po zatwierdzeniu.
  • 95to-tickets
    Dzieli plan lub specyfikację na zestaw zgłoszeń z zależnościami i publikuje je w trackerze lub w plikach lokalnie.
  • 96jira-tickets
    Tworzy, aktualizuje, sortuje i usuwa zgłoszenia w Jira przez polecenia CLI jira.

Uwagi i zgłoszenia

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