Skip to main content
skill CX Codex

github-triage · sammcj — Claude Code skill: what it does, how to install

The github-triage skill sorts GitHub issues through labels and state changes, then guides maintainers through a decision. Use it for bugs, feature requests, and agent handoff.

Apache-2.0 ★ 173 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add sammcj/agentic-coding --skill github-triage -a claude-code
Open on GitHub

What github-triage does

github-triage works with issues in the current repository. It infers the repository from git remote and uses gh for GitHub operations. The skill can show groups that need attention, including unlabeled issues and issues awaiting triage or reporter input. For a selected issue, it reads the body, comments, labels, reporter details, and related code before presenting a recommendation.

Its workflow uses bug and enhancement categories plus states such as needs-triage, needs-info, ready-for-agent, ready-for-human, and wontfix. A maintainer can accept the recommendation, start a grilling session, or override the proposed state. Bug reports go through a reproduction attempt before that session. Any issue or comment created during triage must begin with the supplied AI disclaimer, which affects how this skill fits into a team’s GitHub workflow.

What it helps with

  • sort incoming GitHub issues by triage state
  • assign issue categories and workflow labels
  • prepare a fully specified issue for an AFK agent
  • try to reproduce a reported bug before discussion
  • surface issues that received new reporter activity

Example prompts for the agent

  • Run /github-triage and show me everything that needs my attention.
  • Run /github-triage and review issue #42, including a category and state recommendation.
  • Run /github-triage and prepare #42 for an AFK agent after checking the reported bug.

How to install github-triage

1Skills CLI (Vercel)

npx skills add sammcj/agentic-coding --skill github-triage -a claude-code

2Manually: put the files in place

~/.claude/skills/github-triage/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/github-triage/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about github-triage

How do I install github-triage in Claude Code?

Run npx skills add sammcj/agentic-coding --skill github-triage -a claude-code, then open ~/.claude/skills/github-triage/SKILL.md.

What does github-triage do?

It triages GitHub issues through category and state labels. The skill gathers repository context, recommends the next state, and helps the maintainer move the issue through the defined workflow.

What happens when an issue has conflicting state labels?

The skill flags the conflict and asks the maintainer which state is correct before taking further action. It also provides a recommendation.

Source text

SKILL.md · Apache-2.0
---
name: github-triage
description: Triage GitHub issues through a label-based state machine with interactive grilling sessions. Use when user wants to triage issues, review incoming bugs or feature requests, prepare issues for an AFK agent, or manage issue workflow.
---

# GitHub Issue Triage

Triage issues in the current repo using a label-based state machine. Infer the repo from `git remote`. Use `gh` for all GitHub operations.

## AI Disclaimer

Every comment or issue posted to GitHub during triage **must** include the following disclaimer at the top of the comment body, before any other content:

```
> *This was generated by AI during triage.*
```

## Reference docs

- [AGENT-BRIEF.md](AGENT-BRIEF.md) — how to write durable agent briefs
- [OUT-OF-SCOPE.md](OUT-OF-SCOPE.md) — how the `.out-of-scope/` knowledge base works

## Labels

| Label             | Type     | Description                              |
| ----------------- | -------- | ---------------------------------------- |
| `bug`             | Category | Something is broken                      |
| `enhancement`     | Category | New feature or improvement               |
| `needs-triage`    | State    | Maintainer needs to evaluate this issue  |
| `needs-info`      | State    | Waiting on reporter for more information |
| `ready-for-agent` | State    | Fully specified, ready for AFK agent     |
| `ready-for-human` | State    | Requires human implementation            |
| `wontfix`         | State    | Will not be actioned                     |

Every issue should have exactly **one** state label and **one** category label. If an issue has conflicting state labels (e.g. both `needs-triage` and `ready-for-agent`), flag the conflict and ask the maintainer which state is correct before doing anything else. Provide a recommendation.

## State Machine

| Current State  | Can transition to | Who triggers it        | What happens                                                                                                         |
| -------------- | ----------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `unlabeled`    | `needs-triage`    | Skill (on first look)  | Issue needs maintainer evaluation. Skill applies label after presenting recommendation.                              |
| `unlabeled`    | `ready-for-agent` | Maintainer (via skill) | Issue is already well-specified and agent-suitable. Skill writes agent brief comment, applies label.                 |
| `unlabeled`    | `ready-for-human` | Maintainer (via skill) | Issue requires human implementation. Skill writes a brief comment summarizing the task, applies label.               |
| `unlabeled`    | `wontfix`         | Maintainer (via skill) | Issue is spam, duplicate, or out of scope. Skill closes with comment (and writes `.out-of-scope/` for enhancements). |
| `needs-triage` | `needs-info`      | Maintainer (via skill) | Issue is underspecified. Skill posts triage notes capturing progress so far + questions for reporter.                |
| `needs-triage` | `ready-for-agent` | Maintainer (via skill) | Grilling session complete, agent-suitable. Skill writes agent brief comment, applies label.                          |
| `needs-triage` | `ready-for-human` | Maintainer (via skill) | Grilling session complete, needs human. Skill writes a brief comment summarizing the task, applies label.            |
| `needs-triage` | `wontfix`         | Maintainer (via skill) | Maintainer decides not to action. Skill closes with comment (and writes `.out-of-scope/` for enhancements).          |
| `needs-info`   | `needs-triage`    | Skill (detects reply)  | Reporter has replied. Skill surfaces to maintainer for re-evaluation.                                                |

