triage skill

---
name: Jira Issue Triage and Routing
description: This skill should be used when the user asks to "triage issue", "classify ticket", "route jira", "analyze priority", "categorize issue", "determine complexity", "route to agents", or needs guidance on classifying, prioritizing, and routing Jira issues to appropriate agents and workflows.
version: 1.0.0
trigger_phrases:
  - "triage issue"
  - "classify ticket"
  - "route jira"
  - "analyze priority"
  - "categorize issue"
  - "determine complexity"
  - "assess severity"
  - "route to agents"
  - "triage workflow"
  - "issue classification"
categories: ["jira", "triage", "routing", "classification", "prioritization"]
---

# Jira Issue Triage and Routing Skill

Intelligent classification, prioritization, and routing system for Jira issues.

## Triage Decision Tree

```
START: New Jira Issue
├─ Step 1: ISSUE TYPE CLASSIFICATION
│  ├─ Bug? → Classify severity (Blocker/Critical/Major/Minor) → HIGH Priority if Critical
│  ├─ Story/Feature? → Check requirements clarity, sprint scope, dependencies
│  ├─ Epic? → Route to epic-decomposer (NEVER implement directly)
│  ├─ Task? → Route by category (Tech Debt/Config/Docs/Infrastructure)
│  └─ Spike? → Time-box (1-2 days max) → Document findings → Create stories
│
├─ Step 2: COMPLEXITY ASSESSMENT (0-100 scale)
│  ├─ Code Impact: Single file (2) → Multiple services (10)
│  ├─ Integration: None (0) → Multiple external APIs (10)
│  ├─ Risk: None (0) → Critical/Data loss (10)
│  ├─ Testing: No tests (0) → Complex E2E scenarios (10)
│  ├─ Dependencies: None (0) → Multiple blocking (10)
│  └─ Uncertainty: Known (0) → Complete unknown (10)
│
│  Scoring: (Code×0.25 + Integration×0.20 + Risk×0.20 + Testing×0.15 + Dependencies×0.10 + Uncertainty×0.10) × 10
│
│  Categories:
│  • 1-20: SIMPLE → Quick-Fix Path (2-3 agents, 2-4 hrs)
│  • 21-40: MODERATE → Standard Workflow (3-5 agents, 2-5 days)
│  • 41-70: COMPLEX → Extended Workflow (5-10 agents, 5-10 days)
│  • 71+: VERY COMPLEX → Decomposition Path
│
├─ Step 3: PRIORITY & SEVERITY ASSESSMENT
│  ├─ Business Impact: Blocks production (BLOCKER) → Nice-to-have (LOW)
│  ├─ Urgency: Immediate (hours) → Backlog (months)
│  └─ Bug Severity Matrix:
│     • BLOCKER: Production down, data loss, security breach (1-4 hr SLA)
│     • CRITICAL: Major functionality broken (4-8 hr SLA)
│     • MAJOR: Important feature degraded (1-3 days)
│     • MINOR: Cosmetic issues (next sprint)
│
├─ Step 4: WORKFLOW ROUTING
│  ├─ QUICK-FIX: Simple (1-20), <50 LOC, low risk → EXPLORE→CODE→TEST→COMMIT
│  ├─ STANDARD: Moderate (21-40) → EXPLORE→PLAN→CODE→TEST→FIX→COMMIT
│  ├─ EXTENDED: Complex (41-70), high risk → All phases + extended thinking + checkpoints
│  ├─ RESEARCH: Spike/POC → RESEARCH→DOCUMENT→CREATE STORIES (time-boxed)
│  └─ DECOMPOSITION: Epic (71+) → ANALYZE→DECOMPOSE→CREATE STORIES→TRIAGE EACH
│
├─ Step 5: AGENT SELECTION
│  ├─ By Type: Bug→debugger; Story→feature-architect; Epic→epic-decomposer; Spike→research-specialist
│  ├─ By Tech: Frontend→react-specialist; Backend→nodejs/python/java-specialist; DevOps→k8s-specialist
│  ├─ By Phase: EXPLORE→code-analyst; PLAN→architect; CODE→tech-specific; TEST→test-engineer; COMMIT→git-specialist
│  └─ By Complexity: SIMPLE→2-3 junior agents; COMPLEX→5-10 seniors + extended thinking
│
├─ Step 6: RISK & ESCALATION
│  ├─ Risk Factors: Security, breaking changes, data migrations, compliance issues
│  ├─ Level 1 (IMMEDIATE STOP): Security vulnerability, data loss, compliance breach
│  ├─ Level 2 (CHECKPOINT): Complexity +50%, blocker >4hrs, breaking changes
│  └─ Level 3 (POST-COMPLETION): Standard bugs, docs, minor refactoring
│
└─ Step 7: OUTPUT ROUTING PACKAGE
   ├─ Classification, complexity score, priority, workflow path
   ├─ Agent selection, risk assessment, escalation triggers
   └─ Update Jira labels, assign workflow, spawn agents
```

