Analytics & Reports
RubberDuck isn't only an IDE tool. Point it at a repository on the Analytics dashboard and it produces a graded, evidence-backed report: architecture and dependencies, security findings down to file and line, or complexity hotspots worth refactoring.
Getting your first report
Pick what you're trying to learn
Codebase Atlas for architecture, Bugs & Vulnerabilities for security, or Refactoring for complexity. Each is a separate, repeatable analysis with its own repo list, so a security run doesn't get buried under architecture runs on the same repo.
Point it at a repository
Connect a GitHub repository, or if you don't have one ready, try it in the RubberDuck Playground first: it runs the same analysis against a real demo codebase, findings, grades, and all, so you know exactly what you'll get before connecting your own code.
Let it analyze
The repo list shows which phase it's in and an estimated time to finish, so a large monorepo reads as "in progress" instead of looking stuck.
Open the report
Every analysis is pinned to the exact commit it ran against. Analyze the same repo again later and you can switch between runs to see whether the grade improved or a fix actually landed.
Three ways to analyze a repo
Each report runs its own independent pass over the repository, built for a specific question, so the one you get back is focused on what you actually asked, not a slice of one combined scan:
Codebase Atlas
Maps how a repository is actually built: entry points, module boundaries, dependency density, security posture, and complexity, all pinned to the exact commit analyzed.
Bugs & Vulnerabilities
A full security workup, from an executive summary down to individual findings with file and line evidence. The one to run before a release or an audit.
Refactoring
Ranks files by complexity and call-graph density so you know exactly where to start, then lays out the four-step workflow RubberDuck itself follows when it does fix something. It reads and ranks the code here; it doesn't commit changes on its own.
Inside a Codebase Atlas report
Codebase Atlas is the most detailed report RubberDuck produces, covering four angles on the same repository, from how it's structured down to where the risk concentrates:
Architecture Layers
Files loaded, taint flows, modularity score, and average cyclomatic complexity up top, then the codebase grouped into call-direction layers, Source, Feature/UI, API/Network, Build/Config, each with a file count and line count, plus a searchable index of every file.
Dependency Graph
Total lines of code, complexity, and modularity, then a hotspots table ranking the files with the densest call graphs, exact node and edge counts included, so you can see where a change is likely to ripple furthest.
Security Atlas
A security grade plus a critical/high/medium/low breakdown of every finding, and a findings list that's upfront about which ones are individually verified versus flagged by a pattern scan.
Metrics & Complexity
The same hotspot and complexity data as the dependency graph, reframed as a refactoring lens: which files are carrying the most complexity right now, ranked so you know where to start.
Inside a Bugs & Vulnerabilities report
From the highest-level summary down to individual findings:
Executive Summary
Overall code-health and security grades, key numbers (total findings, critical, high, verified, tainted data flows), a numbered list of top priorities in plain language, and a health-indicator score measured against a target.
Security Vulnerability Overview
A security score out of 100, issues broken down by severity from critical down to info, and the most common vulnerability types ranked by how many times each one shows up, things like missing authentication, path traversal, or unsafe deserialization.
Known Vulnerable Dependencies
Every dependency with a known advisory: the version you're on, the CVEs against it, and the exact version that fixes it, so upgrading is a lookup, not a research project.
Findings
Every individual finding with its severity, the file and line it's in, and a clear label for whether it was individually verified or came from a broader pattern scan, so you know how much to trust each one.
Language & Codebase Composition
A breakdown of the codebase by language: percentage of lines, file counts, and a per-language line count, so you know what you're actually looking at before you dig into the findings.
Inside a Refactoring report
This report tells you what's worth changing and exactly how RubberDuck would approach changing it, and is upfront that reading a repo and refactoring it are two different actions:
Complexity Snapshot
Total lines of code and how many languages they're in, average cyclomatic complexity across every function, a modularity score, and a count of complexity hotspots, the files with the densest call graphs.
Hotspots
The files ranked highest-risk first, each with its exact node and edge counts and a density score, so instead of guessing what's tangled you get a ranked list to start from.
RubberDuck's refactor workflow
A four-step approach explained with the real tool calls behind it: Signal (surfacing the smell), Pre-Check (scoping the change and confirming no hidden caller), Implement (a behavior-preserving edit with a matching test), and Re-Verify (the test suite plus structural checks like dependency cycles and security taint, before anything lands).
Refactor inventory (usually empty)
This report reads your repository, it doesn't change it, so there's no list of “refactors we made” unless you've actually applied one. The hotspots above are what's worth refactoring, not a changelog of what already happened.