systematic-debugging

Identify and resolve root causes of bugs and failing tests.

2|Updated Apr 20, 2026
One-click install
npx skills add https://github.com/FelixBitSoul/contentCrew-AI --skill systematic-debugging-felixbitsoul
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: systematic-debugging
Source: https://github.com/FelixBitSoul/contentCrew-AI/tree/main/.trae/skills/systematic-debugging
Command: npx skills add https://github.com/FelixBitSoul/contentCrew-AI --skill systematic-debugging-felixbitsoul

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

Identifies and resolves the root causes of bugs and failing tests before patches are made.

Core Features & Use Cases

  • Four-phase workflow (Phase 1: root-cause investigation, Phase 2: pattern analysis, Phase 3: hypothesis and validation, Phase 4: implementation)
  • Anti-patterns, enforcement of a non-skipping process, and explicit failure modes
  • Phase-by-phase checklists with defense-in-depth and testing guidance
  • Applicable to production incidents, flaky tests, and complex integrations

Quick Start

Follow Phase 1: root-cause investigation before proposing any fix.

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 before applying a patch?

Root-cause debugging enforces a structured investigation with explicit hypotheses and validation tests before patches are made. It uses a four-phase flow to identify and resolve the actual source of bugs rather than treating symptoms.

What's the best way to debug flaky tests in complex integrations?

Debugging flaky tests requires systematic pattern analysis and multi-layer checks to identify hidden root causes. A structured four-phase workflow guides you through investigation, pattern analysis, hypothesis validation, and final implementation.

How does a systematic four-phase debugging process work?

The systematic debugging process works through four phases: root-cause investigation, pattern analysis, hypothesis and validation, and implementation. It enforces structured investigation with phase-by-phase checklists and defense-in-depth to prevent symptom fixes.

Can I use systematic debugging for production incidents?

Systematic debugging is explicitly designed for production incidents, flaky tests, and complex integrations. It applies multi-layer checks and defense-in-depth guidance to resolve root causes across diverse software project environments.

Why do my bug fixes only treat symptoms instead of resolving the root cause?

Symptom fixes occur when skipping root-cause investigation before patching. Enforcing a non-skipping debugging process with explicit failure modes and anti-pattern checks ensures you validate hypotheses and address the underlying root cause.

What are the limitations of systematic debugging for failing tests?

Systematic debugging requires strict adherence to a non-skipping four-phase process, meaning it may slow down immediate hotfixes. It enforces structured investigation and validation tests, which demands more upfront analysis before implementation.