investigate

Identify failure contracts, map data flows, and produce evidence-backed root-cause reports.

15|5|Updated May 17, 2026
One-click install
npx skills add https://github.com/cropsgg/skills --skill investigate-cropsgg
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: investigate
Source: https://github.com/cropsgg/skills/tree/main/skills/engineering/investigate
Command: npx skills add https://github.com/cropsgg/skills --skill investigate-cropsgg

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic root-cause debugging with evidence before any fix is applied, preventing hasty patches and guiding teams toward verifiable resolutions.

Core Features & Use Cases

  • Capture the failure contract: record expected vs actual behavior, environment details, and reproducible steps.
  • Reproduce minimally: isolate a small, determinable sequence that demonstrates the failure.
  • Map data flow and dependencies: trace inputs, external systems, and async boundaries to reveal the failure surface.
  • Form ranked hypotheses: generate testable, falsifiable causes with actionable next steps.
  • Instrument, test, and verify: add temporary instrumentation, run controlled experiments, and compare failures vs passes.
  • Produce a formal root-cause report: document findings with evidence and cite exact sources.

Quick Start

Capture a failure scenario, reproduce it with minimal steps, map data flow, and begin formulating ranked hypotheses before patching.

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 why do I need evidence before fixing a bug?

Root-cause debugging isolates the exact origin of a failure using evidence rather than assumptions. It prevents hasty patches by requiring documented failure contracts, reproducible steps, and tested hypotheses before any code changes are applied.

How do I systematically reproduce a bug to isolate the root cause?

To systematically reproduce a bug, capture the expected versus actual behavior and environment details, then isolate a minimal, deterministic sequence of steps that reliably demonstrates the failure before mapping data flows and forming hypotheses.

What's the best way to debug an incident without immediately patching the code?

The best way to debug an incident without patching immediately is to form ranked, testable hypotheses, add temporary instrumentation to compare failing versus passing runs, and produce an evidence-backed root-cause report before applying minimal changes.

How do I trace data flows and dependencies to find the failure surface?

Tracing data flows and dependencies involves mapping inputs, external systems, and async boundaries to reveal the failure surface. This comparison between failing and passing runs helps isolate where the data divergence occurs.

Can I use this approach to verify a fix with minimal changes before closure?

Yes, this approach verifies fixes by requiring an evidence-backed root-cause report that cites exact sources. It ensures you apply minimal changes and validate the resolution through controlled experiments before final closure.

When should I not use a systematic root-cause investigation for debugging?

You should avoid systematic root-cause investigation when dealing with trivial, immediately obvious errors or when rapid, emergency mitigation is required before a formal, evidence-backed incident response process can be executed.