skills.rest
JonOlsenCa
JonOlsenCaCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

investigate

Identify and isolate software bug root causes through structured investigation phases.

Updated Aug 23, 2026
Search Tags:#workflow#debugging#investigation#analysis#hypothesis#root-cause#reproduction
One-click install
npx skills add https://github.com/JonOlsenCa/gstack-main --skill investigate-jonolsenca
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: investigate
Source: https://github.com/JonOlsenCa/gstack-main/tree/main/investigate
Command: npx skills add https://github.com/JonOlsenCa/gstack-main --skill investigate-jonolsenca

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematic debugging with root cause investigation. The Iron Law: no fixes without root cause. This workflow helps you collect symptoms, read code, reproduce, form hypotheses, implement fixes, and verify outcomes.

Core Features & Use Cases

  • Structured 4-phase process: investigate, analyze, hypothesize, implement.
  • Reproducible debugging with evidence collection and hypothesis testing.
  • Integrates with AskUserQuestion, WebSearch, and standard shell tools for deterministic debugging.

Quick Start

Describe the bug in one sentence and start 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 software bug instead of just patching symptoms?▼

Root-cause debugging enforces a strict policy of no fixes without isolating the underlying issue. It uses a structured workflow to collect symptoms, read code, reproduce the error, and test hypotheses before implementing any changes.

What is the best way to systematically debug unexpected behavior across my codebase?▼

Systematic debugging follows a multi-phase process: investigate symptoms, analyze code, hypothesize causes, and implement fixes. This structured approach ensures deterministic reproduction and verified outcomes rather than relying on guesswork.

How do I reproduce an error deterministically to test my debugging hypotheses?▼

Deterministic reproduction involves collecting evidence and analyzing Git history using shell tools like grep and log. Once the error is consistently reproduced, you can form and test hypotheses against the isolated behavior.

Do I need to provide specific inputs for interactive root-cause investigation workflows?▼

Yes, the workflow requires interactive prompts to guide the investigation phases. You start by describing the bug in one sentence, and the tool will query you for additional context while analyzing code and testing hypotheses.

When should I avoid applying a quick fix during codebase analysis and debugging?▼

You should avoid quick fixes when a deterministic root cause has not been identified and verified. The workflow mandates collecting symptoms and testing hypotheses to ensure the fix resolves the actual error, not just the visible behavior.

Related Skills

Explore More Software Engineering Skills→
bs-koobs-koo

context

Create and update domain contexts from codebase scans, documents, and git history.

Community
Advanced
nobelknobelk

bugfix

Fix bugs in C#, Python, or Flutter/Dart files using a test-driven workflow.

Community
Advanced
enowdevenowdev
13

social-content

Generate platform-specific social media posts, threads, and video scripts.

Community
Intermediate
UlanxxUlanxx

canary

Monitor live URLs for console errors, performance regressions, and page failures.

Community
Advanced