Teaching Your Coding Assistant to Time‑Travel: The Temporal Debug Skill

When a production crash surfaces, the usual drill is to copy‑paste the stack trace into Claude Code, Cursor, or GitHub Copilot and hope the model can conjure a solution. The problem? Those assistants are looking at the tip of the repo – the present – while the bug actually lived in a past commit. It’s like asking a detective to solve a 1998 robbery while only showing them today’s news headlines.

Meher Bhaskar, a senior data scientist at Walmart, ran into this exact scenario in early 2026. A microservice that processed inventory updates began throwing NullPointerExceptions only after a specific deployment. The error log pointed to a line that, in the current main branch, no longer existed. The AI suggested changing a function that was already gone – classic “debug ghost” behavior.

To cut through the fog, Bhaskar built what he calls the Temporal Debug Skill. At its heart it’s just a couple of Git commands that spin up a temporary work‑tree at the exact commit that generated the crash, hands that snapshot over to the AI, and then tears it down when you’re done. The skill is published on GitHub under MeherBhaskar/temporal-debug-skill and can be added to most AI‑powered IDE extensions with a one‑liner: npx skills add MeherBhaskar/temporal-debug-skill.

The workflow looks deliberately low‑tech, which is part of its charm. First you locate the offending commit – for example, “three hours ago” – using git log --before="3 hours ago" -1 --format="%H". That gives you a SHA‑1 hash, which you then feed into git worktree add /tmp/temporal-debug-<hash> <hash>. Suddenly you have a fully functional copy of the code exactly as it was when the bug manifested, isolated from any current changes.

Now you can drop the same stack trace into Claude Code (or any other assistant) while the work‑tree is the current HEAD. The model sees the same line numbers, the same method signatures, and can suggest a concrete fix – maybe a null‑check that was added later, or a missing field initialisation that got removed in a refactor. When you’re satisfied, a simple git worktree remove --force /tmp/temporal-debug-<hash> cleans up, leaving your repository untouched.

Why does this matter? AI models are brilliant at pattern matching, but they have no intrinsic notion of history. They don’t “remember” that a file used to contain a particular line unless you show them that line. By giving them a snapshot, you give them the context they need to move from vague speculation to actionable code.

Bhaskar notes a couple of practical tips. First, keep the work‑tree path short and out of your project root – it avoids accidental commits. Second, if you’re on a shared machine, wrap the whole thing in a Docker container so the temporary filesystem disappears when the container stops. Lastly, don’t forget to delete the work‑tree; lingering copies can bloat your disk and, worse, confuse future git commands.

Of course, the skill isn’t a silver bullet. It assumes you have a clean commit history and that the crash can be reproduced from a single commit snapshot. Some bugs are the product of a race condition that only appears when a later change re‑introduces a stale state. In those edge cases you may still need to step through the timeline manually.

Still, for the majority of “ghost” bugs – the ones that disappear once the code moves forward – the Temporal Debug Skill offers a cheap, reproducible way to bring the past into the present. It turns an AI from a vague oracle into a pragmatic debugging partner, and that, in Bhaskar’s words, feels a lot less like magic and a lot more like good engineering.

If you’re curious, the skill is open‑source and ready to plug into most modern AI code assistants. Give it a try the next time a stack trace points to a line that’s no longer there – you might just save yourself a few frustrating hours.