Teaching AI Agents to Time-Travel: Building a Temporal Debugging Skill

Meher Bhaskar — Sun, 12 Jul 2026 00:19:41 +0000

Your AI agent is confident. It points to line 42 of PaymentService.java. "There's your null pointer exception."

You check. Line 42 is a comment. The code was refactored 14 commits ago.

The production crash happened 3 hours ago. Your agent just spent 45 minutes debugging ghosts.

The Problem: Agents Are Stuck in the Present

Every AI coding agent today — Claude Code, Cursor, Copilot, Cody, you name it — operates on the same assumption:

The code that matters is at HEAD.

But production bugs don't live at HEAD. They live in the commit that was running when the crash happened. That commit is buried under hotfixes, refactors, dependency updates, and feature merges that landed after the incident.

HEAD (now)          ← Agent analyzes THIS
   │
   ├─ feat: add new payment provider
   ├─ refactor: extract UserService
   ├─ fix: handle edge case in checkout
   ├─ chore: update dependencies
   │
   ▼
a1b2c3d (3 hours ago)  ← Bug ACTUALLY lives HERE

Your agent confidently finds bugs in code that didn't exist when the crash occurred.

The Insight: Git Already Has Time Travel

We don't need a time machine. Git has had one for years: git worktree.

# Get the commit from 3 hours ago
git log --before="3 hours ago" -1 --format="%H"
# → a1b2c3d4e5f6...

# Create an isolated, read-only snapshot at that commit
git worktree add /tmp/debug-a1b2c3d a1b2c3d

# Now analyze the historical codebase
cat /tmp/debug-a1b2c3d/src/PaymentService.java

# Clean up when done
git worktree remove --force /tmp/debug-a1b2c3d

This gives you:

✅ Isolated — doesn't touch your working directory
✅ Parallel — can have multiple historical snapshots simultaneously
✅ Disposable — cleanup is one command
✅ Zero deps — pure Git, works everywhere

The Missing Piece: Teaching Agents When to Time-Travel

Agents already know git log, git show, git diff, cat, grep. They can analyze code perfectly.

What they struggle with:

Fuzzy time → commit resolution — "last night", "v2.4.1", "the deploy before the hotfix"
Worktree lifecycle management — create, track, guarantee cleanup

So I built temporal-debug-skill — a portable skill definition that teaches any agent to handle exactly those two gaps.

What Is an "Agentic Skill"?

Think of it as a prompt template with superpowers. It's a Markdown file that tells an agent:

"When you detect X context, here are the exact git commands to run, in this order, with this cleanup guarantee."

No Python. No Node. No installation. Just instructions the agent follows.

# skills/temporal-debug/SKILL.md (simplified)

## Activation
Trigger when user message contains temporal anchors:
- "3 hours ago", "last night", "yesterday"
- "v2.4.1", "tag:release-42"
- "the deploy before...", "commit before..."

## Workflow
1. RESOLVE: `git log --before="<time>" -1 --format="%H"` → commit SHA
2. SNAPSHOT: `git worktree add /tmp/temporal-debug-<sha> <sha>`
3. ANALYZE: Read files from worktree, trace the bug
4. CLEANUP: `git worktree remove --force /tmp/temporal-debug-<sha>`
5. REPORT: Root cause + historical commit reference + introducing commit

See It In Action

Scenario 1: Production Crash with Timestamp

You: "Crash from 3 hours ago: NullPointerException in PaymentService.java:42"

Agent (with skill):

git log --before="3 hours ago" -1 --format="%H" → a1b2c3d

git worktree add /tmp/temporal-debug-a1b2c3d a1b2c3d

Reads PaymentService.java:42 from worktree → user.getEmail() without null check

git worktree remove --force /tmp/temporal-debug-a1b2c3d

Reports: "In commit a1b2c3d (3 hrs ago), PaymentService.java:42 accesses user.getEmail() without null check. user is null for guest checkouts. Introduced in f8e9d0a."

Scenario 2: Version-Pinned Bug Report

You: "Users on v2.4.1 report auth failures" (attaches error log)

Agent: Resolves tag v2.4.1 → worktree → finds regex bug in auth middleware skipping validation for /health-records → reports fix already in v2.4.2

Scenario 3: Regression Detective

You: "This endpoint 200'd last week, now 500s. Changelog shows nothing."

Agent: Resolves "last week" → creates two worktrees (last week + HEAD) → diffs relevant modules → finds pool size config regression from 50 → 10

Installation: 30 Seconds

For Claude Code (Recommended)

# Clone into your project's skills directory
git clone https://github.com/MeherBhaskar/temporal-debug-skill.git skills/temporal-debug-skill

That's it. The skill auto-activates when temporal context is detected.

For Any Shell-Capable Agent

