Investigation Patterns

Identify and organize evidence-based code behavior investigations to determine root causes.

2|1|Updated Feb 2, 2024
One-click install
npx skills add https://github.com/mtaku3/nix-config --skill investigation-patterns
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Investigation Patterns
Source: https://github.com/mtaku3/nix-config/tree/main/modules/home/app/dev/claude-code/skills/investigation-patterns
Command: npx skills add https://github.com/mtaku3/nix-config --skill investigation-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Provide systematic, evidence-based code investigation and debugging methodologies.

Core Features & Use Cases

  • Pattern-driven framework to classify questions, collect evidence, and guide debugging across codebases.
  • Tools and patterns include scope_classification, source_identification, evidence_collection, synthesis, reproduce, isolate, investigate, hypothesize, and fix to produce a clear, evidence-backed report.
  • Use Case: When debugging a failing module, apply the patterns to gather traces, review history, and deliver a root-cause report with confidence metrics.

Quick Start

Apply the investigation-patterns skill to a codebase to systematically identify the root cause and produce a structured evidence-based report.

Frequently Asked Questions about Investigation Patterns

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

FAQPage Schema
How do I systematically debug code to find the root cause of a failure?

To debug code systematically, apply investigation patterns that guide you through scope classification, evidence collection, and hypothesis testing. This structured debugging approach ensures you gather traces and review history to produce a reproducible, evidence-backed root-cause report.

What is an evidence-based code investigation and when do I need it?

Evidence-based code investigation is a pattern-driven framework that identifies and organizes behavioral evidence to determine root causes. You need this systematic debugging methodology when a failing module requires structured traces, confidence metrics, and file:line references rather than guesswork.

How do I collect and synthesize evidence when investigating a bug across multiple modules?

When investigating a bug across modules, use predefined patterns for source identification and evidence collection. This methodology guides you to gather traces, synthesize findings, reproduce the issue, and isolate variables, ultimately delivering a structured report with confidence and coverage ratings.

Can I apply systematic debugging patterns to investigate issues across different architectures and libraries?

Yes, you can apply these investigation patterns to debug across architectures, modules, and libraries. The framework provides tools for scope classification and evidence synthesis that adapt to different codebases, grounding all findings with file:line references and documented evidence gaps.

What's the best way to document code investigation findings and rate confidence in a root cause?

The best way to document code investigation findings is to use a structured reporting pattern that rates confidence and coverage. This approach grounds your root cause determination with file:line references, documents evidence gaps, and produces a clear, reproducible investigation report.

Why does my code investigation fail to isolate the actual root cause of a bug?

Code investigation fails to isolate the root cause when it lacks systematic evidence collection and hypothesis testing. Without applying structured investigation patterns to reproduce and isolate the issue, findings remain unverified, leading to incomplete synthesis and low-confidence debugging reports.