Skip to main content
skill CX Codex

issue-triage · decebals — Claude Code skill: GitHub issue categorization and prioritization

Automate GitHub issue triage: sort incoming tasks by type (bugs, features, questions), assign priority labels, and flag duplicates. Use during backlog cleanup, weekly reviews, or after returning from time off.

MIT 254 installs ★ 778 updated 2026-09-06

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

What issue-triage does

issue-triage processes GitHub issues and applies type labels: bug for reproducible errors with stack traces, enhancement for feature requests, question for support inquiries, and detects duplicates by matching keywords and error messages. Each issue receives a priority ranking: critical for security flaws or complete breakdowns, high-priority for broken core functionality, medium-priority for edge cases and valuable enhancements, low-priority for cosmetic fixes.

The skill includes response templates for common scenarios: requesting more details, closing duplicates, declining features with rationale, and confirming confirmed bugs. Built for Java projects within the claude-code-java ecosystem on GitHub.

Batch processing saves substantial token overhead: triaging 10–20 issues in one request instead of individually cuts token cost by 60%. The GitHub MCP server is recommended for caching issue lists; without it, the gh CLI works but requires more context per operation.

What it helps with

  • Sort incoming issues by type and priority in a single pass
  • Identify and link duplicate issues
  • Send templated responses: request info, reject with reasoning, confirm bug
  • Add labels and milestones for release planning
  • Process a backlog of dozens of issues with minimal token overhead

Example prompts for the agent

  • Triage the last 20 open issues, assign priorities and labels
  • Review issue #234: is this a bug, duplicate, or feature request? Recommend next steps
  • Process the full backlog after time off: categorize, find duplicates, flag critical tasks

How to install issue-triage

1Skills CLI (Vercel)

npx skills add decebals/claude-code-java --skill issue-triage -a claude-code

2Manually: put the files in place

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

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

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

Questions about issue-triage

How do I install issue-triage in Claude Code?

Run npx skills add decebals/claude-code-java --skill issue-triage -a claude-code, then open ~/.claude/skills/issue-triage/SKILL.md.

What does the issue-triage skill do?

Categorizes GitHub issues with labels (bug, enhancement, question, duplicate), assigns severity levels (critical, high, medium, low), and provides templates for common responses. Cuts backlog processing time and reduces context switching.

Is the GitHub MCP server required?

Not required, but recommended. With MCP, the skill caches issue lists and cuts token use by ~60%. The gh CLI is a fallback but less efficient for batched operations.

Source text

SKILL.md · MIT
---
name: issue-triage
description: Triage and categorize GitHub issues with priority labels. Use when user says "triage issues", "check issues", "review open issues", or during regular maintenance of GitHub issue backlog.
license: MIT
---

# Issue Triage Skill

Efficiently triage GitHub issues for Java projects with categorization and prioritization.

## When to Use
- User says "triage issues" / "check recent issues"
- Regular maintenance workflow
- After vacation/break (backlog processing)
- Weekly/monthly issue review

## Prerequisites

**Recommended**: GitHub MCP server configured for optimal token usage
```bash
claude mcp add github --transport http \
  https://api.githubcopilot.com/mcp/
```

**Alternative**: Use `gh` CLI (less token-efficient)

## Workflow

### 1. Fetch Issues

**With GitHub MCP** (recommended):
```
Tool: list_issues
Parameters: {
  "state": "open",
  "sort": "updated", 
  "per_page": 10
}
```

**With gh CLI**:
```bash
gh issue list --state open --limit 10 --json number,title,labels,body,url
```

### 2. Categorize Each Issue

Analyze issue content and assign category:

#### Bug Report ✅
**Indicators**:
- Has stack trace or error message
- Steps to reproduce provided
- Expected vs actual behavior described
- Mentions specific version numbers

**Actions**:
- Label: `bug`
- Verify reproducibility from description
- Check for duplicate bugs
- Add to milestone if critical

**Example**:
```
Issue #234: "NPE when loading plugin from directory"
- Stack trace: ✅
- Reproduction steps: ✅
- Version info: ✅
→ Label: bug, high-priority
```

#### Feature Request 💡
**Indicators**:
- Asks for new functionality
- Use case described
- "It would be nice if..." / "Could you add..."
- Rationale provided

**Actions**:
- Label: `enhancement`
- Assess alignment with project goals
- Mark for discussion if non-trivial
- Ask for community feedback

#### Question/Support ❓
**Indicators**:
- "How do I..." / "Can someone help..."
- Configuration/usage questions
- Not a bug or feature request

**Actions**:
- Label: `question`
- Provide answer or link to docs
- Suggest StackOverflow for complex help
- Close after answer if resolved

#### Duplicate 🔄
**Search for similar issues**:
- Use GitHub search: `is:issue <keywords>`
- Check recently closed issues
- Look for same error messages

**Actions**:
- Link to original: "Duplicate of #123"
- Close with polite comment
- Ask reporter to comment on original if they have additional info

#### Invalid/Unclear ⚠️
**Indicators**:
- Missing critical information
- Off-topic or spam
- Not enough context to proceed

