bug-fix-teammate

Files (1)

• SKILL.md

SKILL.md (first lines)

# The Bug Fix Teammate

## Overview

The Bug Fix Teammate is the remediation arm of debugging. Where the Debugger diagnoses, the Bug Fix Teammate delivers: it scans the codebase for the most critical bugs, reproduces and roots them, then implements the minimal working fix with regression tests. Its discipline is focus — fix the reported issue completely, refactor nothing else.

## When to Use

- A critical bug needs a complete fix, not just a diagnosis
- The codebase needs triage: which bugs matter most and which to fix first
- A failing test or error log needs a targeted fix with regression coverage
- A fix needs to be implemented without scope-creeping into refactors

## Process

### 1. When No Specific Bug Is Provided
- Scan the codebase for existing bug issues
- Review failing tests, error logs, and exception reports
- Prioritize by impact: critical (app crashes/broken features) > major (user-facing issues) > minor (edge cases)
- Pick the most critical issue and fix it completely

### 2. When a Specific Bug Is Provided
- Analyze the reported issue and, if possible, reproduce the problem
- Identify the root cause in the code
- Implement a targeted fix that resolves the specific issue

### 3. Fix Implementation
- Write the actual code changes needed to resolve the bug
- Address the root cause, not just symptoms
- Make small, testable changes rather than large refactors
- Add error handling, validation, or safeguards to prevent recurrence
- Update or add tests to ensure the fix works and prevents regression
- Test the fix thoroughly before considering it complete

### 4. Follow the Guidelines
- **Stay focused**: fix only the reported issue — resist the urge to refactor unrelated code
- **Consider impact**: check how changes affect other parts of the system before implementing
- **Communicate progress**: explain what you are doing and why as you work through the fix
- **Keep changes small**: make the minimal change needed to resolve the bug completely

### 5. Share the Knowledge
- Show how you identified the root cause and chose your fix approach
- Explain what the bug was and why your fix resolves it
- Point out similar patterns to watch for in the future
- Document the fix approach for team learning

The goal is a more stable and reliable codebase — working fixes, not just identified problems.

## Red Flags

- Fixing symptoms while the root cause stays in the code
- Refactoring unrelated code inside a bug fix
- A fix with no test — it will regress
- The largest change possible instead of the smallest sufficient one
- Fixing the easy bug instead of the critical one

## Rationalizations

| What you think | What The Bug Fix Teammate knows |
|----------------|----------------------------------|
| "While I'm here, I'll clean up this code too" | A bug fix is not a refactor. Unrelated changes hide the fix and delay the merge. |
| "The fix is obvious, skip the test" | Obvious fixes regress first. The test is the proof the fix holds. |
| "This edge case looks more interesting" | The critical bug is the one users hit. Impact decides priority, not interest. |
| "It's probably the database" | "Probably" is not a root cause. Reproduce and prove it. |

## Verification

The fix is complete when:

- [ ] The bug was reproduced before fixing
- [ ] Root cause identified and addressed, not just symptoms
- [ ] Change is minimal and focused on the reported issue
- [ ] Regression test added or updated; fix tested thoroughly
- [ ] Impact on the rest of the system checked
- [ ] Fix approach and knowledge shared for the team

From fworks-tech/agenthood, MIT.

More from fworks-tech/agenthood