skills.rest
Tcuzzo
TcuzzoCOMMUNITY
Explore all skills by this author →
GitHub

systematic-debugging

Diagnose bugs by tracing error paths and verifying live runtime state before fixing root causes.

1|Updated Jun 17, 2026
Search Tags:#debugging#troubleshooting#root cause analysis#bug fixing#error tracing#runtime verification
One-click install
npx skills add https://github.com/Tcuzzo/HydraAgent_public --skill systematic-debugging-tcuzzo
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/Tcuzzo/HydraAgent_public/tree/main/skills/systematic_debugging
Command: npx skills add https://github.com/Tcuzzo/HydraAgent_public --skill systematic-debugging-tcuzzo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Debugging under pressure often leads to symptom-patching: quick fixes that silence an error without addressing why it happened. This Skill enforces a disciplined root-cause workflow so bugs are actually fixed instead of temporarily hidden. ## Core Features & Use Cases - End-to-End Error Path Mapping: Trace every joined mechanism from the failure point back to its origin before proposing any change. - Live State Verification: Inspect real code and runtime state with file reads, directory listing, grep, and shell commands rather than relying on assumptions. - Root-Cause Fixing: Apply fixes at the source of the failure, never at the symptom level. - Use Case: A test suite fails intermittently in CI. Instead of retrying or adding a sleep, use this Skill to trace the actual error path, verify the live state of the involved components, and fix the underlying race condition. ## Quick Start Use the systematic-debugging skill to investigate why the login endpoint returns a 500 error and fix the root cause.

Frequently Asked Questions about systematic-debugging

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

FAQPage Schema
How do I find the root cause of a bug instead of patching symptoms?▼

Trace the error path end-to-end from the failure point back through every joined mechanism, verifying each step against live code and runtime state. Only propose a fix after the true origin of the failure is confirmed, never before.

How to debug unexpected behavior in a running application?▼

Verify hypotheses against live state using file reads, directory listing, grep searches, and shell commands rather than assuming how the code behaves. Map the real error path first, then fix the root cause at its source.

What tools does systematic debugging use to inspect code?▼

It uses fs_read for reading files, list_directory for exploring structure, grep for searching code patterns, and shell for running commands against live runtime state. These tools ground every conclusion in verified evidence.

Why do quick fixes keep breaking again later?▼

Quick fixes typically patch symptoms rather than root causes, so the underlying defect remains and resurfaces under different conditions. Tracing the full error path and fixing the origin prevents recurrence.

When should I not use a root-cause debugging approach?▼

Root-cause analysis takes longer than surface fixes, so for throwaway prototypes or time-critical mitigations a temporary workaround may be appropriate first. However, the root cause should still be traced and fixed before considering the issue resolved.

Related Skills

Explore More Software Engineering Skills→
EstomEstom

debugging-wizard

Diagnose errors and root causes from stack traces and logs.

Community
Advanced
adolfoaranaes12adolfoaranaes12
2

fix-issue

Reproduce bugs, identify root causes, and validate minimal fixes with the full test suite.

Community
Advanced
aqeelalamfca-sysaqeelalamfca-sys

fetch-deployment-logs

Fetch and filter deployment logs by timestamp and regular expressions.

Community
Intermediate
vieitesssvieitesss
7

finding-bug-commits

Identify the exact commit that introduced a bug using git bisect.

Community
Advanced