agentleFS
stormlightlabsstormlightlabs/thunderus/.claude/skills/triage/SKILL.md

triage

Skill4 starsChanged 57 days agoApache-2.0View on GitHub

Read the whole board and rank what to dispatch next, as lanes that several threads can work at once. Use for /triage, for deciding what to work across parent issues, or before dispatching more than one thread.

190 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use writing-beats, setup-matt-pocock-skills 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.
  • LesaniSkill

    writing-beats

    Shape an article as a journey of beats, choose-your-own-adventure style. The user picks a starting beat from the raw material, you write only that beat, then offer options for where to pivot next, beat by beat, until the article reaches a natural end. Use when the user has raw material and wants to assemble it as a narrative rather than an argument.

    Also in 66 projects that use this

  • GoogleSkill

    setup-matt-pocock-skills

    Configure this repo for the engineering skills — set up its issue tracker, triage label vocabulary, and domain doc layout. Run once before first use of the other engineering skills.

    Also in 167 projects that use this

  • 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 42 projects that use this

  • SethGammonSkill

    ascii-diagram

    Generate perfectly aligned ASCII diagrams — architecture, flow, sequence, box-and-arrow. Uses a programmatic character-grid approach so alignment is guaranteed by math, not token prediction. Includes post-render verification.

    Also in 4 projects that use this

  • simo97Skill

    migrate-to-shoehorn

    Migrate test files from `as` type assertions to @total-typescript/shoehorn. Use when user mentions shoehorn, wants to replace `as` in tests, or needs partial test data.

    Also in 68 projects that use this

  • LesaniSkill

    writing-shape

    Take a markdown file of raw material and shape it into an article through a conversational session — drafting candidate openings, growing the piece paragraph by paragraph, arguing about format (lists, tables, callouts, quotes) at each step. Use when the user has a pile of notes, fragments, or a rough draft and wants help turning it into something publishable.

    Also in 63 projects that use this

  • +1 more from Lesani

The file

We split this skill into the rules it gives an agent

5 rules. 0 are common, 3 are distinctive, and 2 are very specific to this project.

  • 0

    Common

    Most of the 179 edited versions we read keep these.

  • 3

    Distinctive

    This author's own choices. Worth a look.

  • 2

    Very specific

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

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

    Every argument is prefixed, because the two numeric ones are otherwise the same token: /triage 3 could ask for three threads or for issue 3.

    line 30
  2. Distinctive:

    Read the whole board every pass, whatever the argument narrows.

    line 47
  3. Distinctive:

    Only the claimable bucket is ranked.

    line 89
  4. Very specific:

    Leave out a heading with nothing under it, and say status:verify and status:blocked work is waiting rather than listing it every pass.

    line 192
  5. Distinctive:

    Write a file, set a label, claim an issue, or open anything.

    line 207

“Common” is measured: kept by at least 6 in 10 of the 179 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

Triage

One pass over the whole board. It produces an order to dispatch in and a plan for running several issues at once. It reads everything and writes nothing.

/storm runs one issue and its sub-issues. This chooses among them, and among the issues that belong to no milestone at all.

The list is re-derived, never stored

Report to chat. Do not write a file, post the list to an issue, or set a label. A list of pending work is stale the moment one issue closes, and a stale copy outranks the board in the next reader's attention. internal/thunderstorm.md states that rule under File conventions.

Two threads that both run this reach the same order, because they read the same board and apply the rules below in the same sequence. What stops them working the same issue is the claim, not the list, under github-board's Claim.

Triage does not claim ahead either. A claim reserves work the thread may never start, which is the stale state the 24-hour rule exists to undo.

Argument

Every argument is prefixed, because the two numeric ones are otherwise the same token: /triage 3 could ask for three threads or for issue 3.

FormMeans
threads=<n>Plan for n threads. Without it, two.
#<n> or milestone:<name>Narrow to that issue, or to a milestone's issues.
area:<name>Narrow to issues carrying that label.
Anything elseAd-hoc work, under Ad-hoc work below.

A narrowing argument changes which issues are ranked and laid into lanes, and nothing else: read the whole board anyway, and report the repairs, the in-flight work and the issues no run reaches across all of it. Those are what a narrowed pass would otherwise stop surfacing.

Read

Read the whole board every pass, whatever the argument narrows.

One paginated call over the repository's open issues carries almost all of it, including the summary objects that answer the buckets and two of the rank rules without a second request per issue. File ownership is the one thing it does not carry, and that comes from the body above each candidate: its own issue, and the milestone over it.

references/reading-the-board.md has the commands, the fields and what each one decides, and why the MCP tools cannot replace the call.

Work no run can reach

An open issue with an empty parent_issue_url is under no parent, and /storm dispatches an issue's children, so no run reaches it however long it stays queued. It is still claimable and it still ranks, and /impl takes it directly.

Report the count and the top five by rank, not the list. There are about forty of these, and printing them all buries the lanes.

Buckets

