Quick Answer
Vibe X-Ray is VibeDoctor's four-level visual code explorer that maps your entire AI-generated codebase into an interactive hierarchy: modules, the features inside them, the flow of calls through each feature, and single functions. Every code scan rebuilds the map, so you can see how your app is organized, where findings cluster, and where complexity is hiding - without reading every line of code yourself. Connect a GitHub repo, run a scan, and get a structural map built from that scan.
The Problem: AI Builds Fast, You Lose Track
When you build with Cursor, Bolt, Lovable, or Claude Code, the AI generates hundreds of files in minutes. It scaffolds routes, creates database models, wires up components, and adds utility functions you never asked for. By the end of a weekend session, you have a working app - and absolutely no idea how it is organized.
This is the fundamental tradeoff of vibe coding. You gain speed. You lose visibility. The AI knows what it built because it built it. You do not know what it built because you were prompting, not reading.
Traditional approaches to understanding a codebase - reading file by file, grepping for imports, drawing architecture diagrams on a whiteboard - do not scale when the codebase was generated in hours instead of months. You need a tool that can map the entire structure automatically, show you where things live, and let you explore at whatever level of detail you need.
That is what Vibe X-Ray does.
There is also a practical cost problem. Every time you prompt your AI coding tool to fix a bug or add a feature, the AI needs to understand your project structure to give useful output. Without a structural map, developers end up pasting 20 or 50 files into a single prompt because they are not sure which files are relevant. That burns through tokens and context window for information the AI does not need. Vibe X-Ray gives you the structural context to feed your AI only what matters - fewer tokens spent, better output quality.
What Is Vibe X-Ray?
Vibe X-Ray is VibeDoctor's visual code explorer. It takes your codebase and maps it into a navigable four-level hierarchy that lets you understand the full structure without reading source code line by line.
Every time you run a code scan on your project, Vibe X-Ray automatically analyzes your codebase and builds a structural map. The map includes the functions, classes, and interfaces in your files and which ones call each other. You can explore this structure interactively in the VibeDoctor dashboard.
Think of it as a live architectural diagram that updates itself with every scan. No manual documentation. No outdated diagrams. No guessing what that utility folder actually contains.
The Four Levels of Exploration
Vibe X-Ray organizes your codebase into four nested levels. Each level answers a different question about your project.
Level 1: Modules
At the top level, your codebase is grouped into modules - logical units based on your directory structure. If your project has src/auth/, src/api/, src/components/, and src/utils/, each of those becomes a module.
Each module shows:
- How many features and functions it contains
- Number of findings (issues detected by Vibe Check)
- A health score based on finding density
- Its file count and lines of code, in the module's side panel
This level answers the question: which parts of my app are healthy and which parts need attention? If your api/ module has 12 findings and your components/ module has zero, you know where to focus.
Level 2: Features
Click into any module and you see the features inside it: an API route, a page, an event handler, each with the functions it uses, its own health score and its findings. The module's side panel also lists every file in the module with its language, line count, and number of findings, with the files that have findings at the top.
This level answers: which parts of the module are contributing to its health score? If a module has a low score, the features and the file list tell you where the problems sit.
Level 3: Flow
Click into a feature and you see its flow: the functions and classes it runs through and which ones call each other. A file named utils.ts could contain 3 functions or 30; here you see which of them a feature actually uses.
This level answers: what does this part of my app actually do, step by step?
Level 4: Function
Click any function to open its panel. You can see:
- Where it lives - its kind (function, class, method, etc.), language, file and line
- Its findings - every issue that falls within its boundaries
- Called by - the functions that call it, each with its file and line
- Calls - the functions it calls
The module map above also draws the calls between modules, so you can see how different parts of your app are wired together.
This level answers the most important question for refactoring: if I change this function, what calls it?
Why You Need This for AI-Generated Code
AI-generated code has structural problems that are invisible at the file level but obvious when you see the whole picture.
God Files
AI tools love to put everything in one file. A single api.ts might contain 15 route handlers, 8 database queries, and 4 utility functions. In the file explorer, it looks like one file. In Vibe X-Ray, each of those functions shows up on the map, so you can see how many responsibilities are crammed into it.
Hidden Complexity
A module with 5 files might have 200 functions across them. Another module with 20 files might have only 40 functions. The second module is better organized - it has smaller, focused files. Vibe X-Ray surfaces this kind of structural insight that you would miss by browsing the file tree.
Dependency Tangles
AI tools often create circular dependencies or tightly coupled modules without realizing it. The module map in Vibe X-Ray draws the calls between modules. If auth/ calls into api/ and api/ calls back into auth/, you see the connection running both ways.
Blast Radius
Before you refactor or rename a function, its panel in Vibe X-Ray lists the functions that call it, with their files and lines. This is critical in AI-generated codebases where you did not write the import graph yourself and have no mental model of what connects to what.
Context Window Waste
AI coding tools have a finite context window, and every token you send costs money. When you do not know which files are relevant to a task, the default behavior is to include everything - paste the whole module, or worse, let the AI tool index your entire repository. Most of that context is noise. The AI processes thousands of lines that have nothing to do with the change you want.
Vibe X-Ray's function panel tells you which functions call the one you want to change and which ones it calls, and where each of them lives. Instead of sending 40 files to your AI, you send 4. The result is faster responses, lower token costs, and higher quality output because the AI has focused, relevant context instead of a repository dump.
Change Tracking: See What Changed Since the Last Scan
Every code scan rebuilds the map from your latest code, and VibeDoctor saves a structural snapshot of each scan. Your Code report then compares the new scan with the previous one.
For vibe-coded projects where the AI is making changes across many files in each session, this gives you a clear record of what the latest changes did to your code's health.
Finding Changes
The "Since Last Scan" cards show how many issues are new (introduced since the last scan) and how many are resolved (fixed since the last scan). This lets you track your remediation progress over time.
Regression Detection
If a function's findings get worse compared with the previous scan, VibeDoctor flags it as a regression. This is your early warning system: the AI introduced a problem that was not there before. The Regressions list shows each one with its previous and current finding count and its file path.
Module Health Scores
Each module in your project gets a health score calculated from the density of findings within it, with critical and high findings weighing more. A large module with few findings scores high. A small module with many findings scores low.
Module health scores let you prioritize your remediation work. Instead of going through 200 individual findings, you can look at the module grid and immediately see which part of your codebase needs the most attention.
The scores update with every scan, so you can see whether your cleanup efforts are moving the needle. If your api/ module went from 45 to 72 after you fixed the unprotected routes, you know the work had impact.
How to Use Vibe X-Ray
Getting started takes four steps:
- Create a project on VibeDoctor and connect your GitHub repository
- Run a scan - Vibe X-Ray data is generated automatically as part of every code scan
- Open Vibe X-Ray from the Code menu in your dashboard
- Explore - click through modules, features, and functions to understand your codebase
On paid plans, Vibe X-Ray updates automatically with every push scan. If you have the Watch, Guard, or Shield plan and push to the main branch of your connected GitHub repo, the map is rebuilt automatically. You always see the latest state of your codebase without running manual scans.
Practical Use Cases
Taking Over an AI-Generated Project
You inherited a codebase built by someone else using AI tools. Instead of reading every file, open Vibe X-Ray and start at the module level. See what the major components are, how many features and functions each module has, and where the findings concentrate. Then drill into specific features and functions to understand the implementation details that matter for your work.
Pre-Refactoring Analysis
Before restructuring a module or splitting a god file, open the functions you plan to move and check what calls them. This prevents the "I moved this function and now 12 files are broken" surprise that is common in AI-generated codebases.
Tracking AI Coding Sessions
After a long session with your AI coding tool, run a scan and check what changed since the last scan: how many issues are new or resolved, and whether any regressions appeared. This gives you a concrete summary of what the AI actually did - not just what you asked it to do.
Cutting AI Token Costs
Before your next prompting session, open Vibe X-Ray and check the module and file you want to modify. Use the function panels to see what calls the code you want to change and what it calls. Now give your AI tool exactly those files as context - nothing more. You stop paying for the AI to process your entire repository and start paying only for the relevant slice. The output quality improves because the model works with targeted context instead of trying to make sense of hundreds of unrelated files.
Code Reviews Without the Code
If you are reviewing someone else's AI-generated project (for a client, a partner, or an acquisition), Vibe X-Ray gives you a structural overview without needing repository access. The module map, function counts, and health scores tell you a lot about code organization and quality before you read a single line.
What Vibe X-Ray Supports
Vibe X-Ray maps functions, classes, and other definitions in the most common languages used in AI-generated projects:
| Language | Symbols Extracted |
|---|---|
| TypeScript / JavaScript | Functions, classes, interfaces, type aliases, constants, methods |
| Python | Functions, classes, methods |
| Go | Functions, methods, types (structs and interfaces) |
| Rust | Functions, structs, enums, traits, implementations |
| Java / Kotlin | Classes, interfaces, enums, objects, methods, functions |
| C# / Swift | Classes, structs, interfaces and protocols, enums, methods |
| Ruby / PHP | Classes, modules, methods, functions |
| Vue / Svelte | Functions and classes in the component's script block |
C, C++, Scala, Elixir, and Lua are mapped too, for 16 languages in total plus the script blocks of Vue and Svelte files.
FAQ
Does Vibe X-Ray work with any GitHub repository?
Yes. Connect any public or private GitHub repository to your VibeDoctor project and run a code scan. Vibe X-Ray generates the structural map automatically as part of the scan. There is no separate setup or configuration needed.
How often does the snapshot update?
The map is rebuilt with every code scan. On the free plan, you can run 1 manual scan per day. On paid plans (Watch, Guard, Shield), every git push to your main branch also triggers a scan, so your structural map stays current without any manual intervention.
Can I compare any two versions, or only adjacent ones?
Today the dashboard compares each scan with the one before it: new and resolved issues, plus regressions, on your Code report. There is no picker for comparing two older versions, and the X-Ray map itself always shows your latest code.
Is Vibe X-Ray available on the free plan?
Yes. Every code scan builds the map, on every plan, including the Free Week. Free accounts get one manual map rebuild a month, and once the Free Week ends, the file and issue lists in the module panel are locked until you upgrade. Paid plans keep automatic push scans after the Free Week.
Does Vibe X-Ray store my source code?
No. Vibe X-Ray stores structural metadata - file names, symbol names, line ranges, import relationships, and finding mappings. It does not store your actual source code. The repository is cloned temporarily during the scan, analyzed, and then deleted. Only the structural snapshot is persisted.