## Issue Type Routing Matrix

| Type | Detection | Routing | Agents |
|------|-----------|---------|--------|
| **Bug** | Title: "bug", "broken", "error"; Stack trace present | Route by severity + "Can reproduce?" check | bug-fixer, debugger, root-cause-investigator |
| **Story** | "Add", "implement", "create"; User story format | Check requirements, sprint scope, decompose if >13 pts | requirements-analyzer, feature-architect, tech-specialists |
| **Epic** | Type=Epic; Multi-sprint scope | DECOMPOSE into 3-8 stories (Foundation→Core→Enhancement→Polish phases) | epic-decomposer, strategic-planner |
| **Task** | No user-facing change | Tech Debt→code-quality; Config→devops; Docs→doc-writer | domain-specialists |
| **Spike** | "Investigate", "research", "POC"; Unknown outcome | Time-box 1-2 days, document findings, create stories | research-specialist, poc-developer |

## Complexity Scoring Example

```
Issue: Add CSV export functionality

Code Impact: 5 (3-4 files, 200-300 LOC) × 0.25 = 1.25
Integration: 3 (internal APIs) × 0.20 = 0.60
Risk: 4 (file generation, perf) × 0.20 = 0.80
Testing: 6 (unit + integration) × 0.15 = 0.90
Dependencies: 2 (DB query opt) × 0.10 = 0.20
Uncertainty: 3 (format details) × 0.10 = 0.30

Score: 3.65 × 10 = 36.5 → MODERATE (5 story points)
→ Standard Workflow, 3-5 agents, 2-5 days
```

## Epic Decomposition Example

```
Epic: User Management System

Phase 1 (Sprint 1): PROJ-101 Profile CRUD (5pts), PROJ-102 RBAC (8pts), PROJ-103 Password Policy (3pts)
Phase 2 (Sprint 2): PROJ-104 Audit Logging (5pts), PROJ-105 MFA (8pts)
Phase 3 (Sprint 3): PROJ-106 Bulk Ops (5pts), PROJ-107 Import/Export (5pts)
Phase 4 (Sprint 4): PROJ-108 Analytics (8pts)

Dependencies: PROJ-102 blocks PROJ-106; PROJ-101 blocks PROJ-104
Total: 8 stories, 47 points, 4 sprints, 2-3 developers
```

## Workflow Paths

| Path | Criteria | Phases | Agents | Duration |
|------|----------|--------|--------|----------|
| **Quick-Fix** | Complexity 1-20, <50 LOC, low risk | EXPLORE→CODE→TEST→COMMIT | 2-3 | 2-4 hrs |
| **Standard** | Complexity 21-40, moderate risk | EXPLORE→PLAN→CODE→TEST→FIX→COMMIT | 3-5 | 2-5 days |
| **Extended** | Complexity 41-70, high risk | All phases + extended thinking + checkpoints | 5-13 | 5-10 days |
| **Research** | Spike/POC, time-boxed | RESEARCH→DOCUMENT→CREATE STORIES | 1-3 | 1-5 days |
| **Decomposition** | Epic, complexity 71+ | ANALYZE→DECOMPOSE→CREATE STORIES→TRIAGE | 2-4 | 1-2 days |