An issue can only move along these transitions. The maintainer can override any state directly (see Quick State Override below), but the skill should flag if the transition is unusual.

## Invocation

The maintainer invokes `/github-triage` then describes what they want in natural language. The skill interprets the request and takes the appropriate action.

Example requests:

- "Show me anything that needs my attention"
- "Let's look at #42"
- "Move #42 to ready-for-agent"
- "What's ready for agents to pick up?"
- "Are there any unlabeled issues?"

## Workflow: Show What Needs Attention

When the maintainer asks for an overview, query GitHub and present a summary grouped into three buckets:

1. **Unlabeled issues** — new, no labels at all. These have never been triaged.
2. **`needs-triage` issues** — maintainer needs to evaluate or continue evaluating.
3. **`needs-info` issues with new activity** — the reporter has commented since the last triage notes comment. Check comment timestamps to determine this.

Display counts per group. Within each group, show issues oldest first (longest-waiting gets attention first). For each issue, show: number, title, age, and a one-line summary of the issue body.

Let the maintainer pick which issue to dive into.

## Workflow: Triage a Specific Issue

### Step 1: Gather context

Before presenting anything to the maintainer:

- Read the full issue: body, all comments, all labels, who reported it, when
- If there are prior triage notes comments (from previous sessions), parse them to understand what has already been established
- Explore the codebase to build context — understand the domain, relevant interfaces, and existing behavior related to the issue
- Read `.out-of-scope/*.md` files and check if this issue matches or is similar to a previously rejected concept

### Step 2: Present a recommendation

Tell the maintainer:

- **Category recommendation:** bug or enhancement, with reasoning
- **State recommendation:** where this issue should go, with reasoning
- If it matches a prior out-of-scope rejection, surface that: "This is similar to `.out-of-scope/concept-name.md` — we rejected this before because X. Do you still feel the same way?"
- A brief summary of what you found in the codebase that's relevant

Then wait for the maintainer's direction. They may:

- Agree and ask you to apply labels → do it
- Want to flesh it out → start a grilling session
- Override with a different state → apply their choice
- Want to discuss → have a conversation

### Step 3: Bug reproduction (bugs only)

If the issue is categorized as a bug, attempt to reproduce it before starting a grilling session. This will vary by codebase, but do your best:

- Read the reporter's reproduction steps (if provided)
- Explore the codebase to understand the relevant code paths
- Try to reproduce the bug: run tests, execute commands, or trace the logic to confirm the reported behavior
- If reproduction succeeds, report what you found to the maintainer — include the specific behavior you observed and where in the code it originates
- If reproduction fails, report that too — the bug may be environment-specific, already fixed, or the report may be inaccurate
- If the report lacks enough detail to attempt reproduction, note that — this is a strong signal the issue should move to `needs-info`

The reproduction attempt informs the grilling session and the agent brief. A confirmed reproduction with a known code path makes for a much stronger brief.

### Step 4: Grilling session (if needed)

If the issue needs to be fleshed out before it's ready for an agent, interview the maintainer to build a complete specification.

### Step 5: Apply the outcome

Depending on the outcome:

- **ready-for-agent** — post an agent brief comment (see [AGENT-BRIEF.md](AGENT-BRIEF.md))
- **ready-for-human** — post a comment summarizing the task, what was established during triage, and why it needs human implementation. Use the same structure as an agent brief but note the reason it can't be delegated to an agent (e.g. requires judgment calls, external system access, design decisions, or manual testing).
- **needs-info** — post triage notes with progress so far and questions for the reporter (see Needs Info Output below)
- **wontfix (bug)** — post a polite comment explaining why, then close the issue
- **wontfix (enhancement)** — write to `.out-of-scope/`, post a comment linking to it, then close the issue (see [OUT-OF-SCOPE.md](OUT-OF-SCOPE.md))
- **needs-triage** — apply the label. Optionally leave a comment if there's partial progress to capture.

## Workflow: Quick State Override

When the maintainer explicitly tells you to move an issue to a specific state (e.g. "move #42 to ready-for-agent"), trust their judgment and apply the label directly.

Still show a confirmation of what you're about to do: which labels will be added/removed, and whether you'll post a comment or close the issue. But skip the grilling session entirely.

