team-shinchan:systematic-debugging

Name: team-shinchan:systematic-debugging
Availability: InStock
Author: Seokan

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

8|2|Updated Feb 3, 2026

Search Tags:#testing #debugging #traceability #phases #hypothesis #guardrails #root-cause

Ready to run

npx skills add https://github.com/seokan-jeong/team-shinchan --skill team-shinchan-systematic-debugging

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: team-shinchan:systematic-debugging
Source: https://github.com/seokan-jeong/team-shinchan/tree/main/skills/systematic-debugging
Command: npx skills add https://github.com/seokan-jeong/team-shinchan --skill team-shinchan-systematic-debugging

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill provides a structured, four-phase approach to root-cause debugging, helping teams investigate failures without guessing and to systematically identify and verify root causes before implementing fixes.

Core Features & Use Cases

Four-phase root-cause process (Phase 1: Investigation, Phase 2: Pattern Analysis, Phase 3: Hypothesis and Testing, Phase 4: Implementation) to guide debugging efforts.
Anti-pattern awareness and escalation rules to prevent shotgun debugging and ensure disciplined methodology.
Supporting techniques like 5 Whys, defense-in-depth, and condition-based waiting to improve debugging reliability.

Quick Start

Use this skill to structure a debugging session following the four phases to reach a verified fix.

Frequently Asked Questions about team-shinchan:systematic-debugging

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

FAQPage Schema

What is a systematic approach to root-cause debugging for software failures?▼

Systematic root-cause debugging uses a four-phase process—investigation, pattern analysis, hypothesis testing, and implementation—to identify why failures occur without guessing.

How do I debug failing builds without resorting to shotgun debugging?▼

To debug failing builds without guessing, follow a disciplined methodology using explicit hypotheses, traceable evidence, and anti-pattern awareness to systematically verify the root cause before fixing.

What are the steps to investigate unexpected runtime behavior across code and configurations?▼

Investigate unexpected runtime behavior by progressing through four phases: gather evidence, analyze patterns, test explicit hypotheses, and implement a verified fix to ensure traceability.

When should I use 5 Whys and hypothesis testing for software debugging?▼

Use 5 Whys and hypothesis testing during the pattern analysis and hypothesis phases to improve debugging reliability and systematically identify the root cause of failing tests or runtime errors.

Can this systematic debugging methodology be applied to data flow and configuration issues?▼

Yes, this systematic debugging methodology applies to unexpected behavior across code, configurations, and data flows, requiring disciplined reasoning and traceable evidence to validate fixes.

How do I prevent anti-patterns and ensure disciplined reasoning during a debugging session?▼

Prevent anti-patterns like shotgun debugging by applying escalation rules and condition-based waiting, ensuring disciplined reasoning and traceable evidence validate the root cause before implementation.