systematic-debugging
A structured methodology for debugging technical issues by prioritizing root cause identification over symptom-based patching. It mandates a four-phase process: root cause investigation, pattern analysis, hypothesis testing, and implementation, while providing specific protocols for handling persistent failures and architectural concerns.
Is systematic-debugging safe to install?
Review the source first: our audit of systematic-debugging's source files found 8 shell commands, 0 external URLs, no file writes (high risk). Every command and URL listed appears verbatim in the skill's source. The skill includes shell commands for diagnostic instrumentation that interact with system security and environment variables.
How we audit skills: our security review methodology.
Who is this skill for?
Software engineers and AI agents tasked with resolving bugs, test failures, or unexpected system behaviors.
What can you do with it?
- Resolving production bugs
- Fixing failing tests
- Addressing performance problems
- Troubleshooting build failures
- Debugging integration issues
How good is this skill?
Quality score: 5/10. The skill provides a clear, actionable, and rigorous framework for debugging. It includes specific diagnostic commands and clear exit criteria for when to stop and re-evaluate.
What does the skill file contain?
# Systematic Debugging ## Overview Random fixes waste time and create new bugs. Quick patches mask underlying issues. **Core principle:** ALWAYS find root cause before attempting fixes. Symptom fixes are failure. **Violating the letter of this process is violating the spirit of debugging.** ## The Iron Law ``` NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST ``` If you haven't completed Phase 1, you cannot propose fixes. ## When to Use Use for ANY technical issue: - Test failures - Bugs in production - Unexpected behavior - Performance problems - Build failures - Integration issues **...
Frequently asked questions
What should I do if I cannot find a root cause?
Document the investigation, implement appropriate handling like retries or timeouts, and add monitoring or logging for future analysis.
When is it appropriate to stop fixing and question the architecture?
Stop and question the architecture if three or more fix attempts have failed to resolve the issue.
Can I skip the root cause investigation if the bug seems simple?
No. Simple bugs have root causes, and systematic debugging remains the fastest approach even for simple issues.
Related skills
convex-performance-audit
79.2KDevelopers working with Convex applications who need to optimize slow features, resolve high-resource usage, or address transaction contention
The convex-performance-audit skill provides a structured workflow for diagnosing and resolving performance issues in Convex applications, including read amplification, OCC conflicts, subscription costs, and function limits.
momentic-result-classification
29.5KDevelopers and QA engineers using the Momentic testing framework to triage and debug automated test failures
The momentic-result-classification skill provides tools to analyze, categorize, and explain test failures within the Momentic end-to-end testing framework. It enables users to investigate test run metadata, step-level results, and historical run data to identify root causes of failures.
swiftui-performance-audit
7.7KiOS developers and engineers troubleshooting SwiftUI performance issues such as janky scrolling, high CPU usage, memory growth, and layout thrash
The swiftui-performance-audit skill provides a structured workflow for diagnosing and remediating SwiftUI performance issues. It guides users through code-first reviews using predefined smell catalogs and assists in collecting runtime evidence via Instruments profiling.
sentry-fix-issues
5.1KDevelopers and AI agents tasked with debugging production issues, triaging Sentry backlogs, and resolving software exceptions
The sentry-fix-issues skill provides a structured workflow for identifying, analyzing, and resolving production errors by integrating with Sentry via the MCP protocol. It guides the agent through issue discovery, root cause hypothesis, code investigation, and verification.