skills.rest
felix-howard
felix-howardCOMMUNITY
Explore all skills by this author →
GitHub

Debugging

Guide root cause investigation through a four-phase debugging process.

Updated Jan 11, 2026
Search Tags:#testing#debugging#troubleshooting#root cause analysis#validation#bug fixing
One-click install
npx skills add https://github.com/felix-howard/ella --skill debugging-felix-howard
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: Debugging
Source: https://github.com/felix-howard/ella/tree/main/.claude/skills/debugging
Command: npx skills add https://github.com/felix-howard/ella --skill debugging-felix-howard

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill provides a structured approach to identifying and fixing bugs, preventing superficial fixes and ensuring root causes are addressed.

Core Features & Use Cases

  • Systematic Debugging: Follows a four-phase process (Investigate, Analyze, Hypothesize, Implement) to ensure thorough root cause analysis.
  • Root Cause Tracing: Helps trace errors backward through call stacks to pinpoint the origin of issues.
  • Defense-in-Depth: Guides the implementation of multi-layered validation to prevent bugs from recurring.
  • Verification Protocols: Mandates evidence-based confirmation before declaring a fix complete.
  • Use Case: When a critical bug is reported in production, use this Skill to guide the investigation, ensuring the team doesn't just patch the symptom but fixes the underlying problem, preventing future occurrences.

Quick Start

Use the debugging skill to investigate and fix the reported test failure by following the four-phase process.

Frequently Asked Questions about 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 patching symptoms?▼

Backward call stack tracing works by systematically tracing errors backward through the execution path to pinpoint the exact origin of an issue. This investigation occurs during the first phase of the debugging framework before any fixes are implemented.

How do I stop recurring bugs from reappearing after a fix is deployed?▼

To stop recurring bugs, implement multi-layered validation and defense-in-depth during the implementation phase. The debugging framework mandates strict evidence-based verification protocols to confirm the fix before declaring the issue resolved.

What steps should I follow for systematic troubleshooting of a critical production bug?▼

Systematic troubleshooting follows a four-phase process: investigate the root cause, analyze patterns, form and test hypotheses, and implement the fix. This structured approach ensures the team addresses the underlying problem rather than applying superficial patches.

When should I use a structured debugging framework instead of quickly patching an error?▼

A structured debugging framework should be used whenever a critical bug is reported or when superficial solutions risk future occurrences. It ensures thorough root cause investigation and prevents the cycle of recurring issues caused by patching symptoms.

Related Skills

Explore More Software Engineering Skills→
jk278jk278

debugging-assistant

Diagnose software bugs from stack traces and error logs.

Community
Advanced
DYAI2025DYAI2025

regression-test-generator

Generate Arrange-Act-Assert regression tests for Jest, Vitest, pytest, or Playwright.

Community
Intermediate
luan-thnhluan-thnh

Debugging

Guide root-cause investigation of software bugs with four-phase debugging protocols.

Community
Advanced
tclemtclem
11

investigate-alert

Diagnose production alerts by aggregating logs, metrics, traces, and source code.

Community
Advanced