forensic

Enforce the scientific method for structured debugging and troubleshooting.

Updated Feb 23, 2026
One-click install
npx skills add https://github.com/mcevoyinit/agentic-skills --skill forensic
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: forensic
Source: https://github.com/mcevoyinit/agentic-skills/tree/main/skills/coding-modes/forensic
Command: npx skills add https://github.com/mcevoyinit/agentic-skills --skill forensic

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Debugging mode that enforces the scientific method: reproduce, hypothesize, instrument, and fix. It prevents guessing and unsafe changes by ensuring understanding before acting.

Core Features & Use Cases

  • Provides a structured, auditable debugging workflow (observe, hypothesize, instrument, verify, fix)
  • Includes a phased protocol (Phase 0 to Phase 4) and narrated investigation logs to guide engineers
  • Ideal for complex bugs, intermittent failures, and regression issues across software systems

Quick Start

Activate forensic mode and follow the nine rules to observe, hypothesize, instrument, and fix the bug.

Frequently Asked Questions about forensic

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

FAQPage Schema
How do I debug an intermittent failure using the scientific method instead of guessing?

Debugging intermittent failures with the scientific method requires structured observation, hypothesis generation, instrumentation, and verification. This approach enforces a phased protocol to reproduce, hypothesize, instrument, and fix bugs while maintaining an auditable log.

What is the best way to find the root cause of a regression issue across services?

Finding the root cause of a regression issue requires a structured debugging workflow that moves through observation, hypothesis, instrumentation, and verification phases. This prevents unsafe changes by ensuring complete understanding before applying any fix to the codebase.

How do I create an auditable log for troubleshooting complex software bugs?

Creating an auditable log for troubleshooting involves narrating the investigation through phased protocols that document observations, hypotheses, and instrumentation results. This structured workflow prevents guessing and provides a verifiable trail for complex bugs.

Can I use a structured debugging protocol for API failures and intermittent codebase issues?

A structured debugging protocol applies to API failures, codebases, and intermittent issues across software systems. It enforces the scientific method through observation, hypothesis generation, instrumentation, and verification with safety rails to prevent unsafe changes.

Why should I generate a hypothesis before instrumenting code during root-cause analysis?

Generating a hypothesis before instrumenting code during root-cause analysis prevents unsafe changes and random guessing. The scientific method requires forming a testable hypothesis first, then adding instrumentation to verify it, ensuring understanding before acting.

What are the limitations of using a hypothesis-driven debugging workflow for software systems?

The limitation of a hypothesis-driven debugging workflow is its strict requirement for structured observation and verification before acting. This enforced safety protocol may slow down rapid patching, as it prevents applying changes until the root cause is fully understood.