Most AI debugging tools do the same thing.

You paste your broken code. They pattern-match the symptom. They suggest a fix. You apply it. Something else breaks. You paste the new error. Three hours later you've applied 14 patches and the original bug is still there.

That loop has a name. It's called symptom chasing. And every major AI tool falls into it — including the best ones.  
look thats not the only thing wrong with debugging with AI agents, if you actually do it often you definately know many many more issues .

I built something to break that loop.

It's called Unravel. It's open source, completely free to use, and you bring your own API key. 



now Unravel

Here's what makes it different from just asking ChatGPT or claude:

and yeah this post is mostly written by claude itself (no jokes on snake biting its own tail) and yeah its ok to post AI written things if its geniune and you really know every single word in it... moving on-

**The Crime Scene analogy**

Your code crashed. Something broke. You need answers.

Here's how every other AI tool debugs:

You call a witness. The witness wasn't there when it happened. They've seen a lot of crime scenes though, so they make an educated guess based on what crimes usually look like in this neighborhood.

"Probably the butler. Usually is."

You arrest the butler. The real criminal is still in the house. Three hours later you've arrested five innocent people and the crime scene is more contaminated than when you started.

Here's how Unravel debugs:

Before the detective says a single word, a forensics team goes in.

They tape off the room. They dust for prints. They map every surface the suspect touched, every room they entered, every timestamp on every door log. They hand the detective a folder of verified facts — not assumptions, not patterns from previous cases. Facts from this crime scene.

"The victim's wallet was untouched. The window was opened from the inside. The variable duration was mutated at line 69 by pause()\*, then read at line 79 by\* reset() — confirmed by static analysis."

Now the detective reasons. Not from vibes. From evidence.

That's the difference. Other AI tools are witnesses guessing. Unravel sends in forensics first.

The forensics team is the AST engine. It runs before the AI touches anything.

Before any AI sees your code, Unravel runs a static analysis pass on your code's structure — extracting every variable mutation, every async boundary, every closure capture — as verified, deterministic facts. These facts get injected as ground truth into a 9-phase reasoning pipeline that forces the AI to:

Generate 3 competing explanations for the bug

Test each one against the static evidence

Kill the ones the evidence contradicts

Only then commit to a root cause

The AI can't guess. It can't hallucinate a variable that doesn't exist. It has to show its work.

Then I tested it.

I took two genuinely nasty bugs — the kind that break most AI debuggers — stripped all comments, and ran them through four tools: Claude sonnet 4.6, ChatGPT 5.3, Gemini 3.1 Pro (Google's current SOTA with thinking tokens), and Unravel running on free-tier Gemini 2.5 Flash

Bug 1 — The Heisenbug

A race condition where adding console.log to debug it changes microtask timing just enough to make the bug disappear. The act of observation eliminates the bug.

Bug 2 — The 5-file cross-component cache invalidation

A Kanban board where tasks appear to be added (the logs confirm it, the stats update correctly) but the columns never show them. The root cause is a selector cache using === reference equality on a mutated array — across 5 files, with two red herrings deliberately placed.

All four tools found the root cause. But only Unravel produced:

8 system invariants that must hold for correctness

Exact reproduction steps with expected vs actual behavior

3 competing hypotheses with explicit elimination reasoning

A paste-ready fix prompt for Cursor/Copilot/Bolt

A timestamped execution trace down to the millisecond

Then on a second run with a broader symptom description, Unravel found two additional bugs that all four tools missed entirely — a redundant render issue firing 5 times for one user action, and a missing event coalescing pattern. It also correctly flagged its own uncertainty when working with a truncated file. No other tool did either.

The uncomfortable truth this revealed:

On finding the bug — all four tools were equal on these tests. Raw model capability isn't the bottleneck for most debugging tasks.

The difference is what happens after the bug is found.

Three SOTA models gave you a correct prose answer you have to read, interpret, and act on yourself.

Unravel gave you the correct answer plus the reasoning chain, the variable lifecycle, the invariants, the reproduction steps, the fix prompt, and the structured JSON that feeds directly into the VS Code extension's squiggly lines and hover tooltips.

Same model. Radically different output. Because the pipeline is doing the work, not the model.

NOT just that the thing is - the bug as of now was on the easier side and thus every agent was able to find it, but as it gets more difficult, the codebase gets bigger and most AI agents start to hallucinate and give wrong solutions that break something else - I expect Unravel to stay persistent and give the perfect fix, altho i am still testing it (managing it with studies is difficult) These were medium-difficulty bugs. The Phase 7 benchmark (50 bugs, 5 categories, 3 difficulty levels) is being built specifically to test whether this holds at scale. Early results are promising.

What it actually looks like:

Web app — upload your files or paste a GitHub URL, describe the bug (or leave it empty for a full scan), get the report.

VS Code / Cursor / Windsurf — right-click any .js or .ts file → "Unravel: Debug This File" → red squiggly on the root cause line, inline overlay, hover for fix, sidebar for full report.

Core engine — one function, zero React dependencies, works anywhere:

jsconst result = await orchestrate(files, symptom, {

provider: 'google',

model: 'gemini-2.5-flash'

});

console.log(result.report.rootCause);

What it doesn't do yet:

Python, Go, Rust — JS/TS only for now

Runtime execution — analysis is static, not live

Multi-agent debate (Phase 4) — currently single-agent with hypothesis elimination

Being honest about limits. A tool that knows what it can't do is more trustworthy than one that claims everything.

Stack: React, Vite, @/babel/parser, @/babel/traverse, Netlify. Zero paid infrastructure. Built in 3 days by a 20-year-old CS student in Jabalpur, India with zero budget.

GitHub: [github.com/EruditeCoder108/UnravelAI](http://github.com/EruditeCoder108/UnravelAI) — MIT license, open source, contributions welcome.

If you're a vibe coder who's spent hours going in circles with ChatGPT on a bug — this is built for you. If you're a senior dev who wants to know why it works — the AST architecture is in the README and I'm happy to go deep in the comments.

Vibe-coders' dream open source project