agentleFS
0xfurai0xfurai/peekaping/.agents/skills/ticket-build/SKILL.md

ticket-build

Skill1.2k starsChanged 17 days agoMITView on GitHub

Implement a ticket's agreed plan: split each PR into pieces, have Sonnet agents build them test first, and connect the pieces on the PR branch.

Trending

More talk lately.thin dataabout the whole repository

Dec 2025: 0 mentionsJan 2026: 0 mentionsFeb 2026: 0 mentionsMar 2026: 0 mentionsApr 2026: 0 mentionsMay 2026: 0 mentionsJun 2026: 0 mentionsJul 2026: 0 mentionsAug 2026: 0 mentionsSep 2026: 0 mentionsOct 2026: 1 mentionNov 2026: 0 mentions
Dec 2025Jun 2026Nov 2026
Mentions a month of the 0xfurai/peekaping repository that our weekly crawl found: only 2 in all, so this is a hint, not a trend. There is no adoption data for this file yet.

The file

We split this skill into the rules it gives an agent

4 rules. About 0 are common, 1 is distinctive, and 3 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Start with setup. The ticket needs a ## Agent plan.

    line 10
  2. Distinctive:

    When the code shows the plan won't work as written, stop and take it back to the user (setup, "Throughout").

    line 14
  3. Very specific:

    before it reports: the server tests, plus web lint and build when it touched apps/web.

    line 33
  4. Very specific:

    Run alone, end by telling the user the next step: /ticket <PP-n> from review.

    line 48

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Ticket: build

Start with setup. The ticket needs a ## Agent plan; without one, stop and tell the user to run /ticket-plan first.

Build the plan's PR stack bottom up, one branch per PR (STACK.md). Each PR goes through the three steps below, with agents doing the building (DELEGATE.md). The next PR starts once the one below is connected, since it builds on it.

When the code shows the plan won't work as written, stop and take it back to the user (setup, "Throughout").

Done when: every PR is connected, every acceptance criterion is implemented with a green test, and the full local run in TESTING.md passes on each branch merged with origin/main.

1. Split

A piece is a part of the PR one agent can build alone: its own acceptance criteria, its own files. Cut along seams the code already has: server and web, one module and the next, one notification provider and another. When two parts need each other's code, write the contract between them before they start, word for word: the type, the function signature, the API payload. When no contract keeps them apart, they are one piece. A PR that doesn't split is one piece.

Each file belongs to one piece. Files every piece would touch (the 45 locale files, go.mod, the swagger docs, the generated web client) go to one piece, or you keep them for the connect step.

Done when: every acceptance criterion and approach step of the PR belongs to exactly one piece, and no file belongs to two.

2. Build the pieces

One agent per piece, all at once, each in a worktree of its own off the PR branch (DELEGATE.md). A lone piece gets one too, so connecting works the same for one piece or five. Each brief also carries:

  • the piece's acceptance criteria and approach steps, quoted from the plan;
  • the files it owns, the contract with the other pieces, and the files you keep, so its report names what it needs in them;
  • red → green, one criterion at a time, as in TESTING.md, committing each green slice;
  • before it reports: the server tests, plus web lint and build when it touched apps/web. The e2e and real-database checks wait for the full local run, since the dev stack and the test containers are one per ticket.

Done when: every agent has reported.

3. Connect

In the ticket's worktree, on the PR branch:

  1. Check each piece against its brief (DELEGATE.md): its report and git log -p <PR branch>..piece/pp-<n>-<piece>.
  2. Merge the pieces one at a time: git merge --no-edit piece/pp-<n>-<piece>. Resolve each conflict keeping what both pieces meant, then remove the piece's worktree and branch.
  3. Glue: the wiring between pieces, the files you kept, what the reports asked for, and the generated layers when the API contract changed (TESTING.md). Commit it.
  4. Verify: one agent runs the full local run in TESTING.md on the PR branch merged with origin/main and fixes what fails, in commits on the PR branch. Check its report as you checked the pieces.

Done when: every piece is merged, its worktree and branch are gone, and the full local run passes on the PR branch merged with origin/main.

Run alone, end by telling the user the next step: /ticket <PP-n> from review.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.