trace
Trace systematically investigates why something happened by generating competing hypotheses and evaluating evidence for and against each one. It's built for ambiguous causal questions—runtime bugs, performance regressions, and architecture issues—where you need to explain the most likely explanation. The skill structures your investigation through observation, hypothesis generation, evidence gathering, and discriminating probes.
Trace helps you identify root causes of runtime bugs by testing competing hypotheses against evidence.
AI-generated summary based on this skill's SKILL.md
Install
zereight/gitlab-mcp/trace · repository language: TypeScript
git clone https://github.com/zereight/gitlab-mcp
cp -r gitlab-mcp/.github/skills/trace ~/.claude/skills/tracenpx skillfed install zereight/gitlab-mcp/traceFrequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
What is Trace and what does it help me debug?
Trace is a systematic investigation skill that helps you root cause runtime bugs, performance regressions, and architecture anomalies. It generates competing hypotheses about why something happened, then evaluates evidence for and against each one to identify the most likely explanation. Trace structures your investigation through observation, hypothesis generation, evidence gathering, and discriminating probes—making it ideal for ambiguous causal questions where multiple explanations seem plausible.
How do I trace this bug for me using competing hypotheses?
Trace works by first capturing your observations about the bug—what failed, when, and under what conditions. It then generates multiple competing hypotheses that could explain the failure. For each hypothesis, Trace helps you identify what evidence would support or refute it, then guides you through targeted probes to gather that evidence. By systematically eliminating unlikely explanations, you converge on the root cause with confidence.
Can Trace help me investigate performance and latency issues?
Yes. Trace is built for investigating performance and latency issues with evidence-driven reasoning. When you report that latency is high or performance has degraded, Trace generates hypotheses about the cause—resource contention, inefficient queries, network delays, config misalignment—then helps you design targeted measurements and observations to test each one. This structured approach turns vague performance complaints into actionable root causes.
How does Trace support postmortem and premortem analysis?
Trace conducts structured causal tracing for both postmortem (after-incident) and premortem (before-deployment) analysis. In postmortem mode, it helps you trace back from observed failure to root cause by generating competing explanations and evaluating evidence. In premortem mode, it helps you imagine what could go wrong, generate plausible failure modes, and identify early warning signs—turning speculation into a prioritized investigation plan.
What kinds of system issues can Trace diagnose?
Trace diagnoses runtime bugs, regressions, performance degradation, latency spikes, and unexpected system output. It also handles config, routing, and orchestration behavior anomalies—cases where the system is behaving unexpectedly but the cause isn't obvious. Trace works best when multiple plausible explanations exist and you need to rank them by likelihood using evidence.
Why is root cause analysis with Trace better than guessing?
Trace replaces guessing with structured evidence-driven reasoning. Instead of jumping to the first plausible explanation, Trace forces you to generate multiple competing hypotheses, identify what evidence would discriminate between them, and gather that evidence systematically. This approach reduces confirmation bias, catches overlooked causes, and gives you confidence that your root cause explanation is sound—not just convenient.
SKILL.md
rendered from the published skill — quoted content, verbatim
Trace
Evidence-driven causal tracing using competing hypotheses. Use for ambiguous, causal, evidence-heavy questions where the goal is to explain WHY something happened.
Good Entry Cases
- Runtime bugs and regressions
- Performance / latency behavior
- Architecture / premortem / postmortem analysis
- Config / routing / orchestration behavior
- "Given this output, trace back the likely causes"
Core Contract
Always preserve: Observation → Hypotheses → Evidence For → Evidence Against → Best Explanation → Critical Unknown → Discriminating Probe
Workflow
- Restate the observed result precisely
- Generate 3 deliberately different hypotheses:
- Code-path / implementation cause
- Config / environment / orchestration cause
- Measurement / artifact / assumption mismatch
- Assign @tracer to each hypothesis lane
- Each lane: evidence for, evidence against, critical unknown, discriminating probe
- Apply lenses: Systems,
(truncated - see the full file via the links below)
Read as markdown · JSON record · Browse the source repository
File tree — 1 file
.github/skills/trace/SKILL.md