agentleFS
SaikaAcoSaikaAco/saika-hermes-skills/skills/to-tickets/SKILL.md

to-tickets

Skill2 starsChanged 4 months agoMITView on GitHub

Use when the user explicitly asks to turn an approved specification, plan, or settled contract into agent-sized implementation tickets with requirement coverage and blocking edges. Drafts first; publishes only with separate authority.

192 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use setup-ts-deep-modules, to-questionnaire and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • liufeng1976Skill

    setup-ts-deep-modules

    Wire dependency-cruiser into a TypeScript repo so each package is a deep module — implementation hidden in subfolders, reachable only through its entry-point files. User-invoked.

    Also in 43 projects that use this

  • AWSSkill

    to-questionnaire

    Turn a decision you can't fully answer into a questionnaire for someone else to fill in.

    Also in 89 projects that use this

  • ryotaroh180105Skill

    claude-handoff

    Hand the current conversation off to a fresh background agent that picks up the work immediately.

    Also in 40 projects that use this

  • RoentekSkill

    loop-me

    Grill me about specs for the workflows I want to build, within this workspace.

    Also in 47 projects that use this

  • AWSSkill

    implement-spec

    Implement the result of /to-spec and /to-tickets in code.

    Also in 69 projects that use this

  • sponge-b0bSkill

    to-specs

    Project decision-complete planning into implementation Specs from exact Canonical Contract Ledger semantics while preserving Independent Specs and existing Spec identity.

    Also in 3 projects that use this

  • +2 more from aws

The file

We split this skill into the rules it gives an agent

11 rules. 0 are common, 7 are distinctive, and 4 are very specific to this project.

  • 0

    Common

    Most of the 183 edited versions we read keep these.

  • 7

    Distinctive

    This author's own choices. Worth a look.

  • 4

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Before slicing, inspect only current repository and record evidence needed to validate implementation-facing claims: active project/tracker …

    line 47
  2. Very specific:

    Verify every claim that determines ticket size, blocker edges, blast radius, or acceptance.

    line 54
  3. Distinctive:

    Prefer narrow vertical slices.

    line 67
  4. Distinctive:

    When the source establishes a wide mechanical change, use

    line 100
  5. Distinctive:

    add a backward-compatible expansion and mixed-version contract evidence.

    line 103
  6. Distinctive:

    remove the old contract only after every cohort is verified migrated.

    line 106
  7. Distinctive:

    If intermediate batches cannot be independently green, name the integration boundary and add final integration verification instead of …

    line 108
  8. Very specific:

    Use stable draft IDs and only real blockers.

    line 116
  9. Distinctive:

    Every ticket uses this contract:

    line 135
  10. Very specific:

    Create blockers first where handles are needed, then bodies and real edges.

    line 202
  11. Very specific:

    Never plan implementation, dispatch agents, create Kanban, implement, commit, deploy, complete tickets, or modify/close/label the parent …

    line 208

“Common” is measured: kept by at least 6 in 10 of the 183 edited versions of this file we could read. “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

Traceable To-Tickets

Lineage

This is an MIT-licensed Hermes adaptation of Matt Pocock's public to-tickets. The complete upstream notice is preserved in references/third-party-notices.md.

Compile one exact, user-accepted source snapshot into an agent-sized delivery graph. Initial invocation authorizes a chat draft only.

DRAFT_READY means an honest reviewable draft exists; it does not mean grounding is complete or authorize publication or implementation. Pending pre-publication grounding, graph rechecks, or fresh approval may coexist with DRAFT_READY when accepted facts already determine the safe draft shape. Use BLOCKED when missing facts prevent an honest draft or materially change its graph, sizing, sequencing, or safety. For decision-only decomposition, do not block merely because later implementation details remain unknown.

Source and grounding

Accept one exact source snapshot with identifiable scope, owner, requirements, decision/evidence handles, constraints, negatives/exceptions, out-of-scope boundaries, observable acceptance, and required evidence. Do not infer acceptance or current truth from an old conversation, a similarly named file, or mere draft existence. Keep source_snapshot exactly equal to the accepted version, revision, fingerprint, or message handle. Put drift history or missing-revision explanations in lineage, blockers, or a separate drift field; never append those explanations to the snapshot value.

Before slicing, inspect only current repository and record evidence needed to validate implementation-facing claims: active project/tracker policy, governing decisions and vocabulary, relevant interfaces, seams, behavior and tests, plus source negatives, exceptions, and acceptance methods. Prior exploration does not validate a specific claim. A direction to reuse an unnamed “existing seam” does not itself verify that seam.

Verify every claim that determines ticket size, blocker edges, blast radius, or acceptance. For an actual ticket bundle, do not claim DRAFT_READY or grounding passed when unavailable evidence would require route-changing guesswork. Never invent a seam, cohort, owner, dependency, acceptance boundary, or implementation fact. Exact files belong to later Plan work, but uncertainty that changes graph, sizing, sequencing, coverage, or safety blocks drafting. Name the missing evidence and required regeneration checks rather than emitting placeholder tickets.

Compile the graph

Ordinary work

Prefer narrow vertical slices. Each ticket must:

  • deliver one observable end-to-end behavior across every required layer;
  • fit one fresh implementation context and leave the repository green;
  • own source-derived positive and negative acceptance plus evidence across every applicable behavior class: validation/failure, authorization, retry and idempotency, atomicity and rollback, audit, confidentiality/metadata, and temporal or compatibility transitions;
  • preserve source semantics exactly: never strengthen, relax, or redefine an exception, grace period, compatibility window, security boundary, or non-goal;
  • be independently demonstrable, with no hidden half-feature or follow-up needed to satisfy the behavior it claims;
  • preserve atomic requirements together: do not split required audit, security, idempotency, rollback, or failure behavior from the operation whose safe completion depends on it.

