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→triage-agent; Story→requirements-analyzer; Epic→epic-decomposer; Spike→requirements-analyzer
│ ├─ By Tech: Frontend→react-specialist; Backend→nodejs/python/java-specialist; DevOps→k8s-specialist
│ ├─ By Phase: EXPLORE→requirements-analyzer; PLAN→architect; CODE→tech-specific; TEST→test-strategist; COMMIT→commit-orchestrator
│ └─ 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 |
triage-agent, hypothesis-debugger, root-cause-analyzer |
| Story |
"Add", "implement", "create"; User story format |
Check requirements, sprint scope, decompose if >13 pts |
requirements-analyzer, requirements-analyzer, task-enricher |
| 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 |
requirements-analyzer, requirements-analyzer |
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 |
requirements-analyzer (1) |
requirements-analyzer, requirements-analyzer (2) |
requirements-analyzer, dep-mapper, architect (3) |
architect, senior-analyst (3) |
| PLAN |
— |
requirements-analyzer (1) |
requirements-analyzer, code-architect (2) |
senior-architect (2) |
| CODE |
junior-dev (1-2) |
task-enricher (2-4) |
task-enricher (3-6) |
senior-specialists (4-6) |
| TEST |
test-runner (1) |
test-strategist (1-2) |
test-strategist, qa-ticket-reviewer (2-3) |
comprehensive-tester (2-4) |
| FIX |
— |
hypothesis-debugger (1) |
hypothesis-debugger, code-quality-enforcer (1-2) |
senior-debugger (1-2) |
| COMMIT |
commit-orchestrator (1) |
commit-orchestrator (1) |
commit-orchestrator, documentation-hub (1-2) |
commit-orchestrator, documentation-hub (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 hypothesis-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