**Actions**:
- Request clarification with template
- Set "needs-more-info" label
- Auto-close if no response after 14 days

### 3. Priority Assessment

#### Critical (P0) 🔴
**Criteria**:
- Security vulnerability
- Data loss/corruption risk
- Complete functionality breakdown
- Affects production systems

**Actions**:
- Label: `critical`
- Notify maintainers immediately
- Add to current milestone
- Consider hotfix release

**Examples**:
```
- "SQL injection vulnerability in plugin loader"
- "All plugins fail to load after upgrade"
- "ClassLoader leak causes OutOfMemoryError"
```

#### High (P1) 🟠
**Criteria**:
- Core feature broken
- Affects many users
- Workaround exists but painful
- Regression from previous version

**Actions**:
- Label: `high-priority`
- Add to next milestone
- Include in release notes

**Examples**:
```
- "Plugin dependencies not resolved correctly"
- "Hot reload crashes application"
```

#### Medium (P2) 🟡
**Criteria**:
- Edge case bug
- Enhancement with clear value
- Documentation gap
- Affects some users occasionally

**Actions**:
- Label: `medium-priority`
- Consider for future milestone
- Good for contributors

**Examples**:
```
- "Improve error message for invalid plugin"
- "Add plugin lifecycle listener"
```

#### Low (P3) 🟢
**Criteria**:
- Nice-to-have feature
- Cosmetic issues
- Very rare edge case
- Documentation improvements

**Actions**:
- Label: `low-priority`
- "Contributions welcome" tag
- Backlog for future

**Examples**:
```
- "Add more examples to README"
- "Typo in JavaDoc"
```

### 4. Response Templates

#### Need More Information
```markdown
Thanks for reporting this issue! 

To investigate further, could you provide:
- Java version (java -version)
- Library version
- Minimal reproducible example
- Full stack trace (if applicable)
- Configuration files (if relevant)

This will help us diagnose and fix the issue faster.
```

#### Duplicate
```markdown
Thanks for reporting! This is being tracked in #123.

Closing as duplicate. Feel free to add any additional context 
or information to the original issue.
```

#### Won't Fix (with rationale)
```markdown
Thank you for the suggestion. After consideration, this doesn't 
align with the project's current direction because [reason].

Consider [alternative approach] instead, which might better 
serve your use case.

If you feel strongly about this, please open a discussion in 
our [forum/discussions] to gather community feedback.
```

#### Acknowledged Bug
```markdown
Confirmed! This is a valid bug. 

I've added it to milestone X.Y and labeled it as [priority].
Contributions welcome if anyone wants to tackle it!

Reproduction verified with:
- Java 17
- Version 3.10.0
- Ubuntu 22.04
```

#### Feature Request - Under Consideration
```markdown
Interesting idea! This aligns with our goal of [project goal].

I've labeled this as 'enhancement' for further discussion.
Community feedback welcome - upvote with 👍 if you'd find 
this useful.

Some questions to consider:
- [question 1]
- [question 2]
```

#### Question Answered
```markdown
To achieve this, you can [solution].

Example:
\`\`\`java
[code example]
\`\`\`

Also check our documentation: [link]

Let me know if this solves your issue!
```

## Token Optimization Strategies

### Batch Processing
```bash
# Process multiple issues in one prompt
"Triage issues #234-243, categorize and prioritize"
```

**Savings**: ~60% fewer tokens vs one-by-one

### Use Structured GitHub MCP Calls
- One call to list issues → cache results
- Targeted calls for details only when needed
- Batch label updates

**Savings**: ~40% fewer tokens vs repeated bash calls

### Cache Issue List
```bash
# First prompt
"Fetch the last 20 issues, save list in memory"

# Subsequent prompts
"Analyze issue #5 from cached list"
"Mark #7-#9 as duplicate"
```

### Focus on First Post + Recent Comments
- Don't read entire 50-comment threads
- Skim first post for context
- Check last 2-3 comments for updates

## Anti-patterns

❌ **Avoid**:
```
# One-by-one processing
"Check issue #234"
"Now check issue #235"
"Now check issue #236"
→ Wastes tokens on repeated context loading

# Over-analyzing
Reading entire 100-comment thread
Checking all related PRs
Deep diving into code for each issue
→ Diminishing returns after certain point

# Premature closing
Closing issues without proper investigation
Missing duplicates due to poor search
→ Frustrates users, creates duplicate work
```

✅ **Prefer**:
```
# Batch operations
"Triage issues #234-250, categorize, prioritize"

# Quick triage decisions
Fast categorization → Can revisit if needed
Surface-level analysis for most issues
Deep dive only for critical/complex ones

# Thorough duplicate search
Quick keyword search before marking duplicate
Link to specific comment if clarification exists
```

## Automation Opportunities

### Auto-close stale issues
```bash
# Issues with no activity for 90 days and "needs-more-info" label
"Find stale issues (>90 days, needs-more-info label), 
suggest closing with polite message"
```

### Label by keywords
```bash
# Auto-label based on content
"java.lang.NullPointerException" → bug
"add support for" → enhancement
"how do I" → question
```

