investigate

Identify root causes of bugs and regressions through structured evidence gathering and verification.

1|Updated Mar 28, 2026
One-click install
npx skills add https://github.com/shhubbh/flowstate --skill investigate-shhubbh
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: investigate
Source: https://github.com/shhubbh/flowstate/tree/main/.claude/skills/gstack/investigate
Command: npx skills add https://github.com/shhubbh/flowstate --skill investigate-shhubbh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Troubleshoot complex bugs by guiding you through a structured root-cause investigation workflow that reduces guesswork and speeds up fixes.

Core Features & Use Cases

  • Systematic phases: collect symptoms, read code, check changes, reproduce, and report root cause.
  • Use it for debugging production issues, flaky tests, or regressions where the real cause is hidden deep in the stack.
  • Real-world flow: from symptom capture to a testable hypothesis and verified fix.

Quick Start

Describe the bug, collect symptoms, reproduce the issue, and identify the root cause.

Frequently Asked Questions about investigate

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

FAQPage Schema
What is root-cause debugging and how does it help with production incidents?

Root-cause debugging identifies the underlying cause of bugs and regressions by applying structured evidence gathering, code comprehension, and reproducible steps. It reduces guesswork and speeds up fixes for production issues where the real cause is hidden deep in the stack.

How do I debug flaky tests and regressions across a codebase?

To debug flaky tests and regressions, follow a systematic workflow: collect symptoms, read the code, check recent changes, reproduce the issue, and report the root cause. This structured approach forms a testable hypothesis to verify the fix.

What's the best way to find the root cause of a bug hidden deep in the stack?

The best way to find a root cause hidden in the stack is through a structured investigation workflow. You collect symptoms, read code, check changes, and reproduce the issue to build a testable root-cause hypothesis with a verification plan.

Can I use structured code analysis for incident response and regressions?

Yes, structured code analysis is effective for incident response and regressions. It guides you through systematic phases of symptom capture and code comprehension, leading to a testable hypothesis and verified fix for complex production issues.

Do I need to reproduce the issue before identifying the root cause of a bug?

Reproducing the issue is a required phase before identifying the root cause. The investigation workflow moves from symptom capture and code reading through reproduction to finally establish a testable root-cause hypothesis.

Why does guessing fail when debugging complex production issues?

Guessing fails debugging complex production issues because the real cause is often hidden deep in the stack. A structured root-cause investigation workflow replaces guesswork with evidence gathering and reproducible steps to form a verified hypothesis.