home / skills / dasien / claudemultiagenttemplate / bug-triage

This skill guides systematic bug triage by reproducing issues, isolating root causes, and selecting optimal fix strategies for reliable resolutions.

npx playbooks add skill dasien/claudemultiagenttemplate --skill bug-triage

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.6 KB
---
name: "Bug Triage"
description: "Systematically reproduce, diagnose, and analyze bugs to determine root cause, assess severity, and plan fix strategy"
category: "analysis"
required_tools: ["Read", "Write", "Grep", "Glob", "Bash"]
---

# Bug Triage

## Purpose
Systematically analyze bug reports to reproduce issues, identify root causes, assess severity and impact, and determine the appropriate fix strategy and priority.

## When to Use
- Analyzing incoming bug reports
- Investigating production issues
- Diagnosing test failures
- Planning bug fix work
- Prioritizing bug backlog

## Key Capabilities
1. **Bug Reproduction** - Create reliable steps to reproduce the issue
2. **Root Cause Analysis** - Identify underlying cause, not just symptoms
3. **Severity Assessment** - Determine impact and urgency accurately

## Approach
1. **Understand the Report** - Read bug description and symptoms
2. **Reproduce the Bug** - Create minimal reproduction steps
3. **Isolate the Cause** - Use logs, debugging, code inspection
4. **Assess Impact** - Determine affected users and severity
5. **Determine Fix Strategy** - Quick patch vs architectural fix
6. **Document Findings** - Clear report for implementation team

## Example
**Context**: Bug report "Users can't log in"
```markdown
## Bug Analysis

**Symptoms**:
- Users see "Invalid credentials" error
- Occurs only for accounts created after Oct 15
- Works fine for older accounts

**Reproduction Steps**:
1. Create new user account
2. Log out
3. Attempt to log in with correct credentials
4. Observe error message

**Root Cause**:
- Code inspection of auth system
- Found: Password hashing algorithm changed Oct 15
- Old accounts use bcrypt, new accounts use argon2
- Login validation only checks bcrypt

**Location**: `src/auth/validator.py:45-67`

**Impact**:
- Severity: Critical (blocks all new users)
- Affected: ~500 accounts created in last week
- Workaround: None available

**Fix Strategy**:
- Update validator to check both hash types
- Add migration for existing argon2 hashes
- Estimated effort: 2 hours (small fix)
- Testing required: Auth system regression tests

**Priority**: Critical - Fix immediately
**Recommended Agent**: implementer (straightforward code fix)
```

## Best Practices
- ✅ Always try to reproduce before diagnosing
- ✅ Check logs and error messages first
- ✅ Use Grep/Glob to find related code quickly
- ✅ Document exact reproduction steps
- ✅ Consider data issues, not just code bugs
- ✅ Assess severity objectively (not all bugs are critical)
- ❌ Avoid: Assuming the cause without investigation
- ❌ Avoid: Treating all bugs as equally urgent

Overview

This skill provides a structured process for reproducing, diagnosing, and analyzing software bugs to determine root cause, assess severity, and plan an effective fix strategy. It focuses on creating minimal reproducible steps, isolating the underlying fault, and delivering a clear, actionable report for engineers. The goal is faster resolution with fewer regressions and better prioritization of work.

How this skill works

The skill inspects bug reports, logs, test outputs, and code to establish reliable reproduction steps. It uses targeted debugging and code inspection to isolate the cause, evaluates user and system impact to assign severity, and recommends a fix strategy—ranging from quick patches to architectural changes. Findings are documented with location, impact, recommended actions, estimated effort, and testing needs.

When to use it

  • Triage incoming bug reports to verify and prioritize them
  • Investigate production incidents and determine root cause
  • Diagnose failing tests and flaky behavior in CI
  • Plan work and estimate effort for bug backlog items
  • Decide whether a bug needs an immediate hotfix or scheduled fix

Best practices

  • Always reproduce the issue before proposing a fix
  • Start with logs and error messages to narrow scope quickly
  • Create minimal, deterministic reproduction steps
  • Check for data or configuration issues as well as code faults
  • Document findings: reproduction, root cause, impact, and fix plan
  • Assess severity objectively based on user impact and scope

Example use cases

  • A login flow breaks for newly created accounts—determine whether hashing or validator logic changed
  • A production endpoint intermittently times out—reproduce under load and inspect upstream services
  • A unit test begins failing after a dependency upgrade—isolate change and decide rollback or patch
  • New feature introduces a memory leak—identify allocation site and recommend short-term mitigation and refactor
  • Triage a backlog of UI bugs to create prioritized implementation tasks for the next sprint

FAQ

What if I cannot reproduce the bug locally?

Collect environment details, logs, and a failing request trace; attempt reproduction in a staging or sandbox that mirrors production. If still unreproducible, document conditions and escalate for deeper telemetry or a user-provided recording.

How do I decide between a quick patch and an architectural fix?

Weigh user impact, recurrence risk, and cost of change. Use quick patches for immediate mitigation when impact is high, but plan an architectural fix if the defect indicates a recurring or systemic issue.