AGENT SKILL

to-tickets

Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker — edges as text in one file per ticket locally, or native blocking links on a real tracker.

License 许可
MIT
最近更新
2026-11-06
Stars
★ 0
Forks
0

01 前言 Front Matter

name
to-tickets
description
Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker — edges as text in one file per ticket locally, or native blocking links on a real tracker.

03 SKILL.md 正文

To Tickets

Break a plan, spec, or conversation into a set of tickets — tracer-bullet vertical slices, each declaring the tickets that block it.

The issue tracker should have been provided to you — run /setup-skills if not.

Process

1. Gather context

Work from whatever is already in the conversation context. If the user passes a reference (a spec path, an issue number or URL) as an argument, fetch it and read its full body and comments.

2. Explore the codebase (optional)

If you have not already explored the codebase, do so to understand the current state of the code. A parent spec's Bearings stand in for the part of that exploration that locates the work — take them rather than getting oriented twice. Ticket titles and descriptions should use the project's domain glossary vocabulary. Read the ADRs in force in the area you're touching, wherever the project's domain docs keep them: each ticket must comply with them (step 3). When the plan contradicts an ADR, surface it to the user before you cut: "Contradicts <ADR> — but worth reopening because…". If the user reopens it, the first ticket supersedes the ADR and blocks each ticket that the ADR governs.

Look for opportunities to prefactor the code to make the implementation easier. "Make the change easy, then make the easy change."

3. Draft vertical slices

Break the work into tracer bullet tickets.

<vertical-slice-rules>

  • Each slice cuts a narrow but COMPLETE path through every layer (schema, API, UI, tests) — vertical, NOT a horizontal slice of one layer
  • A completed slice is demoable or verifiable on its own
  • Each slice is sized to fit in a single fresh context window
  • Any prefactoring should be done first
  • Each slice complies with every ADR in force in the area it touches, from its first commit — narrow, yet compliant. When compliance makes a slice too big, cut it another way or add a prefactor ticket that blocks it. Violations already in the code stay out of scope; a slice adds none

</vertical-slice-rules>

Give each ticket its blocking edges — the other tickets that must complete before it can start. A ticket with no blockers can start immediately.

Wide refactors are the exception to vertical slicing. A wide refactor is one mechanical change — rename a column, retype a shared symbol — whose blast radius fans across the whole codebase, so a single edit breaks thousands of call sites at once and no vertical slice can land green. Don't force it into a tracer bullet; sequence it as expand–contract. First expand: add the new form beside the old so nothing breaks. Then migrate the call sites over in batches sized by blast radius (per package, per directory), each batch its own ticket blocked by the expand, keeping CI green batch to batch because the old form still exists. Finally contract: delete the old form once no caller remains, in a ticket blocked by every migrate batch. When even the batches can't stay green alone, keep the sequence but let them share an integration branch that all block a final integrate-and-verify ticket — green is promised only there. ADR compliance follows the same sequence: the old form that lives beside the new one is the only allowed exception, and compliance is promised at the contract ticket — or at the integrate-and-verify ticket.

4. Quiz the user

Present the proposed breakdown as a numbered list. For each ticket, show:

  • Title: short descriptive name
  • Blocked by: which other tickets (if any) must complete first
  • What it delivers: the end-to-end behaviour this ticket makes work

Ask the user:

  • Does the granularity feel right? (too coarse / too fine)
  • Are the blocking edges correct — does each ticket only depend on tickets that genuinely gate it?
  • Should any tickets be merged or split further?
  • Does each ticket comply with the ADRs in its area, with none left for a later ticket?

Iterate until the user approves the breakdown.

5. Publish the tickets to the configured tracker

