Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

ticket

/ticket

Otwiera wpis w dzienniku pracy, a podagent wykonuje zmianę w osobnym worktree i gałęzi pod nadzorem sesji.

Repozytorium
gabier ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
13.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 13.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Otwiera wpis w dzienniku pracy, a podagent wykonuje zmianę w osobnym worktree i gałęzi pod nadzorem sesji.

Argumenty

/ticket <title of the work> [--issue-only]
Oryginalny opis (EN)

Open the logbook issue of a piece of work and have a subagent do it in a worktree and a branch of its own, under the supervision of the current session. Use when a feature, a fix or any change is asked, when something is left to do that would have been a TODO (it becomes an issue), when a subagent reports a bug unrelated to its ticket, or when the user asks for a ticket, an issue or a branch.

Jak działa

  1. Procedure
  2. Forbidden
  3. Quick reference
Sekcje z nagłówków SKILL.md, w oryginale · 148 linii, 1 609 słów
Podgląd SKILL.md
---
name: ticket
description: Open the logbook issue of a piece of work and have a subagent do it in a worktree and a branch of its own, under the supervision of the current session. Use when a feature, a fix or any change is asked, when something is left to do that would have been a TODO (it becomes an issue), when a subagent reports a bug unrelated to its ticket, or when the user asks for a ticket, an issue or a branch.
argument-hint: '<title of the work> [--issue-only]'
---

# Ticket

**START NOW. Do not greet, do not ask what to work on. Your first action is the pre-flight below.** Opening the ticket is
autonomous: execute end-to-end without confirmation, and stop only on a refusal below.

An issue is a file of the logbook (`.claude/rules/logbook.md` holds its format, its name and its size). Every piece of
work starts the same way: the issue is committed on `main`, then **a subagent** does the work in a worktree and a branch
of its own. The session that ran this skill is the **supervisor**: it does not do the work itself, it follows the
subagent, answers when the subagent stops to ask, and decides what to do with what comes back. A very small technical
task (a few lines, one concern, no new behavior) is not a ticket: the supervisor does it itself, and does not run this
skill (`.claude/rules/workflow.md`, "Tickets").

`--issue-only`: only step 1. For work left for later (what would have been a `TODO`), and for a bug a subagent reports
as unrelated to its ticket: the issue is opened and committed on `main`, nothing is started, the report gives its file
name.

## Procedure

### 0. Pre-flight (refuse if any check fails)

```bash
git rev-parse --verify main && git status --short logbook
```

- No `main` with a commit. Refuse: "`main` has no commit: nothing to branch from."
- Uncommitted changes under `logbook/`. Refuse: "The logbook has uncommitted changes: commit or stash them first."
- Inside a worktree (`git rev-parse --git-dir` differs from `git rev-parse --git-common-dir`). Refuse: "This is a ticket
  worktree: a subagent working a ticket does not open tickets. Report to your supervisor."

Then stop the gabier daemons that nobody uses (a worker stopped before it could stop its own): `sh scripts/stop-stray-daemons.sh`.
It leaves alone every daemon whose project exists, so a worker in flight is not touched.

### 1. The issue

Look first for an issue already open on the subject, never two for one piece of work:

```bash
grep -ril "<two or three keywords of the work>" logbook/issues 2>/dev/null
```

- One matches: it is the ticket, read it, skip the creation and use its title for the slug.
- None matches: take the real time with `date +%d-%m-%Y-%H%M`, then write
  `logbook/issues/open/<DD-MM-YYYY-HHMM>-<slug>.md` as the logbook rule says. The title is English, an outcome like a
  commit subject; the slug is the title in lowercase kebab-case, 40 characters at most; the content is what the user
  asked for, in a few lines: the goal, then a `Done when:` list.
  **The issue holds the need, not the content.** It says what must be true and how to check it, and which
  documentation must stay true (the page, the help, the skill), never the wording of that documentation and never a
  statement of behaviour, a list (names, counts, options) or a sentence of the code written again from memory: a fact
  copied into an issue is copied again into the documentation by the worker, and is wrong as soon as the code decides
  otherwise. When a fact matters, the issue names the symbol or the test that holds it (`Tools.NOT_TOOLS`), not its value.
  Commit **only that file** (never `git add -A`):

```bash
git add "logbook/issues/open/<file>"
git commit -m "Open issue: <title>"
```

With `--issue-only`: report the file name and stop.

### 2. The subagent

Count the workers in flight first: **two at most** (`.claude/rules/workflow.md`, "Tickets"; a batch counts for one). With
two running, the issue stays open and waits for a merge.

Launch it with the Agent tool, `subagent_type: "general-purpose"`, `model: "sonnet"` (the user prefers a Sonnet for the
worker; use a stronger model only when the ticket is hard or the user asks) and `isolation: "worktree"`: the worktree is created from
`origin/main`, which must hold the issue: the commit comes first, then `git push origin main` (when `main` is ahead of
`origin/main` by `.md` commits only; a code commit goes through a pull request). The prompt is self-contained, the subagent has
none of this conversation. **Take the other ready issues of the same module with it** (`.claude/rules/workflow.md`,
"Tickets": a batch): the prompt lists every issue file, each one's `Done when` points are the scope, and the subagent
delivers one commit per issue (each one builds and passes its tests, the full `bin/ci` is run once on the last) and proves
the points of each, one by one, in its report:

- the ticket: the path of the issue file, which it reads first, and the `Done when` points as the only scope;
- the project rules: read `CLAUDE.md` if it exists and `.claude/rules/`; test first, then implement; update the rules and
  skills that its change makes outdated;