Set the run units aside first. One carries no status:* label and is not work, so it is not bucketed or ranked. What they contribute is sub_issues_summary to rank rule 3, and their bodies to the lanes.

Sort every other open issue into the first row it matches, top down. The order is the precedence: a claim that has gone stale is a repair before it is somebody's work in flight.

BucketHolds
Needs repairAny shape under Repairs below.
In flightstatus:claimed or status:review. Another thread has it.
Waitingstatus:verify, or status:blocked inside its 7 days.
Not claimablestatus:queued with blocked_by above zero, or an assignee.
Claimablestatus:queued, no assignee, blocked_by zero.

An issue with no status:* label reaches none of these rows, which is why the first one catches it: it is a repair, not a bucket.

Only the claimable bucket is ranked. Report the rest; they are what tells the human the board is not the shape they thought.

Repairs

Each shape breaks a rule another document owns. Report it and name the rule; the repair itself is a github-board write a human authorizes.

ShapeRule
status:claimed past 24 hours with no pull requestinternal/thunderstorm.md, Statuses
status:blocked past 7 days, or with no blocked:* reasonthe same
Two status:* labels on one issue, or nonegithub-board, Status
An issue with children carrying status:* or risk:*decompose, The issue a run takes
More than five open children on a run unitdecompose, Sizing

The first two are ages, and updated_at does not measure them: any comment or label bumps it, so an abandoned claim reads fresh the moment someone comments. The reference above gives the timeline read that does, and says to report an age as unverified rather than passing updated_at off as an answer.

Rank

Apply these to the claimable bucket in order, each one breaking the ties the one above it leaves. State which rule placed the top few, so a reader who disagrees knows which rule to argue with.

  1. What it unblocks. The count of open issues in its blocking set, highest first. Work that nothing waits on scores zero and sorts below work that holds something up.
  2. type:fix ahead of the rest. A fix names behavior that is wrong now, and everything else is built on top of it.
  3. The issue nearest finishing. Its parent's sub_issues_summary, by completed against total, highest first. A sub-issue whose siblings have mostly landed outranks one under an issue nothing has started: finishing one retires its coordination cost, and starting another adds one. Work under no parent scores zero here and is broken out of by rule 4.
  4. Oldest first. A stable tiebreaker. The oldest queued issue has already lost every ordering before this one.

Risk does not enter the rank. It decides lanes instead, below.

Lanes

A lane is what one thread works, in sequence. threads=<n> says how many; without it, plan two.

Two issues may sit in different lanes only when they own non-overlapping files. Ownership lives in the body above them, under the decompose skill's Recording overlap: the run unit's body for its own sub-issues, its milestone's description for what crosses its children. Honor those as written, including an instruction to sequence a whole issue around one sub-issue: a run works one issue and cannot see its siblings.

Where nothing records ownership, say so and treat every pair under it as overlapping: an unrecorded overlap found by two implementers costs a rework, and holding an issue for one round costs a round.

area:* is a warning rather than a verdict, too broad to decide by. Name the shared area, then decide on files.

Two issues never share a fan-out:

  • Either carries risk:high. It touches released behavior, data, or security, and it wants a thread and a review sequence to itself.
  • Either has sub-issues. implement refuses an issue with children, so it is something /storm takes, not a lane entry.

Three issues per lane is enough. Past that the plan is a backlog, and the board already holds one.

Ad-hoc work

Work that is not filed cannot be ranked, because no other thread can see it. A thread dispatched on an unfiled item holds something invisible, and the next thread picks the same work up with nothing to warn it.

Name ad-hoc work in the argument and triage places it in the order, marked off-board, with what it would displace. File it through /decomp before any thread takes it. Triage does not file it: a command that ranks work should not also create the work it ranks.

Report

Open with one count line, so the shape of the board is readable before the detail:

46 open · 5 claimable · 2 in flight · 1 blocked · 3 need repair · 4 parents runnable

Then, under 40 lines, in this order:

HeadingCarries
Dispatch nowOne block per lane: number, title, type:*, risk:*, parent.
HeldClaimable but overlapping a lane. Name what it overlaps on.
Not claimableThe open blocker, or the assignee.
In flightWhat the other threads hold, so nothing dispatches over them.
No run reachesHow many sit under no parent, and the top five.
Needs repairThe transition each one wants, for a human to authorize.

Leave out a heading with nothing under it, and say status:verify and status:blocked work is waiting rather than listing it every pass.

Close by naming the rule that placed the first entry and what would change the order. A plan whose reasoning is not visible cannot be argued with.

Then give the literal next command, so the operator reads a line to type rather than a plan to translate:

/storm 75     # or: /impl 91 for a lane entry under no parent

Do not

  • Write a file, set a label, claim an issue, or open anything.
  • Rank an issue in the in-flight, repair, or not-claimable buckets.
  • Fan out two issues whose file ownership is unrecorded.
  • Invent a priority signal the board does not carry. The rules above are the whole ordering; a fifth one that lives only in a report is unarguable.

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.