fix-bug

Diagnose and fix software bugs using a Test-Driven Development workflow.

3|1|Updated Feb 7, 2026
One-click install
npx skills add https://github.com/yon/agentic-dev-os --skill fix-bug-yon
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: fix-bug
Source: https://github.com/yon/agentic-dev-os/tree/main/.claude/skills/fix-bug
Command: npx skills add https://github.com/yon/agentic-dev-os --skill fix-bug-yon

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a structured, TDD-driven workflow to systematically diagnose, fix, and verify bugs, ensuring regressions are caught and fixes are robust.

Core Features & Use Cases

  • Reproduce Bugs: Write failing tests to precisely define and isolate bugs.
  • Root Cause Analysis: Guides investigation to find the underlying issue.
  • TDD Fixes: Implement minimal changes that pass the regression test.
  • Subagent Review: Leverages specialized reviewers for code and test quality.
  • Use Case: When a user reports unexpected application behavior, this Skill ensures a reliable process to fix it without introducing new issues.

Quick Start

Use the fix-bug skill to address the bug described in issue number 123.

Frequently Asked Questions about fix-bug

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I fix a software bug using TDD?

To fix a bug using TDD, you write a failing test that reproduces the issue, identify the root cause, implement a minimal code fix, and verify it with regression tests. This approach ensures the original bug is caught and prevents future regressions.

What is the best way to reproduce a bug before fixing it?

The best way to reproduce a bug is to write a failing test that precisely defines and isolates the unexpected behavior. This TDD-driven workflow confirms the bug's existence and provides a verifiable baseline for your regression testing.

How does root cause analysis work in a TDD debugging workflow?

Root cause analysis in a TDD debugging workflow guides your investigation to find the underlying issue causing the failing test. It shifts focus from patching symptoms to identifying the true source, enabling a minimal and robust code fix.

Can I enforce conventional commit standards when fixing bugs?

Yes, a systematic bug fixing workflow can enforce conventional commit standards for bug fixes. This ensures your version control history remains clean and descriptive while tying TDD regression tests directly to their corresponding code changes.

How do subagent reviews improve code quality during bug fixing?

Subagent reviews improve code quality during bug fixing by leveraging specialized reviewers to evaluate both the code fix and test quality. This automated review step ensures the TDD solution is robust and adheres to established engineering principles.

When should I use regression testing for bug fixes?

You should use regression testing after implementing a minimal fix to verify the solution works without introducing new issues. A TDD approach guarantees the original failing test passes and prevents unexpected application behavior from recurring.