Skip to content
Skills Library
Management & product · Building & coding

implement-ticket

/implement-ticket

Work on one Thinkmap ticket in two gates — first a read-only brief (objective, decisions, cautions, acceptance criteria, dependencies, proposed approach, open questions), then, after an explicit "go ahead", claim it (in-progress, owner, Handoff log), build it, and close it (criteria ticked, code filled, done). Use when the person says "work on / take / start / pick up ticket P1-T03".

Repository
ThinkMap ↗
Licence
MIT
Last repository change
05.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 05.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Work on one Thinkmap ticket in two gates — first a read-only brief (objective, decisions, cautions, acceptance criteria, dependencies, proposed approach, open questions), then, after an explicit "go ahead", claim it (in-progress, owner, Handoff log), build it, and close it (criteria ticked, code filled, done). Use when the person says "work on / take / start / pick up ticket P1-T03".

Triggers from the description

go aheadwork on / take / start / pick up ticket P1-T03

Arguments

/implement-ticket <ticket-id, e.g. P1-T03> [owner]
Original author description

Work on one Thinkmap ticket in two gates — first a read-only brief (objective, decisions, cautions, acceptance criteria, dependencies, proposed approach, open questions), then, after an explicit "go ahead", claim it (in-progress, owner, Handoff log), build it, and close it (criteria ticked, code filled, done). Use when the person says "work on / take / start / pick up ticket P1-T03".

How it works

  1. Gate 1 — the brief (read-only, then stop)
  2. Gate 2 — claim, build, close (only after "go ahead")
  3. Things this skill never does
Original SKILL.md headings · 124 lines, 865 words
SKILL.md preview
---
name: implement-ticket
description: Work on one Thinkmap ticket in two gates — first a read-only brief (objective, decisions, cautions, acceptance criteria, dependencies, proposed approach, open questions), then, after an explicit "go ahead", claim it (in-progress, owner, Handoff log), build it, and close it (criteria ticked, code filled, done). Use when the person says "work on / take / start / pick up ticket P1-T03".
argument-hint: "<ticket-id, e.g. P1-T03> [owner]"
allowed-tools: Bash(node "$THINKMAP_CLI" *), Read, Edit, Grep, Glob
---

# /implement-ticket — brief first, then claim, build and close one ticket

> 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.

Also use this on your own when the person says "work on ticket P1-T03", "take P1-T03" or
similar — it is the safe way to start work in a session.

Arguments: `$ARGUMENTS` — the ticket ID (required, pattern `P<n>-T<nn>`) and an optional
owner name (default `claude`).

Two gates. Gate 1 only reads. Gate 2 starts **only** after the person replies "go ahead" (or
an equally clear yes). Never merge them.

## Gate 1 — the brief (read-only, then stop)

### 1. Find the ticket

Get the graph once and read the ticket from it:

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

(Nodes have `id`, `type`, `status`, `owner`, `file`, `implements`, `dependsOn`, `sections`.)
If the ID does not exist, say so and list the tickets whose status is `planned`. Do not
create one.

If it is `done` or `dropped`, say so and stop. If it is already `in-progress` with an owner
other than the one given, say who owns it and when it was last updated, and ask whether to
take it over — continue only on a yes.

### 2. Read the context

- the ticket file: goal, acceptance criteria, out of scope, notes, Handoff log;
- the points it `implements` (title + `What:` / `Why:` / `Expected:` lines) and their topic;
- every caution point in that topic, whether or not the ticket implements it;
- every ticket in `depends_on`, with its status;
- the rules for a session: `docs/plan/FORMAT.md` §6–7;
- the project's `CLAUDE.md` and the docs the ticket touches (architecture, conventions,
  definition of done);
- the code of related `done` tickets (their `code:` field), if any.

### 3. Write the brief, in this shape and nothing more