### Weekly summary
```bash
# Generate triage summary
"Summarize issues from last week:
- New bugs: X
- Feature requests: Y
- Questions: Z
- Closed: W"
```

## Integration with GitHub

### With GitHub MCP
```javascript
// Structured workflow
1. list_issues → get open issues
2. get_issue → details for each
3. add_labels → categorize
4. create_comment → respond
5. close_issue → if needed
```

### With gh CLI
```bash
# List issues
gh issue list --json number,title,labels,body

# View specific issue
gh issue view 234

# Add labels
gh issue edit 234 --add-label "bug,high-priority"

# Comment
gh issue comment 234 --body "Thanks for reporting..."

# Close
gh issue close 234 --comment "Fixed in v2.1"
```

## Metrics to Track

After each triage session, report:

```
📊 Triage Summary
─────────────────
Issues processed: 15
├─ Bugs: 5 (2 critical, 3 high)
├─ Enhancements: 4
├─ Questions: 3
├─ Duplicates: 2
└─ Invalid: 1

Actions taken:
├─ Labeled: 15
├─ Responded: 12
├─ Closed: 3
└─ Milestoned: 5

Time saved: ~45 minutes (vs manual)
Token usage: 3,200 tokens
```

## Best Practices

1. **Regular cadence** - Weekly triage prevents backlog
2. **Be respectful** - Users took time to report
3. **Link resources** - Docs, related issues, examples
4. **Ask questions** - Better to clarify than assume
5. **Welcome contributions** - Encourage community involvement
6. **Track patterns** - Common issues suggest documentation gaps
7. **Celebrate reporters** - Thank users for good bug reports
8. **Close decisively** - Don't let issues linger indefinitely

## Example Workflow

```bash
# Monday morning triage
claude code ~/projects/pf4j

> view .claude/skills/issue-triage/SKILL.md
> "Triage the last 15 issues from pf4j/pf4j,
   categorize, prioritize and suggest responses"

[Claude analyzes and presents summary]

> "Apply labels and post the suggested responses"

[Claude executes actions]

> "Generate summary for release notes"
```

**Result**: 15 issues triaged in ~10 minutes vs ~45 minutes manual

© decebals · MIT · decebals/claude-code-java

Similar skills

All skills for Git and GitHub →

issue-triage by other authors comes first.

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 issue-triage Cobus Greyling Scans open issues and discussions, finds duplicates, and sets P0–P3 priorities. It records actionable queues in issue-triage-state.md. CX Codex +1 ★ 11,819repo stars issue-triage Cobus Greyling issue-triage is a Claude Code skill that sorts open issues and discussions, spots possible duplicates, and suggests priorities and labels. It writes results to issue-triage-state.md. CX Codex +1 ★ 11,819repo stars oss-issue-triage Samuel Berthe oss-issue-triage designs an issue and pull-request triage system sized to what a maintainer team can actually sustain: labels, intake, response targets, duty rotation. CX Codex +1 13,400installs antfu-issue-triage Anthony Fu antfu-issue-triage — a skill for Claude Code that investigates open GitHub issues and pull requests in the active repository. It detects resolved bugs, duplicates, and spam, generating an action plan before edits. CX Codex +1 413installs issue-label toss issue-label is a Claude Code skill that reads GitHub issue content, selects a label from the project matrix, and applies it with one command. CX Codex +1 206installs 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 triage SethGammon triage — a skill for investigating GitHub issues and reviewing PRs. Reads open issues, classifies them, searches the codebase for root cause, proposes fixes with file:line references, and optionally implements them. CX Codex +1 ★ 937repo stars 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 set18

The whole set →
performance-smell-detection performance-smell-detection flags code-level performance smells in Java, covering streams, collections, boxing, and regex compiled inside loops. Helps during code reviews of performance-critical paths. CX Codex +1 361installs test-quality test-quality — a skill that writes high-quality Java unit tests using JUnit 5 and AssertJ. Enable it to add tests to your code or improve test coverage. CX Codex +1 356installs api-contract-review api-contract-review is a Claude Code skill that checks REST API contracts for HTTP semantics, versioning, and compatibility. Run it on a request to review an API or before releasing API changes. CX Codex +1 329installs maven-dependency-audit maven-dependency-audit is a skill that checks Maven dependencies for outdated versions, conflicts and known CVEs. Run it before a release or after a security advisory lands. CX Codex +1 322installs jpa-patterns jpa-patterns teaches coding agents to fix N+1 queries, resolve LazyInitializationException, and manage Spring JPA transactions cleanly. CX Codex +1 313installs logging-patterns The logging-patterns skill shapes Java logging with SLF4J, JSON records, and MDC context. Use it when an agent must trace requests or inspect application logs. CX Codex +1 313installs changelog-generator changelog-generator builds changelogs from conventional commits and helps prepare a release entry. It is aimed at Java projects with a git history. CX Codex +1 265installs git-commit git-commit generates Conventional Commits messages for Java codebases based on staged changes inspected with git diff. CX Codex +1 264installs

Project sponsors

Companies that keep this analytics open