On this page
Codebase visibility for an engineering manager comes down to four signals read from git history and the dependency graph: hotspots (where change and bugs concentrate), bus factor (how many people hold the knowledge), ownership silos (modules one person controls) and doc drift (docs the code has outgrown). Delivery metrics tell you the pipeline is slow. These four tell you which part of the code is making it slow, and who can fix it.
Where delivery metrics stop
DORA metrics describe the delivery pipeline, not the code. DORA's software delivery metrics are five: change lead time, deployment frequency and failed deployment recovery time (throughput), plus change fail rate and deployment rework rate (instability). Sprint velocity and ticket throughput sit alongside them.
Those numbers tell you a team is slowing down. They cannot say whether the cause is one fragile module, a single engineer everyone waits on, or documentation nobody trusts. That is the gap a manager fills with anecdotes from standups, and the one codebase visibility closes.
The four signals
Each signal answers a question a manager is already asked in planning. All of them come from git log, git blame and the dependency graph that repowise builds during repowise init and refreshes with repowise update.
| Signal | The question | What it is | Planning decision |
|---|---|---|---|
| Hotspot | Where will the next incident start? | A file with frequent change and a history of bug fixes | What to refactor first |
| Bus factor | Who can we not afford to lose? | How many top authors it takes to cover 80% of a file's commits | Who to pair, what to hand over |
| Ownership silo | Which module has one gatekeeper? | A module where one person owns more than 80% of files | Where to add reviewers |
| Doc drift | Which docs can we trust? | Paths, links, commands and symbols in docs that the tree no longer supports | What to rewrite |
Scroll the table sideways to see every column.
Hotspots
A hotspot is a file that changes constantly and keeps needing fixes. The danger is not churn on its own. It is a file that changes constantly and only one person understands.
repowise ranks hotspots by change frequency and prior bug fixes mined from full git history, and shows trend, bus factor and owner beside each file. The capture below is the repowise repository itself.

Hotspot health is also reported as its own KPI next to average health, so you can see whether the files that matter most are improving (code health layer). Browse a live example on FastAPI's code health page.
Bus factor
Bus factor is counted per file, not per team. A team of ten can have a billing module with a bus factor of 1. In repowise, a file's bus factor is how many of its top authors it takes to cover 80% of its commits. A value of 1 means one person wrote at least 80% of them. For bus factor across popular projects, see the bus factor of 35 popular open-source repos.
Rolled up, the stats page reports a repository truck factor (the fewest primary owners who together own more than half the files), the count of single-owner files, and the silo count. Bot authors are left out, and .mailmap is applied so one person committing from two addresses is counted once.
The knowledge_loss finding goes further. It fires when a file is still being edited, has a bus factor of 1, and the main author is no longer the one making the recent commits. Stable files never trigger it, because code nobody edits is low risk. See the FastAPI ownership map for what this looks like on a real project.
Ownership silos
A module is a silo when one person owns more than 80% of its files. That is a staffing signal: reviews queue behind one person, and incidents wake the same person each time. The Owners page lists every contributor with the files, hotspots and bus-factor-1 files they own, plus the people they share files with most.
For a team of three or fewer active contributors, one owner per file is normal, so repowise caps these findings at low severity unless the file is a hotspot. The small-team profile in .repowise/health-rules.json lowers them further.
Doc drift
Documentation makes claims the repository can check. repowise verifies five kinds on every init and update: file paths, links between documents, heading anchors, commands and symbols. It reports the ones the tree refutes, with no model involved. A README that names a script the manifest no longer declares is a concrete, fixable item, not a vague complaint about stale docs (doc drift layer).
A manager's weekly check, in four commands
Four commands cover the weekly look, and each reads from the stored index, so none is slow.
repowise init # index once: graph, git history, ownership, health
repowise health # fix-first list, repo KPIs, worst files
repowise risk main..HEAD # review priority for a branch or release
repowise status # what is indexed, and how far behind HEAD
For one file or module, add the ownership block:
repowise context src/billing/invoice.py --include ownership
repowise risk --target src/billing/invoice.py # owner, recent owner, bus factor
repowise init --commit-limit N sets how many commits per file are read (default 5,000, cap 10,000) and --follow-renames keeps ownership across file moves. In a shallow clone, run git fetch --unshallow first, otherwise owners describe only the commits fetched.
Agents and editors read the same data: get_overview(include=["ownership"]) returns the average bus factor, the count of bus-factor-1 files and the top owners, and get_health() returns the KPIs. repowise serves ten MCP tools in total.
Four situations and the signal to reach for
Planning a refactor
Start where hotspot and dependency reach overlap. A messy file nobody changes can wait. A messy file that changes weekly and that many modules import cannot. repowise health ranks a fix-first list with effort and expected health gain, and get_context(targets=[...], include=["callers"]) shows what depends on a file before you commit a sprint to it. For turning that list into a sequence, see how to prioritize technical debt.
Onboarding a senior hire
Give them the generated wiki and the ownership map instead of two weeks of poking around. The wiki explains modules and why they are shaped as they are, and Owners shows who to ask. Browse the FastAPI wiki for the format.
An incident at 2 a.m.
Find the right person before you page anyone. repowise risk --target <file> returns the primary owner, the recent owner and the bus factor. The two names often differ: the person who wrote a file years ago and the person who changed it last month. Page the recent owner first.
Quarterly planning
Fund the work the data points at. A defensible plan item reads: "these three modules are hotspots with a bus factor of 1, so we pair and add a second owner." get_risk(changed_files=[...]) on a release branch also lists up to five recommended reviewers, ranked by how many of the affected files each owns.
Using the numbers well
Treat ownership as authorship, not responsibility. repowise reads commits and blame, so a person who reviews every change but never commits does not appear, and squash merges credit the commit author. Use the output to start a conversation about knowledge sharing, not to rank people.
Three habits make the data useful:
- Put it where the team looks. Share the dashboard (
repowise serve) link or the hotspot table in the planning doc, so debt is a visible number. - Reward de-risking. Moving a critical module from a bus factor of 1 to 3 is delivery work, and the stats page shows it.
- Let the tool carry the "what". The generated wiki covers what code does, so engineers spend their documentation time on the why, which decision records capture.
FAQ
- What is codebase visibility for an engineering manager?
- It is the ability to see the state of the code itself: where change and bugs concentrate, who holds the knowledge, which modules have a single gatekeeper and which docs are stale. It complements delivery metrics, which describe the pipeline rather than the code.
- How do I calculate bus factor from git?
- Count the authors of each file's commits and find how many of the top authors it takes to cover 80%. If one person wrote 80% or more, the bus factor is 1. repowise computes this per file during
repowise init, applies.mailmap, and reports a repository truck factor on the stats page. - Does repowise send my code to an LLM provider?
- Hotspots, bus factor, ownership, health and doc drift are computed locally from git and the dependency graph, with no LLM key and no network calls. repowise is open source and self-hostable, and an LLM is only used if you opt in to generated wiki prose.
- How is this different from SonarQube?
- SonarQube centers on static analysis rules and quality gates. repowise adds the history dimension: ownership, bus factor, co-change and bug-fix history, joined to the dependency graph and an agent-readable index. Teams often run both.
- Does it work for my language?
- repowise parses 28 languages to a full AST, including Python, TypeScript, Go, Rust and Java, with 15 at the Full tier. Ownership and hotspot signals come from git, so they work for any file in the repository.
- Can I rank developers with this?
- It is not designed for that. Ownership means "wrote the most commits or lines", not "is responsible for", and it ignores review work. Use it to find knowledge risk in the code and plan how to spread it.