cp -r temporal-debug-skill/skills/temporal-debug/ /path/to/your/agent/skills/

Why This Approach? (Design Philosophy)

✅ Skill Does	❌ Skill Doesn't
Detects temporal context automatically	Require a CLI tool invocation
Resolves fuzzy time → exact commits	Need external scripts/binaries
Creates isolated `git worktree` snapshots	Touch your working directory
Guarantees cleanup (even on error)	Require Python/Node/Go runtime
Works in ANY git repo, ANY language	Analyze code for you (you're better at that)

The skill is additive. It teaches the agent one new trick (time-travel via worktree). Everything else — reading files, tracing logic, suggesting fixes — the agent already does.

Real-World Impact

Since adding this to my workflow:

Before	After
45 min debugging wrong version	30 sec to historical root cause
"Which commit broke this?" → `git bisect` manual	Agent tells you: "Introduced in `f8e9d0a`"
Context-switching to check historical code	Stay in conversation, agent brings history to you

Roadmap

[ ] Multi-repo temporal analysis — debug across microservice boundaries
[ ] CI/CD integration — auto-trigger on failed builds, post temporal context as PR comment
[ ] Diff analysis mode — side-by-side historical vs. current comparison
[ ] Automated patch generation — from root cause to fix PR
[ ] Observability integrations — Sentry, Datadog, PagerDuty webhooks
[ ] VS Code extension — visual time-travel debugging

Try It

git clone https://github.com/MeherBhaskar/temporal-debug-skill.git
# Drop into your agent's skills directory

Repo: https://github.com/MeherBhaskar/temporal-debug-skill

License: MIT — use it, fork it, ship it.

Discussion

Have you hit the "agent debugging wrong version" problem?

What temporal anchors do you use most — "3 hours ago", version tags, "last deploy"?

Building agent tools?

The skill pattern (Markdown instructions → agent executes shell) is surprisingly powerful for bridging agent capabilities. Happy to discuss the architecture.

Stop debugging ghosts. Start debugging history. ⏪

The AI "Doom Loop": Why your autonomous coding agent is making things worse, and how to fix it

Meher Bhaskar — Sat, 20 Jun 2026 18:42:53 +0000

If you’ve spent any time working with autonomous AI coding agents recently, you know the drill.

You give the agent a straightforward task: "Add a user profile page and link it to the navbar."

The agent says, "I've got this." It writes some code. You run it, and it throws an import error. You paste the error back. The agent apologizes, rewrites the file, and now your routing is broken. You paste that error back. Ten iterations later, your config is mysteriously deleted, the navbar is entirely missing, and the agent is trying to install a deprecated version of React.

This is the AI Agent Doom Loop.

It happens because current agent frameworks mistake intelligence for discipline. We dump a 10,000-token SYSTEM_PROMPT.txt telling the agent everything about our project, hoping it remembers the architecture constraints on step 45 of its execution loop. It rarely does.

I built Agent Rigor because I got tired of babysitting agents that code themselves into corners.

The Root Cause: Context Rot

When an agent starts a task, its context is pristine. But as it reads files, executes commands, and hits errors, its context window fills up with junk stack traces and previous failed attempts.

By the time it's 20 steps deep, the original system prompt you carefully crafted is buried. The agent forgets the architecture guidelines. It starts prioritizing the immediate error in front of it over the overall goal. This is when it starts guessing, hallucinating, and making things worse.

The Solution: Progressive Disclosure and Empirical Discipline

Agent Rigor isn't a new LLM or a magic prompt wrapper. It's an operating system for agents that enforces strict empirical discipline.

Instead of one massive prompt, Agent Rigor uses a 3-tier hierarchy:

L1 (Apex Kernel): The absolute, non-negotiable laws. (e.g., "Never guess an API signature. Always grep or read the file first.")
L2 (Phase Directors): Orchestration that only loads when the agent enters a specific phase (Planning, Execution, Verification).
L3 (Skill Protocols): Specific instructions for specific tasks (like self-correction), loaded only when that specific task is underway.

This is Progressive Disclosure. The agent only sees the instructions it absolutely needs for the current atomic step.

Furthermore, Agent Rigor enforces a "known-good state" policy. If a test fails, the agent doesn't just keep blindly modifying the same file. It reverts, analyzes the actual evidence, and plans a new approach. No more "this seems right" commits. Everything must be empirically proven before moving forward.

Stop Babysitting, Start Engineering

If you're building with Cursor, Copilot or really any coding assitant, you need a discipline layer. You can check out how we implemented it in the open-source repo here: Agent Rigor on GitHub.

If it saves you from reverting a mangled codebase at 2 AM, give it a star. More importantly, if you think the approach is wrong, open an issue and tell me why.

DEV Community: Meher Bhaskar