```
## Brief: <ID> — <title>
**Objective** — one or two sentences: what and why.
**Decisions that apply** — one bullet per implemented point: ID, What and Why in one line each.
**Cautions** — one bullet per caution in the topic: the rule and its Risk.
**Acceptance criteria** — copied from the ticket, unchanged.
**Dependencies** — one bullet per depends_on ticket: ID, title, status.
**Proposed approach** — ordered list of files to create or change, one line each on what goes there.
**Open questions** — anything still open in the topic that touches this ticket, plus anything
  ambiguous in the ticket. If none: "None."
```

If any dependency is not `done`, put `⚠ <ID> is not done — recommend not starting` at the top.

End with: *"Reply **go ahead** to claim and build, or ask / change the plan first."* Then
**stop**. Create, edit or run nothing except reads.

If the person answers a question or changes a decision, record it in the topic file as a
decided point (FORMAT.md §5 and §7), then re-issue only the changed parts of the brief and
wait again.

## Gate 2 — claim, build, close (only after "go ahead")

### 4. Claim it (edit only this ticket's file)

Re-read the ticket's front matter: if someone else claimed it since the brief, stop and say so.
Otherwise set `status: in-progress`, `owner: <owner>`, `updated:` today (`YYYY-MM-DD`), and
append one line to its `## Handoff log`:

```
- <today> · <owner> · started; <one line of intent>
```

Never rewrite earlier Handoff log lines. Then refresh the topic's generated `## Tickets` list:

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

### 5. Build

- Follow the approach from the brief. Respect every caution and the project's `CLAUDE.md`.
- Edit no other ticket's file. In `docs/plan/`, edit only this ticket and points you record
  while discussing.
- **If something the plan didn't decide comes up, don't guess.** Record it in the topic as an
  open point with `What:` and `Options:`, tell the person, and wait for their answer.
- Write tests for the change — whatever the project's definition of done asks for.
- Run the project's lint, typecheck and test commands. Report the real output; a failing step
  is reported as failing, not skipped.

### 6. Close it

- Tick only the acceptance criteria that were verified.
- Fill `code:` with the files or folders implemented, set `status: done`, `updated:` today,
  and append a final Handoff log line.
- In each implemented point, update its `Built:` line to say what was built and where.
- Update the project's docs if behaviour changed.
- Run, and fix anything they report:

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

### 7. Hand back

The list of changed files and a suggested commit message `type(scope): summary [<ID>]`.
Do not commit; humans commit.

## Things this skill never does

- Start Gate 2 without an explicit "go ahead".
- Create a ticket, phase or topic file (that is `/create-tickets`).
- Edit another ticket's file or rewrite someone else's Handoff log line.
- Tick an acceptance criterion that was not verified.
- `git commit`, `push`, `tag`, `rebase` or `reset`.

Versions

RepositoryScoreLicence
This page · dsngeu/ThinkMap100MIT
workbench-soft/agent-skills100MIT

Database snapshot: 13.11.2026 · package version 3551c47377ad (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100create-tickets
    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…
  • 100thinkmap-format
    Use whenever you are planning, discussing, deciding, questioning, suggesting or warning about anything in a project that has a docs/plan/ folder (a Thinkmap plan), and whenever you create or edit a file under docs/plan/. Teaches where the format rules are and the habit of…
  • 100code-implement
    Work one ticket from start to PR: read its acceptance criteria, branch, build them test-first with parallel build workers, and commit after each. Then open the PR with h2xd:git-pr-body, review it with h2xd:review-pr and fix the threads with h2xd:review-fix, without stopping…
  • 100ticket-research
    Build the context brief a developer needs before starting a Jira ticket — what the ticket itself says, what organizational memory adds (the decisions, meetings, and people behind it), related past work, and what is still missing. Use before picking up a ticket whose background…
  • 100writing-tickets
    Write or rewrite an issue tracker ticket (Linear, GitHub Issues, Jira, or similar) that a person or coding agent will pick up. States the objective, evidence, decisions already made, hard rules, and done criteria, and leaves the how to the implementer. Use when the user says…
  • 100ticket-session
    Use when a prompt says to follow the ticket-session skill for a session, such as the task Go gives a planner from the tickets panel in the Herdr app. Plans the session's ticked tickets from its brief, writes one roadmap per project and hands them to the switchboard.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.