- the documentation is the worker's: it updates every page, help text and comment that its change makes outdated (the
  issue says the need, not the words), **writing from the code**: each statement of behaviour, each list and each count
  is read from the code that decides it (the symbol, the test), never copied from the issue, from a page or from the
  report of a previous worker; where a list can be computed or checked against the code by a test, it is, instead of
  being written by hand twice;
- the quality: while working it runs targeted tests, and at most `bin/ci --fast` (no native image, no real jdtls: the
  slow checks stay off the working path); when it thinks the work is ready it runs the full `bin/ci` on its worktree
  **once** (`"$JAVA_HOME/bin/java" --source 25 bin/ci` while mise does not trust the repository) and fixes what it shows
  until every stage passes or is skipped for a stated reason (the `native` and `jdtls` stages skip themselves when no
  changed file reaches them); a failed stage is run again alone with `--stage <name>`; it proves each `Done when` point
  itself, in its report;
- the delivery: all the work in **one commit**, files added by explicit paths (never `git add -A`); it does not close the
  issue and does not merge;
- the supervision (below);
- the final report: what was done, the commit hash, the `bin/ci` summary, how each `Done when` point was proven, the
  business cases handled with the test that covers each one (the reviewer starts from them), for each statement of
  behaviour written in a page, a help text or a comment the code or the test that proves it, and the unrelated bugs
  found.

The prompt and every answer of the subagent follow "Exchanges between agents" (`.claude/rules/workflow.md`): short,
explicit, unambiguous. Keep the prompt short, because the subagent reads the rules and the skills itself: the path of the issue, the scope, the
points above in a line each, and only what the rules do not already say. Do not copy the rules into it.

**Supervision**, in the spirit of the advisor: the subagent works alone, but it **stops and returns to the supervisor**
instead of pushing on when:

- it is stuck, or considers an approach other than the one the ticket implies;
- it finds a bug unrelated to its ticket: it returns the description (what it saw, where, how to reproduce) and, if the
  bug does not block the ticket, it may carry on and put it in its final report instead;
- it is ready: `bin/ci` passes and each `Done when` point is proven. It returns "ready for review" with its report,
  before anything is closed or merged. It is reviewed once: only a finding showing that a `Done when` point is not met
  comes back to it, and its fix is checked by `bin/ci`, not reviewed again.

The supervisor answers by continuing the same agent (`SendMessage` with its id), so its context is kept.

### 3. What the supervisor does with a report

- **An unrelated bug**: run this skill with `--issue-only` for it, on `main`, right away; never fix it inside the
  ticket's branch.
- **A question**: answer it, or ask the user when the answer is theirs.
- **Ready for review**: run the skill `ship` on the branch the subagent reports. It does not run the checks again: it
  has the work reviewed once by a neutral agent, turns what it finds into tickets opened on the fly, then merges, closes
  the issue, cleans up the worktree and moves on to the next ticket.

### 4. Report to the user

The issue (file name), the branch, the commit, and every unrelated bug with the issue opened for it.

## Forbidden

- Doing the ticket's work in the supervisor session: the subagent does it.
- Writing the documentation, or a fact of the code from memory (a list, a count, a sentence), in the issue or in the
  prompt of the subagent: they state the need and name the symbol that holds the fact.
- Writing a time that did not come from `date`.
- A second issue for a subject that has one open.
- `git add -A`, `git add .`, or committing anything but the issue file on `main` when opening a ticket.
- Closing or merging a ticket other than through the skill `ship`.
- Pushing to `main`.
- French in the issue, the commit or the branch name: translate.

## Quick reference

| Step           | Command                                                         |
| -------------- | --------------------------------------------------------------- |
| Pre-flight     | `git rev-parse --verify main && git status --short logbook`     |
| Existing issue | `grep -ril "<keywords>" logbook/issues 2>/dev/null`             |
| Time           | `date +%d-%m-%Y-%H%M`                                          |
| Commit         | `git add "logbook/issues/open/<file>" && git commit -m "…"`     |
| Subagent       | Agent tool, `model: "sonnet"`, `isolation: "worktree"`          |
| Continue it    | `SendMessage` to the agent id                                   |

Wersje

RepozytoriumWynikLicencja
Ta strona · NolwennD/gabier100Apache-2.0
dsnger/dev-workflow-kit100MIT
duronext/jig100MIT
bondie/agent-harness100MIT
CristianPGit/claude-qa-architect100MIT
lttr/claude-marketplace90MIT

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

  • 100worktree
    Przenosi jeden ticket lub grupę powiązanych ticketów do własnej gałęzi i git worktree na potrzeby implementacji.
  • 90dev10x:ticket-branch
    Tworzy gałąź dla zgłoszenia według zasad projektu, po pobraniu najnowszej wersji gałęzi develop.
  • 90start-issue
    Przeprowadza zadanie z Linear od worktree i poprawki po commit, push i szkic pull requesta.
  • 100ticket-branch
    Tworzy gałąź git na podstawie numeru lub linku zgłoszenia z trackera.
  • 90worker
    Wykonuje jedno zgłoszenie z tablicy: czyta opis, wdraża zmianę w osobnym worktree i przekazuje do przeglądu.
  • 90ticket-workflow
    Opisuje, jak podjąć, prowadzić i zamknąć zgłoszenie GitHub Issue w tym repozytorium: nazwy gałęzi, powiązane PRD i TRD oraz etykiety statusu.

Uwagi i zgłoszenia

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