root-cause-tracing

Root-cause tracing systematically backtracks through your call stack with instrumentation to identify the original trigger, not the surface error. This approach captures the full propagation chain, quantifies execution paths via structured metadata, and pinpoints where invalid data or incorrect behavior first originated, enabling targeted fixes rather than band-aids.

Yes. Root-cause tracing is designed for errors buried deep in long call stacks and contexts where reproduction is nontrivial, such as test or instrumentation environments. It adds instrumentation to capture symptom data, tracks propagation through the chain, and identifies the original trigger without requiring easy reproduction.

Tracing symptoms stops at the visible error; root-cause tracing goes backward through execution to find where the problem actually started. Root-cause tracing adds instrumentation to map the full propagation path, captures quantitative metadata, and identifies the original invalid condition or incorrect decision that led to the eventual failure.

Root-cause tracing supports backward call-chain instrumentation that captures execution context and data flow. The Skill generates structured trace metadata documenting each step in the propagation chain, enabling you to see where data became invalid or logic went wrong and trace it back to the original trigger.

Stack traces show where an error occurred, not why. Root-cause tracing is essential when the origin is unclear, errors propagate through multiple layers, or the actual bug is nowhere near where the crash happens. It's especially valuable in test and instrumentation contexts where manual reproduction is slow or impractical.

Yes. Root-cause tracing handles scenarios where the origin of invalid data is unclear by tracking propagation through the call chain with instrumentation. It captures when and where data became corrupted or state became invalid, then backtracks to identify the original source of the problem.