I shipped a GitHub repo analyzer, it went viral in China, then everything broke

Sidhant Kumar — Fri, 29 May 2026 00:48:29 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

CodeAutopsy. You know that feeling when you clone a repo and just...
stare at 47 folders with no idea where anything is? That's what I
built this to fix.

Paste any GitHub URL. It parses the entire codebase, builds a
dependency graph, and tells you exactly what imports what, where
execution starts, and what breaks if you touch a specific file.

Started this a few months ago because I was tired of spending the
first two days of every new project just figuring out where
everything lives.

Demo

Live: codeautopsy-lyart.vercel.app
GitHub: github.com/Sidhant0707/codeautopsy

The Comeback Story

Shipped the core, posted on Reddit, someone in China tweeted it in
Chinese and it got 7,400 views overnight. 66 stars, 262 unique
cloners in two weeks. All organic. I was pretty stoked.

Then everything broke.

The AI layer was sending 40-60k tokens per analysis to a single
provider. Groq hit its 100k daily limit in 18 runs. Switched to
Gemini — project got permanently banned. Tried Cerebras — they
dropped Llama entirely overnight. SambaNova had a 20 requests per
day limit which lasted about 4 minutes.

Two full days of provider roulette.

The fix was rethinking the whole approach — splitting the single
massive AI call into focused smaller calls across multiple providers,
building a fallback chain so one 429 doesn't take the whole thing
down, and stabilizing the streaming JSON repair so users never
stare at a blank screen mid-analysis.

The interview mode feature I'd built — where an AI interviews you
about the codebase while nodes on the graph light up — got parked
on a branch until the core was stable enough to actually support it.

My Experience with GitHub Copilot

Copilot was open the whole time in VSCode. The place it actually
helped most was the partial JSON repair algorithm — I'm streaming
incomplete JSON token by token and trying to parse it in real time.
The edge cases are nasty: unclosed strings mid-token, mismatched
brackets, empty chunks. Copilot kept catching the ones I missed.

Also saved me a lot of time tuning the d3-force physics for the
dependency graph. Getting node collision and link distance to feel
right took a lot of iteration and having inline suggestions for the
parameter values was genuinely useful instead of just guessing.

I built an open-source tool that reverse-engineers any GitHub repo in 10 seconds

Sidhant Kumar — Fri, 29 May 2026 00:26:15 +0000

You know that feeling when you join a new project or want to contribute to an open-source repo, and you spend the first two days just trying to figure out where everything is?

I did. Every single time.

Clone the repo. Open the files. Stare at 47 folders. Wonder which one actually matters. Grep for the entry point. Follow imports down a rabbit hole. Give up and ask someone.

That's not learning. That's just wasted time.

So I built CodeAutopsy.

What it does

Paste any GitHub URL. That's it.

CodeAutopsy clones the repo, parses every file into an AST (Abstract Syntax Tree), traces every import and dependency, and gives you:

An interactive dependency graph showing exactly what imports what
The entry points — where execution actually starts
A blast radius map — click any file and instantly see everything that breaks if you change it
An AI-generated architectural summary explaining what the codebase does, how it's structured, and how to get started
Live Health Telemetry: An Edge API that generates a live SVG health badge (A to F grade). Drop the markdown in your README once. Every time you refactor and re-scan, your badge updates everywhere instantly. My own CodeAutopsy repo just hit 99/100. Drop the markdown snippet once and forget about it.

What used to take days now takes about 10 seconds.

The real problem it solves

Every developer has been here:

You're onboarding at a new job. The codebase has 200 files. Your tech lead says "just read the code." You spend a week feeling lost.
You want to contribute to an open-source project. The repo has no architecture docs. You don't know where to start.
You're doing a code review on a PR that touches 15 files. You have no idea what the blast radius of those changes is.

CodeAutopsy solves all three.

The interesting engineering problems

The hardest part wasn't the AST parsing — it was keeping it serverless without hitting Vercel's 504 timeout limits, while making the AI analysis feel instant.

The Serverless Timeout Hack: Doing AST extraction, building an adjacency list, and waiting for an LLM to generate a massive response in a single API route was a guaranteed timeout crash. I split it into dual endpoints: a fast extractor for the AST graph, and a separate inference engine triggered by the client that pipes a native Web ReadableStream directly back to the frontend.

Streaming JSON Repair: The LLM streams back a strict JSON object token by token. Normally you'd wait for the complete JSON before showing anything, leaving the user staring at a blank screen. Instead, I wrote a partial JSON repair algorithm that runs on every incoming chunk. It closes open strings, balances braces and brackets, and tries to parse whatever it has so far. The UI updates in real time as the analysis streams in — you can literally watch the architectural summary build itself word by word.

The blast radius algorithm

This one I'm genuinely proud of.

When you click a file, CodeAutopsy does a BFS traversal on the reverse adjacency list of the dependency graph. Every file that imports the file you clicked — directly or transitively — lights up red.

So if you're about to refactor auth.ts, you instantly see that 14 other files depend on it. You know the blast radius before you write a single line.

What happened when I shipped it

// Detect dark theme var iframe = document.getElementById('tweet-2059229559413674120-325'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2059229559413674120&theme=dark" }

I posted on Reddit. Someone in China found it, tweeted it in Chinese, and it got 7,400 views overnight. 59 people bookmarked it. Someone compared it to DeepWiki and said it looked more advanced.

I found out because my GitHub traffic spiked and I went looking for the source. 66 stars. 262 unique cloners in 14 days. All organic.

I'm a CS student. I built this because I was tired of being lost in codebases. Turns out a lot of other developers feel the same way.

Try it

Free to use — no credit card, no setup. New users get 3 instant
analyses, then a free account unlocks 10 per day.

Live App: codeautopsy-lyart.vercel.app
GitHub: github.com/Sidhant0707/codeautopsy

Would love feedback — especially on the blast radius algorithm. Currently doing BFS on the reverse adjacency list but I suspect there are smarter approaches for large monorepos. Drop a comment if you have ideas.

DEV Community: Sidhant Kumar