investigate

Name: investigate
Availability: InStock
Author: geoffreywoo

Guide systematic debugging by collecting symptoms and inspecting code to identify root causes.

1|Updated Feb 27, 2026

Search Tags:#debugging #engineering #investigate #root-cause #software #gstack

Ready to run

npx skills add https://github.com/geoffreywoo/clawfable --skill investigate-geoffreywoo

💬 Prompt for ChatGPT / Claude Chat▼

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic debugging with root-cause investigation to prevent fixes that only treat symptoms and wasted cycles.

Core Features & Use Cases

Phase-driven workflow: Collect symptoms, read code, and check recent changes to form a grounded hypothesis.
Pattern analysis: Identify likely root causes across modules and changes.
Hypothesis testing: Use minimal instrumentation and reproducible checks to verify hypotheses.
Implementation guidance: Provide steps to apply the root-cause fix and verify results with tests.

Quick Start

Describe the bug you want to debug, and I will guide you through symptoms, code review, and a root-cause plan.

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 when should I use it for software engineering?▼

Root-cause debugging is a systematic process of collecting symptoms, inspecting code paths, and checking recent changes to identify the actual origin of a bug. Use it to prevent fixes that only treat superficial symptoms and waste development cycles.

How do I debug a software error by forming testable hypotheses?▼

To debug a software error, start by collecting detailed symptoms and reproducible steps. Read the relevant code paths and inspect recent changes to form a grounded, testable hypothesis about the likely root cause before attempting any fix.

What's the best way to investigate a bug across different software modules and environments?▼

The best way to investigate bugs across modules is applying a phase-driven workflow: collect symptoms, read code to trace execution paths, and analyze recent changes to identify error patterns, turning scattered symptoms into a verified root cause.

How do I verify a root-cause fix before implementing it in my code?▼

Verify a root-cause fix by using minimal instrumentation and reproducible checks to test your hypothesis. After confirming the root cause, follow implementation guidance to apply the fix and verify results with tests.

Why does my software fix only treat the symptom instead of resolving the root cause?▼

Your software fix likely treats only symptoms because it lacks a systematic investigation of underlying code paths and recent changes. Without forming and testing a grounded hypothesis, you risk patching superficial errors while the true root cause persists.

Can I use systematic debugging for any error scenario or software environment?▼

Yes, systematic debugging applies across software modules, environments, and error scenarios. It requires structured evidence and reproducible steps to turn diverse symptoms into testable hypotheses, ensuring accurate root-cause identification.