Publish the approved tickets. How depends on the tracker /setup-skills configured — the tickets are the same either way, only the shape of the blocking edges changes:

  • Local files → write one file per ticket under .scratch/<feature-slug>/issues/<NN>-<slug>.md, numbered from 01 in dependency order (blockers first). Each file's "Blocked by" lists the numbers/titles it depends on. Use the per-ticket file template below — one ticket per file, never a single combined file.
  • A real issue tracker (GitHub, Linear, …) → publish one issue per ticket in dependency order (blockers first) so each ticket's blocking edges can reference real identifiers. Use the platform's native blocking / sub-issue relationship where it has one; otherwise set each ticket's "Blocked by" to the blocking issues.

Work the frontier: any ticket whose blockers are all done. For a purely linear chain that means top to bottom.

Do NOT close or modify any parent issue.

<local-ticket-template>

<NN> — <Ticket title>

What to build: the end-to-end behaviour this ticket makes work, from the user's perspective — not a layer-by-layer implementation list.

Blocked by: the numbers/titles of the tickets that gate this one, or "None — can start immediately".

  • [ ] Acceptance criterion 1
  • [ ] Acceptance criterion 2

Bearings: the areas the implementer should read to get oriented — the parent's, narrowed to this slice, or your own when there's no parent.

ADRs: a reference to each ADR in force this slice must comply with, or "None".

</local-ticket-template>

<issue-template>

Parent

A reference to the parent issue on the tracker (if the source was an existing issue, otherwise omit this section).

What to build

The end-to-end behaviour this ticket makes work, from the user's perspective — not layer-by-layer implementation.

Acceptance criteria

  • [ ] Criterion 1
  • [ ] Criterion 2

Blocked by

  • A reference to each blocking ticket, or "None — can start immediately".

Bearings

Where to look to get oriented — an estimate, not a commitment. Take the parent's when it has them, narrowed to this slice; derive your own only when there's no parent. Point at the areas whose existing code and tests the implementer needs in context, so getting there costs no search; which files change stays their call, which is what keeps the prefactor free.

  • <area> — <what the implementer finds there>
  • <where its tests live> — the prior art the new tests mirror
  • <ADR reference> — each ADR in force this slice must comply with

</issue-template>

In either form, code stays in the codebase, its own source of truth — a copy in a ticket goes stale in silence. Give each ticket its Bearings instead: the areas to read to get oriented. Exception: if a prototype produced a snippet that encodes a decision more precisely than prose can (state machine, reducer, schema, type shape), inline it and note briefly that it came from a prototype. Trim to the decision-rich parts — not a working demo, just the important bits.

04 同仓库更多 Skills

javierponferradalopez
javierponferradalopez/skills

zoom-out

Tell the agent to zoom out and give broader context or a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how it fits into the bigger picture.

★ 0
javierponferradalopez
javierponferradalopez/skills

writing-for-agents

Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.

★ 0
javierponferradalopez
javierponferradalopez/skills

walkthrough

Build a throwaway HTML reading guide for a set of changes (dirty tree, local commits, or a PR): what it means for users and for the system, then an ordered walk through the code with links that open each file in the IDE. Orients the human; leaves every quality call to them.

★ 0
javierponferradalopez
javierponferradalopez/skills

teach

Teach the user a new skill or concept, within this workspace.

★ 0
javierponferradalopez
javierponferradalopez/skills

suggest-reviewers

Suggest GitHub reviewers for the current branch's Pull Request by ranking the people who actually own and recently touched the changed files (git history + CODEOWNERS). Use when the user asks who should review this PR/branch or wants reviewer suggestions. Also invoked as the final step of the github-pr skill.

★ 0
javierponferradalopez
javierponferradalopez/skills

setup-skills

Sets up an `## Agent skills` block in AGENTS.md/CLAUDE.md and `docs/agents/` so the engineering skills know this repo's issue tracker (GitHub, GitLab, ClickUp, or local markdown), domain doc layout, and error tracking. Run as a first-time bootstrap for a repo, or if engineering skills appear to be missing context about the issue tracker, domain docs, or error tracker.

★ 0