Root Cause Tracing

---
name: root-cause-tracing
description: Trace bugs backward to their origin, not just symptoms
version: 1.0.0
author: Ariff
when_to_use: When fixing bugs - trace to source before patching
---

# Root Cause Tracing

## Core Principle

```
TRACE BACKWARD TO THE BUG'S ORIGIN
Don't patch symptoms - fix the disease
```

## The Backward Trace Method

```
SYMPTOM
   ↓ Where does this value come from?
IMMEDIATE CAUSE
   ↓ What set that to wrong value?
DEEPER CAUSE
   ↓ Why did that happen?
ROOT CAUSE ← Fix HERE
```

## Practical Steps

### 1. Start at Symptom
```
Q: What exactly went wrong?
→ Document the exact symptom
→ Note file, line, error message
```

### 2. First Backward Step
```
Q: Where does this value/state come from?
→ Find the direct source
→ Check: is THIS the bug or just a carrier?
```

### 3. Keep Tracing
```
Q: What set THAT to the wrong value?
→ Follow the data flow backward
→ Each step: is this the origin or just passing it along?
```

### 4. Identify Root
```
SIGNS YOU'VE FOUND ROOT:
- Logic error in requirements interpretation
- Initial state incorrectly set
- Wrong assumption in algorithm
- Missing validation at entry point
- Broken invariant at creation
```

## Stop Conditions

**You've found root cause when:**
- There's no earlier source to trace
- The error was introduced HERE (not inherited)
- Fixing HERE prevents the bug entirely
- The "why" answer is: "wrong logic/design"

**You're still at symptoms if:**
- The wrong value came from somewhere else
- Another function passed bad data
- It's a consequence, not origin
- Fixing here = adding a workaround

## Common Patterns

| Bug Pattern | Root Usually At |
|-------------|-----------------|
| Wrong value displayed | Data calculation, not display code |
| Null pointer | Where object should've been created |
| Off-by-one | Loop bounds definition, not body |
| Race condition | Shared state design, not specific access |
| Invalid state | State transition logic, not current handler |

## Anti-Patterns (Don't Do This)

❌ **Symptom Patching**
```
// Bad: Fix where error happens
if (value === undefined) value = defaultValue
// Good: Find why value is undefined
```

❌ **Guard Stacking**
```
// Bad: Add guards everywhere
if (x) if (y) if (z) doThing()
// Good: Ensure x, y, z correct at source
```

❌ **Quick Fix Pressure**
```
"Just make it work" → Technical debt
Better: "5 more minutes tracing saves 5 hours debugging later"
```

## Verification

After identifying root cause:

1. **Explain the chain** - Symptom ← caused by ← caused by ← ROOT
2. **Confirm origin** - "This is where wrong value first appears"
3. **Fix at root** - Change the origin, not the symptoms
4. **Verify fix** - Original symptom gone + no new bugs

## Integration with Checkers

Use with:
- `assumption-checker` → Was root cause an assumption?
- `dependency-validator` → Was root cause a broken dependency?
- `pre-action-verifier` → Verify root cause fix before applying