investigate

Guide structured root-cause investigation workflows for bugs and stack traces.

Updated Dec 22, 2019
One-click install
npx skills add https://github.com/sajalsuhane/sajalsuhane.github.io --skill investigate-sajalsuhane
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: investigate
Source: https://github.com/sajalsuhane/sajalsuhane.github.io/tree/main/.claude/skills/gstack/investigate
Command: npx skills add https://github.com/sajalsuhane/sajalsuhane.github.io --skill investigate-sajalsuhane

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic debugging with root-cause investigation, enforcing a disciplined four-phase process (investigate, analyze, hypothesize, implement) so fixes address the real cause instead of masking symptoms.

Core Features & Use Cases

  • Structured root-cause analysis that leads from symptoms to evidence and a testable hypothesis.
  • Multi-phase workflow (investigate, analyze, hypothesize, implement) guiding reproducibility and learning.
  • Proactive artifact collection (logs, traces, greps) and decision logs to support safe, verifiable fixes.

Quick Start

Describe the symptoms or error and I will begin the root-cause investigation workflow.

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 a bug instead of just masking the symptoms?

Root-cause debugging requires a structured workflow that enforces evidence gathering and hypothesis testing. By applying a four-phase cycle of investigation, analysis, hypothesizing, and implementation, you ensure software engineering fixes address the actual underlying cause rather than masking symptoms.

What is the best way to debug flaky behavior and intermittent errors across a codebase?

Debugging flaky behavior requires proactively collecting artifacts like logs, traces, and grep results across the codebase. A structured investigation workflow uses this evidence to test hypotheses and reproduce intermittent errors, ensuring you isolate the true root cause of the issue.

How do I systematically analyze stack traces to fix software bugs?

Systematically analyzing stack traces involves a multi-phase workflow progressing from investigation to analysis, hypothesis, and implementation. This disciplined process enforces evidence collection and controlled changes, ensuring your software bug fixes are safe, verifiable, and address the root cause.

Does root-cause debugging require specific dependencies or tools to work?

Root-cause debugging requires no specific external dependencies or component tools to function. The investigation workflow operates independently, guiding evidence collection, hypothesis testing, and controlled implementation directly within your existing software engineering environment and codebase.

Why should I use a structured workflow for software debugging instead of directly patching errors?

A structured debugging workflow is necessary because directly patching errors often masks symptoms without resolving the root cause. A disciplined four-phase process enforces evidence gathering and decision logging, ensuring safe, verifiable fixes that prevent recurring flaky behavior and software bugs.