Debugging

Diagnose software bugs through root-cause analysis before applying fixes.

Updated Dec 16, 2025
One-click install
npx skills add https://github.com/nguyenvanlinh1902/trackingSolar --skill debugging-nguyenvanlinh1902
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Debugging
Source: https://github.com/nguyenvanlinh1902/trackingSolar/tree/main/.opencode/skill/debugging
Command: npx skills add https://github.com/nguyenvanlinh1902/trackingSolar --skill debugging-nguyenvanlinh1902

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Debug systematically with root cause analysis before fixes. Use for bugs, test failures, unexpected behavior, performance issues, call stack tracing, and multi-layer validation.

Core Features & Use Cases

  • Four-phase debugging (Phase 1: Root Cause Investigation; Phase 2: Pattern Analysis; Phase 3: Hypothesis and Testing; Phase 4: Implementation)
  • Root Cause Tracing to identify origin of data and errors
  • Defense-in-Depth validation across multiple layers
  • Verification before completion to ensure evidence supports success

Quick Start

Identify the failing component by reviewing the error message, reproduce the issue reliably, and trace data flow to the root cause before proposing a fix.

Frequently Asked Questions about Debugging

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

FAQPage Schema
How do I systematically debug unexpected behavior and test failures?

Systematic debugging requires root-cause analysis before applying fixes. You diagnose bugs by reproducing the issue reliably, tracing data flow to the origin of errors, and validating hypotheses across multiple layers before implementing the actual code fix.

What is root-cause tracing for software bugs and performance issues?

Root-cause tracing is the process of identifying the exact origin of data and errors within a system. It involves investigating the call stack and analyzing patterns to ensure the underlying issue is fixed, rather than just addressing the surface symptoms.

How do I fix build errors without introducing new bugs?

Fixing build errors safely requires defense-in-depth validation across multiple layers and formal verification before completion. This ensures that the applied fix is supported by evidence and prevents regression by validating the solution thoroughly.

What is the best way to investigate a complex multi-layer validation failure?

The best way to investigate multi-layer validation failures is applying a four-phase debugging process: root cause investigation, pattern analysis, hypothesis testing, and implementation, ensuring formal verification confirms the resolution.

Can I use this approach for performance issues and call stack tracing?

Yes, this debugging approach applies directly to performance issues and call stack tracing. It systematically diagnoses unexpected behavior by tracing the origin of data bottlenecks and errors before applying any fixes to the codebase.