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.