## Agent Selection by Phase

| Phase | SIMPLE | MODERATE | COMPLEX | VERY COMPLEX |
|-------|--------|----------|---------|--------------|
| EXPLORE | code-analyst (1) | code-analyst, requirements-analyzer (2) | code-analyst, dep-mapper, architect (3) | architect, senior-analyst (3) |
| PLAN | — | feature-architect (1) | feature-architect, code-architect (2) | senior-architect (2) |
| CODE | junior-dev (1-2) | tech-specialists (2-4) | tech-specialists (3-6) | senior-specialists (4-6) |
| TEST | test-runner (1) | test-engineer (1-2) | test-engineer, qa-specialist (2-3) | comprehensive-tester (2-4) |
| FIX | — | debugger (1) | debugger, refactoring-specialist (1-2) | senior-debugger (1-2) |
| COMMIT | git-specialist (1) | git-specialist (1) | git-specialist, doc-writer (1-2) | git-specialist, doc-writer (1-2) |

## Escalation Matrix

| Trigger | Level | Action | Timeline | Notify |
|---------|-------|--------|----------|--------|
| Security vulnerability | 1 IMMEDIATE | STOP work, create incident | Immediate | Security, management |
| Data loss risk | 1 IMMEDIATE | STOP work, document | Immediate | Ops, management |
| Complexity +50% | 2 CHECKPOINT | Pause, request decision | Same day | Tech lead, product owner |
| Blocker >4 hrs | 2 CHECKPOINT | Escalate blocker | Within 4 hrs | Blocking team, manager |
| Breaking change | 2 CHECKPOINT | Document impact, approve | 1-2 days | Affected teams |
| Standard bug fix | 3 POST-COMPLETION | Complete, notify | After done | Reviewer |

## Bug Routing Decision

```
Bug Detected
├─ Can reproduce consistently? NO → Gather reproduction steps
├─ Security vulnerability? YES → IMMEDIATE ESCALATION
├─ Severity?
│  ├─ BLOCKER/CRITICAL → Extended workflow, root-cause analysis, human checkpoints
│  ├─ MAJOR → Standard workflow, add regression tests
│  └─ MINOR → Quick-Fix path, batch with similar fixes
└─ Root cause known? NO → Extend EXPLORE phase with debugger/profiler
```

## Feature Routing Decision

```
Story/Feature Detected
├─ Requirements clear? NO → Route to requirements-analyzer first
├─ Single sprint scope? NO → Consider epic decomposition
├─ Tech complexity?
│  ├─ Frontend → UI specialists
│  ├─ Backend → API specialists
│  ├─ Full-stack → Both
│  └─ Infrastructure → DevOps specialists
├─ Integration complexity?
│  ├─ None → SIMPLE (1-20 pts)
│  ├─ Internal APIs → MODERATE (21-40 pts)
│  ├─ External APIs → COMPLEX (41-70 pts)
│  └─ Multiple external → VERY COMPLEX (71+ pts)
└─ Score 1-100 and route to appropriate workflow
```

## Spike Handling

```
Spike Detected
├─ Time-Box Definition (CRITICAL)
│  ├─ Small: 1 day max
│  ├─ Medium: 2-3 days max
│  └─ Large: 1 week max (justify)
├─ Research Phase: Investigate tech/approach, build POC if needed
├─ Document Phase: Write findings, recommend approach, estimate effort
└─ Output: Go/No-Go decision OR implementation stories with estimates
```

## Triage Output Checklist

- [ ] Issue classification (type, subtype, confidence)
- [ ] Complexity score (0-100) with factor breakdown
- [ ] Priority & severity assessment
- [ ] Workflow path selection (Quick-Fix/Standard/Extended/Research/Decomposition)
- [ ] Agent recommendations per phase
- [ ] Risk assessment and escalation level
- [ ] Dependencies and blockers
- [ ] Jira labels and field updates
- [ ] Execute workflow with selected agents