- Home
- Skills
- Productivity
- Plan To Tracer Bullet Tickets
Works with the AI Agents you already use
Plan To Tracer Bullet Tickets
Turns a plan, spec or design document into a ticket list a team can pick up in parallel
$5
/moSubscription · cancel anytime
Secure checkout via Stripe
- Always the latest version
- Delivered live to your agent via MCP
- Cancel anytime, access ends at period end
Plan To Tracer Bullet Tickets
Example session with this skill installed
Here's the SPD-140 plan. Break it into tickets three people can pick up in parallel.
- Read your context and instructions
- Compiled the plan to tracer
Tickets - SPD-140 saved payment methods - 2026-09-03
Plan: plan-a.md | Repo: shopfront
4 tickets, 1 can start now, 4 plan items folded in. The plan is serialised at the front: nothing else has an observable until T1 lands.
Start now
T1 - A card used at checkout is saved for next time
Observable when done: a customer pays with a fresh card as they do today, and GET /checkout/cards comes back with Visa ending 4242 for that user instead of an empty list.
Touches: migrations/003_saved_cards.sql, app/payments/vault.py, app/checkout/service.py, app/checkout/routes.py
Blocked by: nothing
Retires the risk that: the single-use browser token from window.PaymentProvider.tokenize() cannot be exchanged for a reusable vault reference at all. Everything downstream assumes it can, and app/checkout/service.py currently persists nothing about the token. If the exchange does not exist, plan item 6 is already decided and server-side vaulting is the only route.
Waits
T2 - Returning customer sees their saved cards at checkout
Observable when done: a customer who has ordered before lands on checkout and sees a radio list of their saved cards plus a "use a new card" option, rather than the bare Pay now button in web/src/Checkout.jsx.
Touches: web/src/Checkout.jsx, app/checkout/routes.py
Blocked by: T1 - needs GET /checkout/cards returning {id, brand, last4, exp_month, exp_year} per card, the shape the radio list renders from and the id the other tickets send back.
T3 - Returning customer pays without typing a card
Observable when done: the customer taps the card ending 4242, presses pay, the provider SDK is never invoked, and an order confirmation comes back.
Touches: web/src/Checkout.jsx, app/checkout/routes.py, app/checkout/service.py, app/payments/vault.py
Blocked by: T1 - needs the stored vault reference and charge_saved(vault_ref, amount) in app/payments/; place_order today takes a card_token and charges it straight through. T2 - needs the selected card's id present in the POST /checkout/orders body, where only items and card_token exist now.
T4 - Customer removes a card they no longer use
Observable when done: the customer presses delete on a saved card, it leaves the list, and it is not offered on the next checkout.
Touches: web/src/Checkout.jsx, app/checkout/routes.py, app/payments/vault.py
Blocked by: T1 - needs the saved_cards row and the id that identifies it. T2 - needs the rendered card list the delete control hangs off; there is nothing to delete from until the list exists.
Not tickets
- Add a users table so cards can be owned - already done - migrations/001_users.sql creates
users (id, email, token)andapp/users/auth.pyalready resolves a request to aUser;saved_cards.user_idhangs off it the wayorders.user_iddoes. - Add the SavedCard model - layer - folded into T1, the first ticket that needs a row to exist.
- Add the schema migration for saved cards - layer - folded into T1 as migrations/003_saved_cards.sql; a migration alone shows nobody anything.
- Build the payments service layer - layer - split by need rather than built up front:
vault_cardlands in T1,charge_savedin T3. Building both before either caller exists is the integration-day risk this breakdown is trying to avoid. - Wire up the UI - layer - split across T2, T3 and T4, one observable each. "The checkout screen" is three separate things a person can see, and they do not have to land together.
- "The UI can only start once everything else is done" - wrong - it is the opposite way round. The UI is where every observable in this plan lives; a stack built with no screen on it proves nothing. T2 comes second, not last.
- Decide whether we keep tokenising client-side or move to server-side vaulting - decision - not something anyone can pick up, and it does not need settling before work starts. T1 is the experiment that informs it: it establishes whether the current client-side flow yields a re-chargeable reference, which is the fact the decision is missing. Settle it after T1 reports, before T3 commits to a charge path.
Unanchored
- Admin reporting on saved-card usage - the repo has no admin surface at all: no admin routes, no reporting module, nothing outside app/checkout, app/users and web/src/Checkout.jsx.
ordersalso holds onlyid,user_idandtotal, so nothing recorded today distinguishes a saved-card order from a fresh one - settled by: naming where an admin page lives (or confirming finance reads it from SQL), and adding the payment-path marker toordersinside T3, where the distinction first exists. - The provider's vaulting API - web/src/payments-sdk.js wraps one call,
tokenize(), returning a single-use browser token, and no code in the repo exchanges it for anything. The plan'svault_card(token)assumes an exchange endpoint that is not visible here - settled by: the provider's vaulting docs, or one test call showing a token converts to a durable reference.
Say the word and I'll write this to a file.
Subscription · always the latest version
- Secure checkout via Stripe
- Cancel anytime
- Delivered live via MCP
About this skill
A plan is not work until somebody can pick a piece of it up. This skill turns a spec or design document into tickets that each cut a thin slice through the whole stack, naming what a person can see when it lands, the files it touches, and what it waits for and why. Layers, decisions and anything the repo does not have yet are called out as such rather than dressed up as tickets. It ends by telling you what can start today, hardest assumption first.
What it does
Turns a plan, spec or design document into a ticket list a team can pick up in parallel. Every ticket is a tracer bullet - a thin slice through the whole stack - and carries the observable it produces, the files it touches, and any blocking edge with the specific artefact it is waiting for. Plan items that are layers rather than slices, decisions rather than work, or assumptions the repo does not support are listed separately instead of being turned into tickets that cannot be finished.
Try it first
Open a repo, paste or point at a plan you have not broken down yet, and say "break this plan into tickets we can hand out". You should get back a header with the ticket count and how many can start now, a Start now section ordered by which assumption each ticket kills, a Waits section where every Blocked by names the artefact it needs, and separate Not tickets and Unanchored lists for the parts of the plan that are not work.
What it needs
An agent that can read and search the repo - Read, Grep, Glob and Bash. No API keys, no MCP servers, no tracker integration, no network access. A repo is optional: without one the tickets still come out, but they lose their file lists, which is a real part of the value.
Granularity is a judgement, and it moves. Run it twice on the same plan and you may get five tickets or seven, and a first wave of one or of three. What holds every time is the rules - every ticket carries something observable, every blocking edge names the artefact it waits for, layers and decisions stay out of the list, and anything the repo does not have is called out - but where exactly the seams fall is a call, and it is the same call two experienced leads would make differently. Treat the output as a strong first draft to argue with rather than a fixed answer. It also does not create anything in Jira, Linear or GitHub Issues. It prints the list and you paste it, which is one manual step it will not save you. It refuses to estimate, size or assign, because nothing in a plan supports those and a confident number would be a made-up one. Its output is bounded by the plan it is given: a vague plan produces vague tickets, and it will say the plan is too thin rather than invent detail to look thorough. It also has no idea who owns what on your team, so the waves it proposes are ordered by dependency and risk, never by which group would naturally take them.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Free forever
No account required to browse
Trust & safety
Security scan
Security scan passed 1 month ago