to-issues

Trigger phrases

Phrases that activate this skill when typed to Claude Code:

• break this plan into issues
• to-issues
• create implementation tickets

What it does

to-issues converts a plan, spec, or PRD into a set of GitHub issues (or whichever issue tracker the project uses, configured via setup-matt-pocock-skills). The unit of decomposition is the tracer bullet: a thin vertical slice that cuts through every integration layer end-to-end, not a horizontal slice of one layer.

The skill’s process:

1. Gather context from the current conversation. If the user passes an issue reference (number, URL, path), fetch it from the tracker and read its body and comments.
2. (Optional) explore the codebase so issue titles use the project’s domain glossary vocabulary and respect ADRs in the touched area.
3. Draft vertical slices. Each issue is end-to-end, independently grabbable by an AFK agent, and small enough to ship in a single PR.

The output is a set of titles and bodies, ready to file or already filed depending on configuration.

When to use it

Reach for it when:

• A plan or PRD has just landed and you want to turn it into a backlog rather than a single sprawling implementation
• You’re handing work to an agent or contractor and need each issue to be self-contained
• The plan currently exists as a long doc and you can feel the temptation to “just start coding” — that’s the signal to break it down first

When not to reach for it:

• A small change that’s one PR end-to-end — issue decomposition is overhead
• The plan still has open questions; grill it first (grill-me / grill-with-docs) before issuing it out

Install

The skill is distributed via Pocock’s skills repo. Install via his recommended path (npx skills add or manual copy into .claude/skills/to-issues/) — see the repo README for canonical install instructions. Issue-tracker config and triage label vocabulary should be set up via setup-matt-pocock-skills first.

What a session looks like

A typical session has three phases:

1. Context gathering. The skill reads whatever’s in the conversation and (if pointed at one) fetches a referenced issue or PRD from the tracker.
2. Slice draft. The agent proposes 3–10 vertical-slice issues, each titled in domain vocabulary, each end-to-end through the layers it touches. Horizontal slices (“all the DB work” / “all the UI work”) get rejected during this phase.
3. Confirm and file. You review the slices, push back on any that look horizontal or too coarse, and the skill files them.

The discipline that makes it work: each slice has to be independently shippable. If issue B can’t start until issue A’s API is done, they’re horizontal, not vertical — the skill flags this.

Receipts

TODO — to be filled in from a real session. When the skill is triggered in production use, capture: number of vertical slices produced from a given plan, whether any slice got pushed back as horizontal during review, how the domain-vocabulary titles compared to a manually-written backlog, and whether all slices were independently grabbable (or whether sequencing constraints surfaced later).

Source and attribution

Originally written by Matt Pocock. The canonical SKILL.md lives in the engineering/to-issues folder of his public skills repository.

License: MIT. You can install, adapt, and redistribute the skill, with attribution preserved.

This page documents the skill from a practitioner’s perspective. For the formal spec and any updates, defer to the source repo.