Vibe X-Ray: See What Your AI Actually Built

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 scan on your project, Vibe X-Ray automatically analyzes your codebase and produces a complete structural snapshot. That snapshot includes every file, every function, every class, every interface, and the relationships between them. 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:

• Total file count
• Total lines of code
• Number of findings (issues detected by Vibe Check)
• A health score based on finding density

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: Files

Click into any module and you see every file inside it. Each file shows its language, line count, and any findings attached to it. Files with findings are highlighted so you can spot problem areas immediately.

This level answers: which specific files are contributing to the module's health score? If a module has a low score, the file list tells you exactly which files are responsible.

Level 3: Symbols

Click into any file and you see every symbol defined in it - functions, classes, interfaces, type aliases, constants, and exported variables. Each symbol shows its kind (function, class, method, etc.), its line range, and any findings that fall within its boundaries.

This level answers: what is this file actually doing? A file named utils.ts could contain 3 functions or 30. The symbol view tells you exactly what is inside without opening the file.

Symbols also show their signature when available. You can see function parameter types and return types at a glance, making it easy to understand the shape of an API without reading the implementation.

Level 4: Dependencies

The dependency view shows how files and symbols connect to each other. You can see:

• What this file imports - both internal project files and external npm packages
• What imports this file - which other files depend on it
• Cross-module connections - how different parts of your app are wired together

This level answers the most important question for refactoring: if I change this file, what else breaks?

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, the symbol view shows exactly how many responsibilities are crammed into it.

Hidden Complexity

A module with 5 files might have 200 symbols across them. Another module with 20 files might have only 40 symbols. 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 dependency view in Vibe X-Ray shows these connections explicitly. If auth/ imports from api/ and api/ imports from auth/, you can see the circular reference immediately.

Blast Radius

Before you refactor a function or rename a file, Vibe X-Ray shows you every file that depends on it. 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 dependency view tells you exactly which files are connected to the one you want to change. 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.

Version Tracking: See How Your Codebase Evolves

Every scan creates a new versioned snapshot of your codebase structure. Vibe X-Ray keeps a history of these snapshots so you can see how your project has changed over time.

Version 1 is your first scan. Version 2 is the next scan after you make changes. Each version records the full structure at that point in time - files, symbols, dependencies, module health scores, and finding counts.

This version history answers questions like:

• How many files were added since the last scan?
• Did the overall code complexity go up or down?
• Which modules grew the most?
• Did the number of findings increase or decrease?

For vibe-coded projects where the AI is making changes across many files in each session, version tracking gives you a clear audit trail of what the AI actually did.

Diff View: What Changed Between Scans

The diff view compares any two snapshots and shows exactly what changed between them. It operates at every level of the hierarchy.

File-Level Diffs

See which files were added, removed, or modified between two scans. If the AI added 8 new files during your last coding session, the diff view lists all 8 with their module assignments and line counts.

Symbol-Level Diffs

See which functions, classes, or interfaces were added, removed, or changed. If a function signature changed (new parameter, different return type), the diff highlights it. This is particularly useful for catching breaking API changes the AI introduced without telling you.

Finding Diffs

See which issues are new (introduced since the last scan), which are resolved (fixed since the last scan), and which are recurring (still present). This lets you track your remediation progress over time.

Regression Detection

If a symbol that had zero findings in the previous scan now has findings, Vibe X-Ray flags it as a regression. This is your early warning system: the AI introduced a problem that was not there before. Regressions show you exactly which code change caused the new issue.

Module Health Scores

Each module in your project gets a health score calculated from the density of findings within it. A module with many files and few findings scores high. A module with few files and 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 under 5 minutes:

1. Create a project on VibeDoctor and connect your GitHub repository
2. Run a scan - Vibe X-Ray data is generated automatically as part of every code scan
3. Open the Code Intelligence tab in your project dashboard
4. Explore - click through modules, files, and symbols 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 your connected GitHub repo, a new snapshot is created 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 files each module has, and where the findings concentrate. Then drill into specific files and symbols to understand the implementation details that matter for your work.

Pre-Refactoring Analysis

Before restructuring a module or splitting a god file, use the dependency view to understand the blast radius. See which other files import from the one you want to change. 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 the diff view. See exactly how many files the AI created or modified, what new symbols were introduced, 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 dependency view to identify which files import from it and which it depends on. 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 grid, symbol 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 works with any language that has structural syntax - functions, classes, interfaces, and modules. This includes the most common languages used in AI-generated projects:

Over 40 languages are supported in total. If your AI tool generated code in a mainstream language, Vibe X-Ray can map it.

FAQ