systematic-debugging

Debug bugfix items by writing failing tests and coordinating parallel subagents.

Updated Jan 12, 2026
One-click install
npx skills add https://github.com/ben-mad-jlp/claude-mermaid-collab --skill systematic-debugging-ben-mad-jlp
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/ben-mad-jlp/claude-mermaid-collab/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/ben-mad-jlp/claude-mermaid-collab --skill systematic-debugging-ben-mad-jlp

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill enables rapid, test-first debugging of bugfix items by coordinating multiple subagents to reproduce, verify, and fix issues described in design documents.

Core Features & Use Cases

  • Test-first reproduction: Write a failing test that reproduces the bug before any fix attempts.
  • Parallel debugging workflow: Spawn 2–3 subagents to explore fixes concurrently and surface the best approach.
  • Design-doc integration: Update the design doc with the confirmed fix and record outcomes in the session state.
  • Use Case: When a design doc marks an item as bugfix, run a controlled debugging cycle that ends with a verified fix and documented rationale.

Quick Start

Initiate a bugfix debugging cycle by fetching the current bug item, write a failing test, run tests to confirm failure, spawn subagents to propose fixes, and update the design doc and session state upon success.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is test-first debugging and how does it handle bugfix items?

Test-first debugging enforces writing a failing test that reproduces the bug before attempting any fixes. It reads bugfix items from design docs, confirms the failure by running the test suite, and then proposes verified corrections.

How do I debug a bugfix item using parallel subagents?

To debug using parallel subagents, fetch the current bugfix item from the design doc, write a failing test, and spawn 2 to 3 subagents concurrently. These subagents explore and propose fixes simultaneously to surface the best approach.

Can I use subagents to reproduce and fix issues described in design documents?

Yes, subagents can reproduce and fix issues described in design documents. After a failing test confirms the bug, parallel subagents are spawned to explore fixes. Upon verification, the design doc and session state are updated with the confirmed fix.

What is the best way to coordinate multiple debugging approaches at once?

The best way to coordinate multiple debugging approaches is spawning parallel subagents. This workflow runs 2 to 3 subagents concurrently to explore proposed fixes, allowing you to compare approaches and select the verified best solution.

Does systematic debugging require a design doc to start a bugfix cycle?

Yes, a design doc is required. The debugging cycle reads the current bugfix item directly from the design doc to understand the issue, and later updates that same design doc with the confirmed fix and documented rationale.

Why should I write a failing test before attempting a bugfix?

Writing a failing test before a bugfix ensures accurate reproduction of the issue. Running the test suite to confirm the failure prevents false positives, ensuring that any proposed fix from subagents actually resolves the targeted problem.