thunderstorm
Skill4 starsChanged 57 days agoApache-2.0View on GitHub
Run one thunderstorm loop over an issue and its sub-issues. Dispatches work, tracks status, reports, and stops. Use for /storm, /thunderstorm, or when asked to run an issue with sub-issues.
In this repository14 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- commits-and-prsSkill
- decomposeSkill
- github-boardSkill
- implementSkill
- releaseSkill
- reviewSkill
- reviseSkill
- rubber-duckSkill
- specifySkill
- triageSkill
- worktreeSkill
- writing-docsSkill
The file
We split this skill into the rules it gives an agent
8 rules. About 0 are common, 3 are distinctive, and 5 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈3
Distinctive · estimate
This author's own choices. Worth a look.
5
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 34
Stop and ask when any of these is true:
- Very specific: line 53
Read each sub-issue's blocked_by before claiming it, through the
- Distinctive: line 61
Every implementer you dispatch gets its own worktree, on either host, and you create it before dispatching rather than leaving the subagent …
- Very specific: line 77
When the pull request opens, move the issue to status:review.
- Very specific: line 79
Use the model assignments in internal/models.md.
- Very specific: line 84
Do not review the diff yourself.
- Very specific: line 120
Every sub-issue is terminal: status:done, status:verify, or status:dropped.
- Distinctive: line 139
Write code, edit files, or work in an implementer's tree.
≈ “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.
Files
Thunderstorm
One run covers one issue and the sub-issues declared under it. A human starts every run. Nothing here runs on a schedule.
A milestone is not that issue. It groups several of them and holds what crosses them, and it is not an issue at all, so there is nothing there to dispatch. Take the issues in a milestone one run each.
This skill dispatches and reports. It writes no code and edits no files; the
one thing it does in the checkout is create and remove the worktrees it hands
out. See internal/thunderstorm.md for the protocol this obeys.
Start
The argument is the number of an issue that has sub-issues. Read it and its children:
The github-board skill's Transport section decides whether this run uses gh
or the GitHub MCP tools. Use the same transport for everything below.
gh issue view <n> --json number,title,body,labels,url
gh issue view <n> --json subIssuesThrough MCP: issue_read method get, then method get_sub_issues.
Stop and ask when any of these is true:
- It declares no sub-issues. It is a unit of work; use
/implinstead. - It has more than five open sub-issues. Split it through
/decompfirst: a run holds every sub-issue it dispatches in one context, and past five that context is spent on work not yet started. - Its
Done whencondition is missing or not checkable. - Any sub-issue is already
status:claimedby another run.
Restate the stop condition before dispatching anything. A run whose ending you cannot state is not ready to start.
Dispatch
Take sub-issues one at a time unless two are genuinely independent and own
non-overlapping files. Two writers in one area produce rework, not throughput.
The triage skill's Lanes section says what may share a fan-out; a run
taking two at once applies those rules rather than deciding again.
Read each sub-issue's blocked_by before claiming it, through the
Dependencies section of github-board. An issue whose blockers are still
open is not claimable, whatever its status label says, and dispatching one
anyway produces a worker with nothing to build on. Independent in the dependency
graph is not the same as safe to run at once: check the file ownership this
issue records, and its milestone's description for what crosses to a sibling,
before taking two at a time.
Every implementer you dispatch gets its own worktree, on either host, and you
create it before dispatching rather than leaving the subagent to. Two of them
sharing a checkout share one HEAD, and the second to create its branch takes
the first's work onto it without git raising anything. Make it through the
worktree skill and pass no isolation on the dispatch itself. Tell the
implementer the directory it is to work in. That argument and whether the
implementer goes there are the two parts of this no check covers, so read its
report for the paths it touched rather than assuming.
For each sub-issue:
- Claim it through the
github-boardskill. - Give it a working tree through the
worktreeskill. - Dispatch an implementer. Give it the issue number, the acceptance criteria, the file ownership, the working directory, and the verification command. Nothing else.
- When the pull request opens, move the issue to
status:review.
Use the model assignments in internal/models.md. The implementer and the
reviewer never share a model within one run.
Review
Do not review the diff yourself. The review skill owns that, and the
orchestrator forming its own verdict defeats the separation the sequence exists
to create.
The sequence per pull request is /rev, /edit, /rev, /edit, /adv-rev,
/edit. Then stop. A human merges to edge.
Tell each pass which one it is, because nothing else can: a pass that reads the
thread to work it out gets the answer wrong. The first /rev reports its
findings to you and posts nothing, so hand them to the /edit that follows and
to the second /rev. They are the edit pass's only input, and the second pass
cannot say what survived the first without them. From the second pass on, each
pass comments for itself.
Report and continue
Report each sub-issue as it reaches status:review:
- what was claimed, and what its pull request number is;
- what verification ran and what it returned;
- what was filed as new work rather than absorbed;
- what remains queued under the issue.
Then take the next one. A run that stops after every sub-issue to ask makes the
operator the scheduler, which is the job this skill exists to do. Stop only on a
stop condition below, or when the argument was one.
End the run by listing every pull request it opened and whether its checks are green, so the operator sees what is waiting on them in one place. The merge itself is theirs: nothing here merges, and nothing here tells them a command to run that would.
Stop conditions
Any of these ends the run:
- Every sub-issue is terminal:
status:done,status:verify, orstatus:dropped. - The argument was
oneand the first sub-issue reachedstatus:review. - A sub-issue hits
status:blocked. - An edit pass exhausts its 5 cycles, or the same finding recurs unchanged.
- The work needs a decision the issues do not record.
Report the reason and what remains. Do not open new work to keep a run alive.
Scope
A worker that finds adjacent work files a new issue beside this one and does not start it. Self-expanding scope is how a run stops being one.
The Not in this issue section is binding, and so is the milestone's. Work named there gets
filed, never absorbed.
Do not
- Write code, edit files, or work in an implementer's tree.
- Merge, approve, or push to
edgeormain. - Change the protocol mid-run.
- Continue past a stop condition because the remaining work looks small.
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
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.