If moving to `ready-for-agent` without a grilling session, ask the maintainer if they want to write a brief agent brief comment or skip it.

## Needs Info Output

When moving an issue to `needs-info`, post a comment that captures the grilling progress and tells the reporter what's needed:

```markdown
## Triage Notes

**What we've established so far:**

- point 1
- point 2

**What we still need from you (@reporter):**

- question 1
- question 2
```

Include everything resolved during the grilling session in "established so far" — this work should not be lost. The questions for the reporter should be specific and actionable, not vague ("please provide more info").

## Resuming Previous Sessions

When triaging an issue that already has triage notes from a previous session:

1. Read all comments to find prior triage notes
2. Parse what was already established
3. Check if the reporter has answered any outstanding questions
4. Present the maintainer with an updated picture: "Here's where we left off, and here's what the reporter has said since"
5. Continue the grilling from where it stopped — do not re-ask resolved questions

© sammcj · Apache-2.0 · sammcj/agentic-coding

Similar skills

All skills for Git and GitHub →

github-triage by other authors comes first.

github-triage code-yeongyu github-triage reads every open issue and PR in a repo and writes evidence-backed reports. It never comments, merges or closes anything. CX Codex +1 2,800installs github-triage trailofbits The github-triage skill reviews a repository’s open GitHub issues and pull requests, links pending fixes to issues, and prepares local priority and change-size estimates. CX Codex +1 1,900installs Issue Triage Agent microsoft Issue Triage Agent — a subagent for triaging individual GitHub issues. It categorizes tickets, assigns component labels, and sets priority levels based on repository guidelines. CX Codex +1 ★ 1,627repo stars issue-triage modelcontextprotocol issue-triage sorts incoming issues and PRs for the MCP servers repo. Moves valid tasks to the Servers V2 board and closes duplicates, spam, and misdirected requests with canned responses. CX Codex +1 ★ 92,149repo stars triage-issue official anthropics The triage-issue Claude Code command sorts GitHub issues and changes their labels. It runs for a new issue or after a comment to update lifecycle labels. CX Codex +1 ★ 156,584repo stars oh-my-issues thedotmack oh-my-issues — a skill for Claude Code and Codex clusters GitHub issue backlogs by root cause into plan-master issues. Runs during backlog triage and consolidation. CX Codex +1 4,500installs om-verify-in-repo open-mercato om-verify-in-repo — a skill for Claude Code runs read-only triage on tracker issues before triggering autofix workflows. It verifies defects and halts the pipeline with NO_ACTION_NEEDED if no work is required. CX Codex +1 3,500installs triage Matt Pocock This skill moves issues and external PRs through triage states, verification, and agent briefs. It fits maintainers managing an issue queue. CX Codex +1 990,453installs code-review Matt Pocock code-review evaluates code diffs along two parallel tracks: project standards and issue specifications. Uses isolated sub-agents to keep findings clean. CX Codex +1 789,521installs implement Matt Pocock Implements work from a specification or tickets, following a test-driven flow and ending with review and a commit. Use it when a coding task needs a defined delivery routine. CX Codex +1 774,700installs

From the same set73

The whole set →
guided-demo guided-demo adds interactive, self-running guided walkthroughs and typed narration overlays to web apps and HTML pages. CX Codex +1 ★ 173repo stars diagnose-hard-problem The diagnose-hard-problem skill guides Claude Code through a structured bug investigation, starting with a repeatable failure signal and narrowing the case before testing possible causes. Use it for regressions and intermittent bugs. CX Codex +1 ★ 173repo stars yue2-music yue2-music — a Claude skill that carries a YuE2 song from request to finished audio: three generation modes, covers transcribed with SheetSage2, and a local player for A/B listening. CX Codex +1 ★ 173repo stars swift-development swift-development enforces modern Swift 6 guidelines, region-based concurrency checks, and clean API conventions for macOS and iOS codebases. CX Codex +1 ★ 173repo stars authoring-claude-md authoring-claude-md is a Claude Code skill for creating and maintaining CLAUDE.md and .claude/rules/ files that record project context, architectural decisions, and non-obvious conventions. CX Codex +1 ★ 173repo stars bento-slides bento-slides is a Claude Code skill that creates and edits Bento presentations in single .bento.html files. It turns source material into slides. CX Codex +1 ★ 173repo stars code-review-recent-changes code-review-recent-changes reviews a diff from a fixed point along three separate axes and returns severity-ordered findings with a verdict. Handy before merging a branch or opening a PR. CX Codex +1 ★ 173repo stars aws-strands-agents-agentcore aws-strands-agents-agentcore guides development with AWS Strands Agents SDK and Amazon Bedrock AgentCore: architecture patterns, cloud deployment, and MCP server setup. CX Codex +1 ★ 173repo stars

Project sponsors

Companies that keep this analytics open