investigate

Guide root cause investigation of software bugs through a four-phase workflow.

Updated Mar 25, 2026
One-click install
npx skills add https://github.com/Chang-Shih-Yung/auto-learning --skill investigate-chang-shih-yung
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: investigate
Source: https://github.com/Chang-Shih-Yung/auto-learning/tree/main/.claude/skills/gstack/investigate
Command: npx skills add https://github.com/Chang-Shih-Yung/auto-learning --skill investigate-chang-shih-yung

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps teams systematically debug by focusing on root cause investigation before fixes, reducing regressive bugs and wasted effort.

Core Features & Use Cases

  • Structured four-phase framework: investigate, analyze, hypothesize, implement.
  • Evidence-driven debugging with reproducible steps, logs, and cross-checks.
  • Use cases: when facing errors, stack traces, or intermittent failures that need root cause analysis.

Quick Start

Start by summarizing the observed symptoms and reproduction steps, then proceed to root-cause investigation.

Frequently Asked Questions about investigate

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

FAQPage Schema
How do I find the root cause of an intermittent software failure?

To find the root cause of an intermittent software failure, apply a structured four-phase workflow: investigate, analyze, hypothesize, and implement. This enforces evidence-driven data collection and deterministic reproduction steps before fixing.

What is the best way to debug stack traces using evidence-based reasoning?

The best way to debug stack traces with evidence-based reasoning is to follow a structured investigation framework. It isolates the root cause by enforcing structured data collection, reproducible tests, and cross-checks to ensure fixes address the real issue.

How do I systematically triage errors before implementing a software fix?

Systematically triage errors by working through a four-phase debugging workflow: investigate, analyze, hypothesize, and implement. This approach focuses on root cause investigation and evidence collection before fixes, reducing regressive bugs and wasted effort.

Can I use this structured debugging workflow for intermittent failures and complex errors?

Yes, you can use this structured debugging workflow for intermittent failures, complex errors, and stack traces. It provides deterministic reproduction steps and documentation to ensure your fixes address the actual root cause effectively.

Why does fixing bugs without root cause analysis lead to regressive issues?

Fixing bugs without root cause analysis leads to regressive issues because the underlying problem remains unaddressed. Structured investigation enforces evidence-based reasoning and reproducible tests, ensuring fixes target the real cause instead of superficial symptoms.

What steps should I take to reproduce an error for root-cause debugging?

To reproduce an error for root-cause debugging, start by summarizing the observed symptoms and reproduction steps. Then proceed through structured data collection and cross-checks to establish deterministic reproduction before hypothesizing fixes.