skills.rest
kwasi-cpu
kwasi-cpuCOMMUNITY
Explore all skills by this author →
GitHub

systematic-debugging

Guide root cause investigation of software bugs through a four-phase process.

Updated Aug 27, 2026
Search Tags:#debugging#investigation#troubleshooting#software development#root cause analysis#bug fixing
One-click install
npx skills add https://github.com/kwasi-cpu/hermes-agent --skill systematic-debugging-kwasi-cpu
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/kwasi-cpu/hermes-agent/tree/main/skills/software-development/systematic-debugging
Command: npx skills add https://github.com/kwasi-cpu/hermes-agent --skill systematic-debugging-kwasi-cpu

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the common and costly issue of inefficient bug fixing by enforcing a structured, root-cause-driven investigation process, preventing wasted time and the introduction of new errors.

Core Features & Use Cases

  • Systematic Root Cause Analysis: Guides users through a four-phase process to identify the fundamental reason for a bug, not just its symptoms.
  • Error Message Interpretation: Emphasizes careful reading and understanding of error messages and stack traces.
  • Reproducibility: Focuses on reliably reproducing the issue before attempting any fixes.
  • Change Analysis: Integrates checking recent code changes (git diffs) as a key investigation step.
  • Data Flow Tracing: Provides methods to trace data flow in complex, multi-component systems.
  • Hypothesis Testing: Encourages forming and testing specific hypotheses with minimal changes.
  • Architectural Questioning: Prompts users to question the underlying architecture when multiple fixes fail.
  • Use Case: When a critical test fails in a CI/CD pipeline, this Skill ensures the engineer thoroughly investigates the error, reproduces the failure, checks recent commits, and traces the data flow to pinpoint the exact line of code or configuration issue causing the problem, rather than making a speculative change.

Quick Start

Use the systematic-debugging skill to investigate a test failure by carefully reading error messages and reproducing the issue.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
What is the best way to find the root cause of a software bug instead of just fixing symptoms?▼

A systematic debugging process guides you through four phases: interpreting error messages, reproducing the failure, analyzing recent code changes, and tracing data flow to pinpoint the fundamental reason for the bug.

How do I troubleshoot a critical test failure in a CI/CD pipeline?▼

Troubleshooting a CI/CD test failure involves carefully reading the error stack trace, reliably reproducing the issue locally, checking recent git diffs for changes, and tracing data flow to pinpoint the exact line of code or configuration causing the problem.

Why should I reproduce a bug before attempting a code fix?▼

Reproducing a bug reliably confirms the exact conditions triggering the unexpected behavior, ensuring that any hypothesis you form and test minimally targets the actual root cause rather than a speculative code change.

How can I trace data flow in a complex multi-component system to investigate unexpected behavior?▼

Tracing data flow in complex systems involves using file search and terminal tools to gather evidence across components, analyzing how data transforms at each step, and forming specific hypotheses about where the unexpected behavior originates.

What should I do when multiple bug fixes fail to resolve a software issue?▼

When multiple bug fixes fail, you should question the underlying software architecture, re-evaluate recent code changes via git diffs, and trace data flow to ensure you are addressing the actual root cause and not just symptoms.

Does systematic debugging require any specific testing frameworks or dependencies to work?▼

Systematic debugging requires no specific testing frameworks or dependencies; it integrates with standard tools like search_files, read_file, and terminal for evidence gathering and analysis during the root cause investigation process.

Related Skills

Explore More Software Engineering Skills→
kynoptickynoptic
1

Debugging Runtime Errors

Analyze stack traces and error logs to identify root causes and propose fixes.

Community
Advanced
dmae97dmae97
130

omk-flow-bugfix

Guide bug resolution from reproduction evidence to root-cause analysis and minimal code changes.

Community
Intermediate
mwaymway
4

systematic-debugging

Identify root causes of bugs and test failures through a four-phase debugging workflow.

Community
Advanced
romiluz13romiluz13
161

root-cause-analysis

Guide root cause analysis through evidence collection and hypothesis testing.

Community
Basic