skills.rest
cheng80
cheng80COMMUNITY
Explore all skills by this author →
GitHub

investigate

Identify and fix root causes through a structured four-phase debugging workflow.

1|Updated Apr 12, 2026
Search Tags:#debugging#investigate#analyze#root-cause#implement#bug-fix#hypothesize
One-click install
npx skills add https://github.com/cheng80/rummipoker --skill investigate-cheng80
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: investigate
Source: https://github.com/cheng80/rummipoker/tree/main/.agents/skills/gstack-investigate
Command: npx skills add https://github.com/cheng80/rummipoker --skill investigate-cheng80

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic debugging with root cause investigation. Four phases: investigate, analyze, hypothesize, implement. Iron Law: no fixes without root cause.

Core Features & Use Cases

  • Structured, phased approach that guides users from symptom to root cause.
  • Helps prevent regressions by addressing the underlying cause, not just the symptom.
  • Use cases include debugging errors, stack traces, performance bottlenecks, and flaky tests.

Quick Start

Describe the issue, collect relevant logs, reproduce the problem, and identify the root cause before proposing a fix.

Frequently Asked Questions about investigate

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

FAQPage Schema
What is the best way to debug a root cause across multi-file and multi-service systems?▼

Root-cause debugging across multi-service systems requires a structured four-phase workflow: investigate, analyze, hypothesize, and implement. This prevents premature fixes by ensuring no code changes are applied until the underlying cause is confirmed.

How do I fix a flaky test or intermittent failure without causing regressions?▼

Fix intermittent failures by reproducing the problem, collecting relevant logs, and identifying the root cause through structured analysis. This methodology enforces the rule of no fixes without root cause, preventing regressions caused by symptom patching.

Why should I analyze a stack trace before implementing a bug-fix?▼

Analyzing a stack trace before implementing a bug-fix prevents premature patches. The structured workflow requires hypothesizing the root cause from the stack trace first, ensuring the implemented fix addresses the underlying issue rather than just the symptom.

Can I use this structured debugging workflow for performance bottlenecks and errors across different code paths?▼

Yes, this debugging workflow applies to performance bottlenecks, errors, and regressions across different code paths. It guides users from symptom investigation through analysis and hypothesis to implementation, safely handling complex multi-service scenarios.

What do I need to start investigating a regression in my codebase?▼

To start investigating a regression, describe the issue, collect relevant logs, and reproduce the problem. These inputs drive the initial investigation phase before moving to analysis, hypothesis, and implementation.

Related Skills

Explore More Software Engineering Skills→
hw-native-syshw-native-sys
11

create-issue

Reproduce reported problems, collect dependency versions, and create GitHub issues.

Official
Advanced
dmae97dmae97
130

omk-flow-bugfix

Guide bug resolution from reproduction evidence to root-cause analysis and minimal code changes.

Community
Intermediate
paopp2paopp2

Root Cause Tracing

Trace bugs backward through the call stack to identify the original trigger.

Community
Intermediate
YaugourtYaugourt
2

investigate

Identify root causes of bugs by analyzing logs and code paths.

Community
Advanced