root-cause-by-layer

Diagnose bugs through a five-layer ladder from symptom to conceptual origin.

2|Updated Apr 20, 2026
One-click install
npx skills add https://github.com/veegee82/loss-driven-development --skill root-cause-by-layer
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: root-cause-by-layer
Source: https://github.com/veegee82/loss-driven-development/tree/main/skills/root-cause-by-layer
Command: npx skills add https://github.com/veegee82/loss-driven-development --skill root-cause-by-layer

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Five-layer root-cause analysis helps engineers avoid symptom patches by forcing explicit causal reasoning across symptom, mechanism, contract, structural origin, and conceptual origin.

Core Features & Use Cases

  • Five-layer diagnostic ladder: sequentially examines symptom, mechanism, contract, structural origin, and conceptual origin to locate the true cause.
  • Guardrails for fixes: prevents quick-and-dirty patches by ensuring changes address the real root cause at the appropriate layer.
  • Use cases: red or flaky tests, unexpected exceptions, CI gate failures, or time-pressured debugging where surface edits would be insufficient.

Quick Start

Walk the five-layer ladder on the current bug report, document findings for layers 1–5, and name a targeted fix at the appropriate layer.

Frequently Asked Questions about root-cause-by-layer

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

FAQPage Schema
How do I find the root cause of a bug instead of just patching the symptom?▼

To find the root cause of a bug, apply a five-layer diagnostic ladder that examines the symptom, mechanism, contract, structural origin, and conceptual origin. This forces explicit causal reasoning to locate the true cause before you propose a fix.

What is the best way to debug flaky tests and CI gate failures under a tight deadline?▼

The best way to debug flaky tests under a tight deadline is walking the five-layer diagnostic ladder across code and integration boundaries. It ensures you document findings for each layer and name a targeted, layer-appropriate fix rather than applying a quick patch.

How does layered root-cause analysis work for software debugging?▼

Layered root-cause analysis works by sequentially examining the symptom, mechanism, contract, structural origin, and conceptual origin of a bug. This process prevents quick-and-dirty patches by ensuring changes address the real root cause at the appropriate diagnostic layer.

When do I need a five-layer diagnostic approach for triaging unexpected exceptions?▼

You need a five-layer diagnostic approach for triaging unexpected exceptions when surface edits or symptom patches are insufficient. It is specifically designed for red tests, flaky behavior, and deadline-driven debugging across code, integration, and design boundaries.

How do I document root-cause findings across code, integration, and design boundaries?▼

You document root-cause findings by recording details for each of the five diagnostic layers: Symptom, Mechanism, Contract, Structural origin, and Conceptual origin. This documentation captures the causal chain across boundaries and names a targeted fix.

Why does my bug fix keep recurring across different parts of the system?▼

Your bug fix keeps recurring because changes likely address only the symptom or mechanism instead of the structural or conceptual origin. Applying a five-layer diagnostic ladder enforces explicit causal reasoning to target the true root cause and prevent symptom patches.