---
name: write-plan-and-tickets-prompt
description: A prompt that breaks a plan or spec into small tracer-bullet tickets, each a thin end-to-end slice with its blockers listed, then has the AI work through them one at a time with tests and commits. Use when the user has a spec to turn into tickets, wants a feature split into tasks, asks for a plan-then-execute workflow, or wants issues an agent can pick up.
license: MIT
metadata:
  category: coding-prompts
  tags: "planning,tickets,issues,agents,workflow"
  author: johnny-bravo
  version: "1.0"
  updated: "2026-10-31"
  status: published
  aliases: "to-tickets,implement,plan-tickets-execute,break-spec-into-tasks"
  source_url: "https://github.com/mattpocock/skills/blob/a496f5513d4a4cf889bc48e189e579f4b0bdf6aa/skills/engineering/to-tickets/SKILL.md"
  source_license: MIT
  copyright: "Copyright (c) 2026 Matt Pocock"
  original_author: "Matt Pocock (mattpocock/skills, 'to-tickets' and 'implement')"
  modified: "Adapted by TheSkillVault: to-tickets and the short implement skill merged into one plan -> tickets -> execute prompt; tracker setup replaced by a local-files default; templates shortened; added safety, how-to-adapt and done-when sections."
  imported_on: "2026-10-31"
---

# Plan, tickets, execute (prompt)

Big features go wrong when an AI tries to build them in one go. This prompt splits the work into small tickets. Each one is a thin slice that works end to end and can be checked on its own. Then the AI builds them one by one.

## When to use
- You have a plan, spec or PRD and need it turned into tickets or tasks.
- A feature is too big for one AI session.
- You want issues that an agent can pick up and finish without asking.

## Steps
1. Write or paste your plan or spec. (Need one first? Use write-prd-prompt.)
2. Paste the prompt below. Review the proposed tickets and push back on size and order.
3. Approve, then let the AI publish the tickets and build them one at a time.

## Prompt
```text
PART 1 - TICKETS. Break the plan below into tickets. Do not write code yet.

1. Read the plan, plus any spec, issue or files I reference. Skim the codebase for its current
   shape and domain words. Look for a small "prefactor" that makes the work easier; it goes first.
2. Draft tracer-bullet tickets (vertical slices):
   - each cuts a thin but complete path through every layer (data, API, UI, tests)
   - each is demoable or checkable on its own
   - each fits in one fresh AI session
   - list each ticket's blockers: the tickets that must finish first ("None" = can start now)
   Exception: a wide mechanical refactor (rename a column, retype a shared symbol) uses
   expand -> migrate in batches -> contract, so the build stays green between tickets.
3. Show me a numbered list: Title, Blocked by, What it delivers. Ask:
   is the size right, are the blockers real, should any be merged or split? Iterate until I approve.
4. Publish the approved tickets in dependency order (blockers first):
   - default: one file per ticket at .scratch/<feature>/issues/<NN>-<slug>.md
   - or, if I say so, one issue per ticket in my tracker, using native "blocked by" links if it has them
   Each ticket has: What to build (user-visible behaviour), Blocked by, and testable acceptance
   criteria as checkboxes. Avoid file paths and code snippets; they go stale.
   Do not close or edit any parent issue.

PART 2 - EXECUTE. When I say "go", work the frontier (tickets whose blockers are all done):
- state the ticket title before you start
- write tests first where there is a clear seam; run the typecheck and single test files often
- run the full test suite at the end of each ticket and show me the result
- review your own diff, then commit to the current branch with a clear message
- tick the acceptance criteria and move to the next ticket

PLAN:
{{PASTE YOUR PLAN OR SPEC, OR NAME THE FILE / ISSUE}}
```

## How to adapt
- Using GitHub Issues, Linear or Jira instead of local files? Say "publish to my tracker" in step 4.
- Want parallel work? Hand unblocked tickets to separate agents (see build-with-parallel-subagents-prompt).
- Works with any stack and any AI coding tool that can edit files and run tests.

## Gotchas
- "Backend ticket, then frontend ticket" is a horizontal split. Ask for vertical slices instead.
- Tickets too big for one session come back half done. Split them.
- Publishing issues is visible to your team. Check the list before saying yes, and keep secrets, tokens and customer data out of ticket text.

## Done when
- Every ticket has blockers and testable acceptance criteria, and you approved the list.
- Each finished ticket has passing tests and its own commit.

## Example prompt
"Here's my spec for team invites. Break it into tickets, then build them one at a time."

---
Adapted from "to-tickets" and "implement" in mattpocock/skills by Matt Pocock (MIT). See LICENSE.txt.