For each applicable behavior, make cross-effects explicit:

  • authorization failure, expiry, revocation, or a nonexistent handle causes no protected mutation, no success audit, and no protected metadata or secret disclosure unless the source explicitly permits an effect;
  • same-key retry duplicates none of the source-required persisted effects, including primary records, audit records, events, or handles;
  • temporal and grace behavior is verified before, during, at the boundary, and after transition without redefining the source contract.

Split large work by independently usable behavior, not schema/API/UI or other horizontal layers. A separate infrastructure or preparation ticket is allowed only when independently verifiable and a genuine blocker. Preserve unrelated parallelism; never add edges for review order or convenience.

Wide migrations

When the source establishes a wide mechanical change, use expand → independently green migration batches → contract:

  1. add a backward-compatible expansion and mixed-version contract evidence;
  2. migrate explicitly bounded, owned, independently testable cohorts in parallel where safe;
  3. remove the old contract only after every cohort is verified migrated.

If intermediate batches cannot be independently green, name the integration boundary and add final integration verification instead of claiming each batch is releasable. Missing cohort membership, ownership, transition semantics, conflict behavior, or contraction evidence that changes sizing or safety is BLOCKED, not a placeholder ticket.

Coverage and graph checks

Use stable draft IDs and only real blockers. Reject missing, self, or cyclic edges and compute the true frontier. frontier is stage-specific: a DRAFT_READY bundle may show structural start nodes for review but creates no implementation authority; BLOCKED and RECONCILE_REQUIRED bundles always use frontier: []. Never expose a blocked, unknown-body, or reconciliation-pending ticket as actionable.

Cycle-check completeness concerns the intended ticket-ID/blocker-edge set, not ticket bodies, acceptance, or source mappings. If all intended IDs and edges are known, run the check even when grounding or coverage remains blocked. If that ID/edge set is unavailable or incomplete, set cycle_check: not_run; never claim passed for an unaudited graph. Prove both directions: every current requirement/constraint maps to tickets or an explicit owner-accepted disposition, and every ticket maps to source requirements, decisions/evidence, and acceptance. Omission, orphan scope, silent expansion, or self-accepted disposition is BLOCKED.

Canonical schemas

Every ticket uses this contract:

id: <stable draft ID or published handle>
status: DRAFT | READY | BLOCKED | PUBLISHED
parent: <source snapshot handle>
source_snapshot: <hash, version, timestamp, or accepted message handle>
owner: <real owner>
source_requirements: [<IDs>]
source_decisions_evidence: [<IDs or handles>]
blocked_by: [<ticket IDs>]
delivers: <one observable behavior>
acceptance_criteria: [<observable positive and negative checks>]
verification_evidence: [<tests, artifacts, or observations>]
constraints: [<source-derived constraints>]
exclusions: [<explicit non-goals>]
authorization: <draft/publication/implementation boundary>

The bundle uses this contract:

schema: to-tickets-bundle-v1
state: DRAFT_READY | PUBLISHED | BLOCKED | RECONCILE_REQUIRED
source: <path, handle, or conversation reference>
source_snapshot: <hash, version, timestamp, or accepted message handle>
source_owner: <name>
lineage: <source -> ticket graph>
tickets: [<canonical ticket objects>]
frontier: [<currently unblocked ticket IDs>]
coverage:
  requirement_to_tickets: <map>
  ticket_to_source: <map>
  dispositions: <map>
  uncovered_requirements: []
  orphan_tickets: []
cycle_check: passed | failed | not_run
grounding_status: passed | blocked
publication:
  backend: none | local | tracker
  approval_binding: none | <exact opaque graph fingerprint copied verbatim, e.g. G14; never append backend, status, or prose>
  persistence: none | partial | confirmed
  published_handles: []
  readback_verified: false

Additional presentation fields are allowed, but these meanings and types must not be silently replaced by an ad-hoc schema.

Authority, drift, and recovery

  • Publication requires later approval bound to the exact reviewed graph and one named backend. A configured tracker, old access, source approval, draft request, or generic “go ahead” is not publication authority.
  • Graph approval and backend authorization are separate. Naming or approving a backend does not invalidate approval of an unchanged graph; source or graph changes do.
  • RECONCILE_REQUIRED preserves the exact approval binding for an unchanged graph. Uncertain, partial, or unverified persistence alone never clears that graph approval.
  • An approved ticket ID whose source mapping is temporarily unavailable remains approved-but-unresolved, not an orphan. Keep orphan_tickets: [] unless evidence proves a ticket lacks source authority; represent unknown mappings as blocked or unknown coverage instead.
  • Source drift invalidates coverage and approval. Graph mutation requires affected grounding, bidirectional coverage, cycle/frontier checks, and new exact publication approval.
  • Create blockers first where handles are needed, then bodies and real edges; read back bodies, edges, labels, and handles before claiming PUBLISHED or applying ready-for-agent to verified approved child tickets.
  • On uncertain or partial writes, preserve known handles, search stable idempotency keys before retry, never recreate blindly, and return RECONCILE_REQUIRED until reconciled.
  • Never plan implementation, dispatch agents, create Kanban, implement, commit, deploy, complete tickets, or modify/close/label the parent specification. A ticket graph never creates implementation authority.
  • A request for exact files, code, tests, or commands for one existing ticket routes to Plan, not To-Tickets.

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.