Issue Triage Streamlined

The Issue Triage Streamlined command automates the analysis, classification, and routing of incoming issues with intelligent priority assignment and team allocation. It examines issue content, applies classification rules, assigns severity and priority levels, and routes issues to the appropriate team or individual. Execute this command when your issue backlog needs systematic triage to transform an unstructured queue into an organized, prioritized work list.

When to Use This Command

Run this command when...

• Your issue backlog has accumulated untriaged items that need systematic classification and priority assignment
• You want to establish automated triage rules that classify new issues based on content, labels, and affected components
• You need to route issues to specific teams or individuals based on the area of the codebase they affect
• You are preparing for sprint planning and need to prioritize the backlog so that the highest-impact items are addressed first
• You want to identify duplicate issues, related issue clusters, and issues that can be closed as already resolved

Consider alternatives when...

• Issues are few enough that manual triage in the platform UI is more efficient than automated analysis
• You need to discuss individual issues with stakeholders before assigning priority, requiring interactive review rather than automated classification
• Triage decisions require domain-specific business context that automated rules cannot capture

Quick Start

Copy
# triage-config.yml
classification:
  categories: ["bug", "feature", "enhancement", "documentation", "question"]
  severity-rules:
    critical: ["crash", "data loss", "security"]
    high: ["broken", "regression", "blocker"]
    medium: ["unexpected", "incorrect", "slow"]
    low: ["cosmetic", "typo", "suggestion"]
routing:
  frontend: ["UI", "CSS", "component", "page"]
  backend: ["API", "database", "server", "auth"]
  infrastructure: ["CI", "deploy", "build", "docker"]
deduplication:
  enabled: true
  similarity-threshold: 0.8

Example invocation:

Copy
/issue-triage-streamlined --scope untriaged --assign --deduplicate

Example output:

Issue Triage Report
====================
Issues analyzed: 47 untriaged items

Classification results:
  Bugs: 18 (6 critical, 5 high, 4 medium, 3 low)
  Features: 14 (2 high, 8 medium, 4 low)
  Enhancements: 9 (3 medium, 6 low)
  Documentation: 4 (4 low)
  Questions: 2 (closed with answers)

Routing:
  Frontend team: 15 issues assigned
  Backend team: 22 issues assigned
  Infrastructure: 8 issues assigned
  Unroutable: 2 (require manual review)

Duplicates detected: 5
  #201 duplicates #189 (closed #201)
  #215 duplicates #203 (merged into #203)
  #222, #225, #228 cluster (consolidated into #222)

Immediate attention:
  #198: Critical - Authentication bypass in OAuth flow
  #205: Critical - Data corruption on concurrent writes

Core Concepts

Concept	Purpose	Details
Content Classification	Categorize issue type	Analyzes issue title, description, and labels to classify each issue as bug, feature, enhancement, documentation, or question
Severity Assessment	Gauge business impact	Applies keyword rules and pattern matching to assign severity levels based on the potential impact of the reported issue
Intelligent Routing	Direct to correct team	Maps issues to teams based on the affected codebase areas, component labels, and file paths mentioned in the issue description
Deduplication	Reduce redundant work	Compares new issues against existing ones using text similarity to identify duplicates and related issues for consolidation
Priority Scoring	Rank by importance	Combines severity, user impact, frequency, and effort estimates into a composite priority score for backlog ordering

Architecture: Triage Pipeline
================================

+-------------------+     +---------------------+     +------------------+
| Issue Fetcher     | --> | Content Analyzer    | --> | Classifier       |
| (untriaged queue) |     | (NLP extraction)    |     | (category + sev) |
+-------------------+     +---------------------+     +------------------+
                                                             |
                          +----------------------------------+
                          v
              +---------------------+     +-------------------+
              | Dedup Engine        | --> | Router + Assigner |
              | (similarity match)  |     | (team allocation) |
              +---------------------+     +-------------------+

Configuration

Parameter	Type	Default	Description
scope	string	"untriaged"	Issues to process: untriaged for unclassified items, all for full backlog re-triage, or a specific label filter
assign	boolean	false	Automatically assign issues to teams or individuals based on routing rules
deduplicate	boolean	true	Enable duplicate detection and consolidation for similar issues
auto-close	boolean	false	Automatically close issues classified as duplicates or already resolved
notify	boolean	true	Send notifications to assigned teams or individuals about newly triaged issues

Best Practices

1. Establish clear classification rules before running triage. Define what distinguishes a bug from an enhancement and what severity levels mean in your project's context. Ambiguous rules produce inconsistent triage results that require reclassification later, negating the automation's efficiency gains.

2. Review critical and high severity items immediately after triage. Automated severity assessment catches most urgent issues, but false positives and false negatives can occur. Quickly scan the critical and high severity lists to ensure genuinely urgent items are not misclassified and that non-urgent items are not consuming attention unnecessarily.

3. Tune deduplication sensitivity based on your issue patterns. The similarity threshold determines how aggressively the dedup engine consolidates issues. Too high a threshold misses duplicates; too low a threshold incorrectly merges distinct issues. Start with a moderate threshold and adjust based on false positive and false negative rates.

4. Use routing rules based on file paths rather than keywords alone. When issues mention specific files or directories, routing based on codebase ownership rules produces more accurate team assignments than keyword matching, which can be fooled by incidental word usage.

5. Run triage regularly to prevent backlog accumulation. Schedule triage runs weekly or trigger them on new issue creation to keep the backlog organized continuously. Allowing untriaged items to accumulate makes each triage session larger and increases the risk of missing urgent items.

Common Issues

Classification misidentifies feature requests as bugs. Issues that describe desired behavior changes are sometimes classified as bugs because they contain words like "broken" or "incorrect" in the context of user expectations. Refine classification rules to consider the full context of the issue description rather than isolated keywords.

Deduplication merges distinct issues that share similar descriptions. Issues about different features can have overlapping vocabulary that triggers false positive duplicate detection. Reduce the similarity threshold or add exclusion rules for issues that share terms but belong to different components or feature areas.

Routing assigns issues to the wrong team in cross-cutting concerns. Issues that span multiple subsystems such as a frontend bug caused by a backend API change may be routed to only one team. Configure multi-team routing for issues that affect multiple areas and establish a primary team assignment with secondary team notifications.