meow:investigate

Trace symptoms to root causes through investigate, analyze, hypothesize, and implement phases.

14|2|Updated Mar 25, 2026
One-click install
npx skills add https://github.com/ngocsangyem/MeowKit --skill meow-investigate
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: meow:investigate
Source: https://github.com/ngocsangyem/MeowKit/tree/main/.claude/skills/meow%3Ainvestigate
Command: npx skills add https://github.com/ngocsangyem/MeowKit --skill meow-investigate

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

Systematic debugging with root cause investigation. Four phases: investigate, analyze, hypothesize, implement. Iron Law: no fixes without root cause. Use when asked to "debug this", "fix this bug", "why is this broken", "investigate this error", or "root cause analysis". Proactively suggest when the user reports errors, unexpected behavior, or is troubleshooting why something stopped working.

Core Features & Use Cases

  • Phase-driven workflow guiding users through investigate → analyze → hypothesize → implement.
  • Iron Law enforcement to prevent fixes without verified root cause.
  • On-demand references and progressive disclosure to keep context lean until needed.
  • Hooks and safe-scope boundaries to prevent unintended edits during investigation.
  • Use cases include debugging bugs, reliability investigations, and incident triage.

Quick Start

Initiate the root-cause investigation by asking me to debug a reported issue and guide you through the four phases.

Frequently Asked Questions about meow:investigate

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

FAQPage Schema
What is root-cause debugging and how does it help fix unexpected behavior?

Root-cause debugging is a systematic investigation process that traces symptoms back to their origin across codebases and services. It guides analysts through investigate, analyze, hypothesize, and implement phases to ensure issues are permanently resolved rather than patched.

How do I debug a reported error using a systematic investigation workflow?

To debug a reported error, follow a four-phase root-cause investigation workflow: investigate the symptoms, analyze the codebase, hypothesize the origin, and implement a minimal diff fix. This process requires strict hypothesis testing before any code changes are applied.

Why should I trace root causes before applying fixes during incident triage?

Tracing root causes before applying fixes prevents scope creep and unintended edits. An enforced Iron Law requires verified root cause identification through hypothesis testing, ensuring that fixes target the actual origin rather than merely masking symptoms during incident triage.

Can I use a phase-driven debugging workflow for reliability investigations across integrations?

Yes, phase-driven debugging workflows apply to reliability investigations across codebases, services, and integrations. The process uses safe-scope boundaries and a freeze gate to prevent unintended edits, keeping context lean with on-demand references during the investigation.

What's the best way to prevent scope creep during codebase investigation?

The best way to prevent scope creep during codebase investigation is enforcing a freeze gate with safe-scope boundaries. This restricts edits during the analyze and hypothesize phases, requiring verified root causes and minimal diffs before implementation begins.

When should I not use a root-cause analysis workflow for troubleshooting?

You should not use a root-cause analysis workflow when a quick surface-level patch is sufficient and tracing symptoms to their origin is unnecessary. The strict guardrails and hypothesis testing phases add overhead that may be excessive for trivial fixes.