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

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.