Root-Cause-Tracing

Trace backward through call stacks to locate a bug's original trigger.

149|10|Updated Oct 30, 2025
One-click install
npx skills add https://github.com/tilework-tech/nori-profiles --skill root-cause-tracing-tilework-tech
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Root-Cause-Tracing
Source: https://github.com/tilework-tech/nori-profiles/tree/main/src/installer/features/profiles/config/_mixins/_swe/skills/root-cause-tracing
Command: npx skills add https://github.com/tilework-tech/nori-profiles --skill root-cause-tracing-tilework-tech

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill systematically traces bugs backward through the call stack to identify the original trigger of invalid data or incorrect behavior, ensuring you fix the root cause rather than just symptoms.

Core Features & Use Cases

  • Backward Tracing: Guides you to trace errors from their manifestation point back to their origin in the code.
  • Instrumentation: Instructs on adding diagnostic logging and stack traces to gather evidence in complex systems.
  • Polluter Identification: Provides methods to find which specific test or code change introduces pollution or errors.
  • Use Case: When an error appears deep in a multi-component system, use this skill to systematically trace the data flow and call chain, pinpointing the exact line of code where the invalid state originated.

Quick Start

An error is occurring deep in the system. Help me trace its root cause.

Frequently Asked Questions about Root-Cause-Tracing

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

FAQPage Schema
How do I trace a bug back to its root cause through the call stack?

Root-cause tracing traces errors backward from where they manifest to their origin in code. Add instrumentation like diagnostic logging and stack-trace capture at key points, then follow the call chain backward to identify the exact line where invalid data or incorrect behavior originated, rather than treating surface symptoms.

When should I use root-cause analysis instead of just fixing the error I see?

Use root-cause analysis when errors appear deep in multi-component systems with long call chains, unclear data origins, or pollution across tests. Fixing only the symptom leaves the underlying trigger active; tracing isolates the true source so you fix the problem permanently.

How do I find which test or code change is introducing pollution or errors?

Polluter identification uses instrumentation and multi-layer validation to systematically trace data flow and pinpoint which specific test or code change corrupts state. This reveals whether the problem stems from misrouted file paths, incorrect working directories, or misplaced resource initialization.

What's the difference between fixing a symptom and tracing to root cause?

Symptom fixes address the error where it's detected; root-cause fixes address the original trigger. Root-cause tracing requires instrumenting the system to capture stack traces and validate data at multiple layers, ensuring the invalid state does not recur across different execution paths.

Can I use root-cause tracing with unclear data origins or complex multi-component systems?

Yes, root-cause tracing is designed for exactly these scenarios. It applies when errors manifest with long call chains and pollution across tests, enabling isolation through instrumentation and stack-trace capture to locate the original point where data became invalid or behavior diverged.