OpenClaw GitHub Issue Triage Skill: Automate Your Issue Management

GitHub Issue Triage is the second most popular OpenClaw skill with 1,240 community stars because it solves a universal problem: engineering teams spend 2-4 hours per week manually labeling, routing, and closing issues. This skill automates that entire workflow so your team focuses on code instead of inbox management.

This guide covers the complete setup for automating issue triage including labeling strategies, team routing rules, bulk operations, and real-world workflows that save 80+ hours per team per quarter.

What GitHub Issue Triage Automates

The skill transforms your issue workflow from manual overhead into zero-touch infrastructure. Every new issue is processed automatically within seconds of creation, and bulk operations run on existing backlogs during off-hours.

Concrete automation capabilities:

• Auto-labeling by keyword analysis — Scan issue title and body for terms like auth, database, or security and apply the matching label immediately.
• File path-based labeling — If the issue mentions src/auth/** or contains stack traces pointing to authentication code, tag it with area:auth.
• Team routing based on CODEOWNERS — Assign issues to the developer who maintains the affected files, following your existing CODEOWNERS configuration.
• Custom routing rules by component — Route all frontend issues to the UI team, backend issues to the API team, and infrastructure issues to DevOps, using configurable matchers.
• Duplicate detection and merging — Compare new issues against recent submissions using semantic similarity and suggest duplicates for manual review or auto-close.
• Stale issue closing — Automatically close issues with no activity for 30+ days after posting a final “This issue is being closed due to inactivity” comment.
• Sprint planning summaries — Generate a digest of all new issues from the past week, grouped by label and priority, and post it to Slack or save it as a planning document.

The skill runs continuously in the background, triggered by GitHub webhooks for real-time processing, or on a schedule for batch operations like stale issue cleanup.

Why This Saves Time

Manual triage costs add up quickly. A team of five engineers triaging 20 issues per week spends:

Activity	Manual Time/Week	With Automation
Labeling issues	45 minutes	0 minutes
Routing to assignees	30 minutes	0 minutes
Closing duplicates	20 minutes	5 minutes (review only)
Stale issue cleanup	15 minutes	0 minutes
Total per week	110 minutes	5 minutes

Over a quarter, that is 14 hours of engineering time returned to feature work. Scale that across a 20-person team and the savings become structural.

Prerequisites

Before starting, verify these resources are available:

• GitHub account with admin or write access to the target repository
• GitHub Personal Access Token with the repo scope (full repository access including issues, labels, and assignments)
• OpenClaw 2026.1.0 or later installed and running on a host with continuous uptime (cloud VM, dedicated server, or Docker container)
• Webhook endpoint if you want real-time issue processing (optional but recommended)

If you do not have OpenClaw installed yet, follow the installation guide and return here after openclaw --version reports 2026.1.0 or newer.

Installation and Configuration

Step 1: Create GitHub Personal Access Token

1. Navigate to GitHub Settings > Developer settings > Personal access tokens
2. Click Generate new token (classic)
3. Set a descriptive name: OpenClaw Issue Triage
4. Select scopes:
   • repo (full control of private repositories)
   • workflow if your triage rules need to trigger Actions
5. Set expiration to 90 days and add a calendar reminder to rotate it
6. Click Generate token and copy the token immediately

Store the token securely. You will not see it again.

Step 2: Install the GitHub Issue Triage skill

From your OpenClaw host, run:

openclaw skill install github-issue-triage

Verify installation:

openclaw skill list | grep github-issue-triage

Expected output:

github-issue-triage (v2.4.1) — Automate issue labeling, routing, and triage workflows

Step 3: Configure authentication

Set your GitHub token as an environment variable:

openclaw config set github.token "ghp_yourPersonalAccessTokenHere"

Verify authentication:

openclaw skill exec github-issue-triage --test-auth

Expected output:

✓ Authenticated as: your-username
✓ Scopes: repo, workflow
✓ Rate limit: 5000/5000 remaining

Step 4: Configure repository allowlist

Restrict the skill to specific repositories to prevent accidental operations on unintended projects:

openclaw config set github.repos "your-org/repo-name,your-org/another-repo"

For organization-wide operation (use cautiously):

openclaw config set github.repoPattern "your-org/*"

Step 5: Enable auto-labeling and auto-assignment

openclaw config set github.autoLabel true
openclaw config set github.autoAssign true

Step 6: Start the skill

openclaw skill start github-issue-triage

Confirm the skill is running:

openclaw skill status github-issue-triage

Expected output:

Status: running
Repositories: 2 monitored
Last activity: 12 seconds ago
Issues processed today: 0

Step 7: Test with a sample issue

Create a test issue in one of your configured repositories with a title like:

Auth system returns 500 on login

Within 30 seconds, the skill should:

• Add the area:auth label
• Add the priority:high label if configured
• Assign to the CODEOWNERS maintainer for src/auth/**

Check the issue on GitHub to verify labels and assignees were applied. If nothing happened, consult the troubleshooting section below.

Configuration Reference

All configuration lives in your OpenClaw config file at ~/.openclaw/config.yaml or is set via openclaw config set. Here is the complete reference with defaults and examples.

Core settings

github:
  token: "ghp_yourTokenHere"
  repos: "your-org/repo1,your-org/repo2"
  repoPattern: ""  # Use "org/*" for org-wide, overrides repos list
  autoLabel: true
  autoAssign: true
  staleDays: 30
  webhook:
    enabled: false
    port: 9100
    secret: ""

Auto-labeling configuration

Enable or disable automatic label application based on issue content:

github:
  autoLabel: true
  labelRules:
    - keywords: ["auth", "login", "oauth", "jwt"]
      label: "area:auth"
    - keywords: ["database", "sql", "postgres", "migration"]
      label: "area:database"
    - keywords: ["ui", "frontend", "react", "css"]
      label: "area:frontend"
    - keywords: ["api", "backend", "endpoint", "rest"]
      label: "area:backend"
    - keywords: ["security", "vulnerability", "cve"]
      label: "priority:critical"
      alsoLabel: "security"
    - keywords: ["crash", "panic", "segfault"]
      label: "priority:high"
    - keywords: ["typo", "docs", "documentation"]
      label: "priority:low"

The skill checks both the issue title and body. If any keyword matches, all specified labels are applied. The alsoLabel field allows adding multiple labels from a single rule.

File path-based labeling

Apply labels when issues reference specific file paths or stack traces:

github:
  pathLabelRules:
    - pattern: "src/auth/**"
      label: "area:auth"
    - pattern: "src/db/**"
      label: "area:database"
    - pattern: "frontend/**"
      label: "area:frontend"
    - pattern: "api/**"
      label: "area:backend"
    - pattern: "infra/**"
      label: "area:infrastructure"
    - pattern: "test/**"
      label: "type:test"

Patterns use glob syntax. The skill extracts file paths from markdown code blocks, stack traces, and inline code references automatically.

Team routing rules

Assign issues to team members based on keywords, file paths, or round-robin scheduling:

github:
  autoAssign: true
  assignmentRules:
    - label: "area:auth"
      assignTo: ["alice", "bob"]
      mode: "round-robin"
    - label: "area:database"
      assignTo: ["charlie"]
    - label: "priority:critical"
      assignTo: ["team-lead"]
      notifySlack: true
    - pathPattern: "frontend/**"
      assignTo: ["dana", "eve"]
      mode: "load-balanced"  # Assign to whoever has fewest open issues

The mode field supports:

• round-robin — Rotate through the list on each assignment
• load-balanced — Assign to the person with the fewest currently assigned issues
• all — Assign to everyone in the list (use for critical issues requiring team visibility)

CODEOWNERS integration

If your repository has a .github/CODEOWNERS file, the skill can automatically assign issues to the owners of affected files:

github:
  useCodeowners: true
  codeownersFallback: "maintainers-team"  # Assign here if no CODEOWNERS match

With this enabled, the skill reads your CODEOWNERS file and assigns issues based on the file paths mentioned in the issue body. If no file path is detected, it falls back to the configured team or user.

Stale issue handling

Automatically close issues with no activity after a configurable period:

github:
  staleEnabled: true
  staleDays: 30
  staleLabel: "stale"
  staleComment: |
    This issue has been inactive for 30 days and is being closed.
    If this is still relevant, please reopen with updated context.
  exemptLabels: ["pinned", "security", "roadmap"]

Issues with any of the exemptLabels are never marked stale. The skill posts the staleComment before closing, giving reporters a final chance to respond.

Auto-Labeling Strategies

Effective auto-labeling requires a well-structured label taxonomy and rules tuned to your team’s language. Start with broad categories and refine as false positives appear.

Recommended label structure

Use a two-level hierarchy with a prefix system:

• area:auth — Authentication and authorization
• area:database — Database, migrations, queries
• area:frontend — UI, React, CSS, design
• area:backend — API, server logic, business rules
• area:infrastructure — DevOps, CI/CD, deployment
• priority:critical — Production down, security incident
• priority:high — Major bug, blocks users
• priority:medium — Standard bug or feature
• priority:low — Typos, minor improvements
• type:bug — Something is broken
• type:feature — New functionality request
• type:docs — Documentation improvement

This structure supports filtering by area, priority, and type simultaneously.

Keyword-based rules

The simplest labeling strategy matches keywords in the issue title or body:

labelRules:
  - keywords: ["crash", "exception", "error", "failed"]
    label: "type:bug"
  - keywords: ["feature request", "enhancement", "add support"]
    label: "type:feature"
  - keywords: ["typo", "spelling", "grammar"]
    label: "priority:low"

Tune the keyword lists by reviewing recent issues and identifying common patterns. Avoid overly broad terms like “issue” or “problem” that generate false positives.

File path-based rules

When issues include stack traces or mention specific files, use path patterns for accurate labeling:

pathLabelRules:
  - pattern: "src/auth/**"
    label: "area:auth"
  - pattern: "src/api/v2/**"
    label: "area:backend"
    alsoLabel: "api:v2"
  - pattern: "frontend/components/**"
    label: "area:frontend"
    alsoLabel: "type:ui"

This approach has higher precision than keyword matching because file paths are explicit references to code areas.

Custom label taxonomies

If your team uses different naming conventions, adjust the rules to match:

labelRules:
  - keywords: ["login", "signup", "password"]
    label: "component:authentication"
  - keywords: ["checkout", "payment", "stripe"]
    label: "component:payments"
  - keywords: ["search", "filter", "query"]
    label: "component:search"

Consistency matters more than the specific names. Pick a taxonomy and enforce it with automation.

Combining rules for precision

Apply multiple labels by chaining rules:

labelRules:
  - keywords: ["security", "vulnerability"]
    label: "security"
    alsoLabel: "priority:critical"
  - keywords: ["crash", "segfault"]
    label: "type:bug"
    alsoLabel: "priority:high"

An issue titled “Security vulnerability causes crash in auth module” would receive:

• security
• priority:critical
• type:bug
• priority:high (duplicate priority labels can be deduplicated in config)
• area:auth (from keyword “auth”)

If this over-labels, add a maxLabelsPerIssue setting to cap the total applied labels.

Team Routing and Assignment

Automatic assignment reduces the time between issue creation and first response. Configure routing to match your team’s structure and expertise.

CODEOWNERS integration

If your repository has a .github/CODEOWNERS file, enable automatic assignment based on file ownership:

github:
  useCodeowners: true

Example CODEOWNERS file:

# Authentication module
src/auth/**          @alice @bob

# Database layer
src/db/**            @charlie

# Frontend
frontend/**          @dana @eve

# API routes
src/api/**           @frank

# Infrastructure
infra/**             @devops-team

When an issue mentions a file path like src/auth/jwt.ts or includes a stack trace pointing to that file, the skill assigns the issue to @alice and @bob automatically.

Custom routing rules

For teams without CODEOWNERS or for more complex routing logic, define explicit rules:

assignmentRules:
  - label: "area:auth"
    assignTo: ["alice", "bob"]
    mode: "round-robin"
  - label: "area:database"
    assignTo: ["charlie"]
  - label: "priority:critical"
    assignTo: ["team-lead"]
    notifySlack: true
    slackChannel: "#incidents"

With round-robin, the skill maintains a counter and alternates between assignees on each new issue. With load-balanced, it queries the GitHub API to count each person’s currently assigned issues and picks the one with the lightest load.

Expertise-based routing

For specialized areas, assign to individuals with specific expertise:

assignmentRules:
  - keywords: ["kubernetes", "k8s", "deployment"]
    assignTo: ["devops-alice"]
  - keywords: ["machine learning", "ml", "model"]
    assignTo: ["ml-bob"]
  - keywords: ["security", "cve", "vulnerability"]
    assignTo: ["security-team"]
    alsoNotify: ["ciso"]

The alsoNotify field adds subscribers without formal assignment, useful for visibility on high-stakes issues.

Fallback assignment

When no rule matches, assign to a default maintainer or team:

github:
  defaultAssignee: "maintainer-team"

This prevents issues from falling through the cracks when they do not match any specific routing rule.

Bulk Operations

The skill supports batch processing for existing backlogs. Use these operations during off-hours to minimize API rate limit impact.

Labeling all open issues

Apply labeling rules retroactively to all open issues:

openclaw skill exec github-issue-triage --bulk-label --repo your-org/repo-name

This queries all open issues, applies the configured label rules, and updates each issue. For large repositories (500+ open issues), this may take 10-15 minutes due to rate limiting.

Closing stale issues

Identify and close issues with no activity in the past 30 days:

openclaw skill exec github-issue-triage --close-stale --dry-run

The --dry-run flag shows which issues would be closed without actually closing them. Review the output, then run without the flag to execute:

openclaw skill exec github-issue-triage --close-stale

The skill posts a final comment before closing, giving reporters notice and an opportunity to reopen if needed.

Duplicate detection and merging

Scan recent issues for duplicates using semantic similarity:

openclaw skill exec github-issue-triage --detect-duplicates --days 90

The skill compares issue titles and bodies using embedding-based similarity and generates a report:

Potential duplicates found:

#1234 "Auth fails after upgrade"
  → Possible duplicate of #1189 (similarity: 0.89)

#1256 "Login broken on mobile"
  → Possible duplicate of #1234 (similarity: 0.92)

Review the suggestions and close duplicates manually, or enable auto-close with:

github:
  duplicateDetection:
    enabled: true
    similarityThreshold: 0.85
    autoClose: false  # Set to true for automatic closing
    comment: "This appears to be a duplicate of #{{original}}. Closing to consolidate discussion."

When autoClose: true, the skill automatically closes duplicates and references the original issue.

Real-World Workflow Examples

These workflows show how teams integrate GitHub Issue Triage into daily operations.

Daily triage routine

A small team of 5 engineers processes new issues every morning at 9 AM:

1. The skill runs overnight, labeling and assigning all new issues
2. Each engineer checks their assigned issues at standup
3. Critical issues (labeled priority:critical) are reviewed first
4. The team lead reviews any issues that did not match assignment rules

Before automation, this took 30 minutes per day. After automation, it takes 5 minutes.

Sprint planning automation

Every Monday at 8 AM, the skill generates a sprint planning summary:

openclaw skill exec github-issue-triage --sprint-summary --days 7 --output sprint-summary.md

Output format:

# Sprint Planning Summary — Week of 2026-02-24

## New Issues This Week: 18

### By Priority
- Critical: 2
- High: 5
- Medium: 8
- Low: 3

### By Area
- area:auth: 4 issues
- area:database: 3 issues
- area:frontend: 7 issues
- area:backend: 4 issues

### Critical Issues Requiring Immediate Attention
- #1234: Auth system down in production
- #1245: Database migration failed on staging

### Stale Issues Closed This Week: 12

The summary is posted to Slack automatically or saved as a planning document for the Monday standup.

Release blocker identification

During release week, the skill monitors for issues labeled release-blocker:

github:
  monitorLabels:
    - label: "release-blocker"
      notifySlack: true
      slackChannel: "#release-team"
      notifyEmail: "release-manager@company.com"

Any new issue with this label triggers immediate notifications to the release team.

Troubleshooting

Permission errors

Symptom: Skill fails with 403 Forbidden or 401 Unauthorized.

Cause: GitHub token lacks required scopes or has expired.

Fix:

1. Verify token scopes at GitHub Token Settings
2. Ensure the repo scope is enabled
3. Regenerate the token if it has expired
4. Update OpenClaw config: openclaw config set github.token "new-token-here"
5. Restart the skill: openclaw skill restart github-issue-triage

Rate limit handling

Symptom: Skill logs show Rate limit exceeded, retrying in 3600 seconds.

Cause: GitHub API enforces a rate limit of 5,000 requests per hour for authenticated users. Bulk operations can exceed this limit.

Fix:

1. Reduce bulk operation frequency
2. Use --dry-run to preview changes before executing
3. Split large repositories into multiple runs with delays
4. Upgrade to GitHub Enterprise for higher rate limits (10,000 requests/hour)

Check current rate limit:

openclaw skill exec github-issue-triage --rate-limit

Label conflicts

Symptom: Multiple rules apply conflicting labels like priority:high and priority:low to the same issue.

Cause: Overlapping keyword rules or misconfigured label hierarchies.

Fix:

1. Review your label rules for overlapping keywords
2. Use more specific keywords or add exclusion patterns
3. Enable label deduplication:

github:
  deduplicateLabels: true
  labelPriority:  # Higher priority labels override lower ones
    - "priority:critical"
    - "priority:high"
    - "priority:medium"
    - "priority:low"

With deduplicateLabels enabled, only the highest priority label from each category is applied.

FAQ

Does this work with GitHub Enterprise?

Yes. The skill supports GitHub Enterprise Server and GitHub Enterprise Cloud. Configure the base URL:

openclaw config set github.baseUrl "https://github.company.com/api/v3"

GitHub Enterprise has higher rate limits (10,000 requests per hour) which improves bulk operation performance. All features work identically to public GitHub.

Can I customize label names?

Yes. The skill uses your repository’s existing labels. If a label does not exist when the skill tries to apply it, the skill creates it automatically with a default color. To use your own label names, update the rule configuration:

labelRules:
  - keywords: ["auth"]
    label: "component:authentication"  # Use your label name here

To customize label colors, create the labels manually in your repository settings before enabling the skill.

How does duplicate detection work?

The skill uses sentence embeddings to compute semantic similarity between issue titles and bodies. When a new issue is created, it compares it against all issues opened in the past 90 days (configurable). If the similarity score exceeds the threshold (default 0.85), the skill flags it as a potential duplicate.

The similarity threshold ranges from 0.0 (completely different) to 1.0 (identical). A threshold of 0.85 catches near-duplicates while avoiding false positives. Lower the threshold to catch more potential duplicates at the cost of more manual review.

Duplicate detection requires the OpenClaw embedding model, which is included in the default installation. No additional setup is required.

Next Steps

With GitHub Issue Triage running, explore related workflows and integrations:

1. Top 10 OpenClaw Skills 2026 — Discover other popular skills to automate your workflow
2. GitHub Issue Triage Skill Details — View community examples and advanced configurations
3. Linear Integration Guide — Sync GitHub issues to Linear for cross-tool project management
4. Incident Response Playbook — Handle production issues with structured AI-assisted workflows

For questions or advanced configuration help, join the OpenClaw Discord where the community shares triage rules, label taxonomies, and routing strategies.

---

GitHub Issue Triage saves engineering teams 80+ hours per quarter by automating the repetitive work of labeling, routing, and closing issues. Start with one repository, prove the time savings, then scale across your organization.