investigate

Identify root causes of software bugs through a structured four-phase debugging workflow.

1|Updated Mar 15, 2026

Search Tags:#debug #investigate #triage #root-cause #reproduction #log-analysis #code-reading

Ready to run

npx skills add https://github.com/westn/gstack-pi-port --skill investigate-westn

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: investigate
Source: https://github.com/westn/gstack-pi-port/tree/main/port/gstack/investigate
Command: npx skills add https://github.com/westn/gstack-pi-port --skill investigate-westn

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic debugging primed to uncover the root cause of software issues rather than treating symptoms.

Core Features & Use Cases

Four-phase workflow: investigate, analyze, hypothesize, implement to structure debugging and avoid guesswork.
Evidence-first approach: collect symptoms, read code paths, reproduce steps, and log findings to validate root cause.
Use Case: when user reports an error or crash and you need a deterministic path to identify the real problem before patching.

Quick Start

Describe the issue clearly and run /skill:investigate to begin the root-cause analysis.

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 software error instead of just treating the symptoms?▼

Root-cause debugging uses an evidence-first, phase-driven workflow to investigate, analyze, hypothesize, and implement fixes. It requires clear symptom data, code access, and permission to add logging to validate hypotheses before patching.

What is the best way to debug a stack trace when the root cause is not obvious?▼

Debugging a stack trace systematically involves collecting symptoms, reading code paths, reproducing steps, and logging findings. This structured approach avoids guesswork by validating hypotheses against evidence to uncover the real problem.

How do I triage failing tests using a structured debugging workflow?▼

Triaging failing tests uses a four-phase workflow: investigate, analyze, hypothesize, and implement. You read code paths and add targeted logging to reproduce steps and confirm the root cause before applying a fix.

Can I use structured log analysis to reproduce steps for a software crash?▼

Yes, structured log analysis is an evidence-first approach to reproduce steps for a crash. By reading code paths and logging findings, you validate hypotheses to identify the deterministic root cause before patching.

Do I need permission to add tests when investigating a code error?▼

Yes, investigating a code error requires permission to add logging or tests to confirm hypotheses. You also need clear symptom data and access to the relevant code paths to successfully identify the root cause.

When should I avoid guesswork and switch to systematic code reading for triage?▼

You should switch to systematic code reading for triage when a user reports an error and the root cause is not obvious. A structured investigation prevents treating symptoms by validating hypotheses against collected evidence first.