All posts
Developer tracking6 min read

Bus factor of a codebase: which modules depend on one developer?

For a CTO or a CEO: how to see which modules of your codebase were written by a single person over the last 12 months, how to read that concentration fairly, what to do about it, and what the answer does not say.

The DeployIt Team

We build DeployIt, an MCP server that lets a whole company ask its code from Claude and track each developer's work.

The bus factor of a codebase is the smallest number of people who would have to leave before work on it stalls, and the place to look first is the modules written by one person. DeployIt keeps a dataset of who wrote each module over the last 12 months: a CTO or a CEO asks Claude “Which modules depend on a single person?” and reads the answer in a table.

If you run the company or its engineering, you do not need to read code to see this risk. You need a list of modules, a name beside each, and a way to read it that is fair to the person named.

In your Claude · example

Which modules depend on a single person?

Three modules were written almost entirely by one person over the last 12 months. It is a concentration to look at, not a fault.

ModuleMain authorShare of the module
billingCamille R.94%
exportsIdriss B.88%
notificationsLéa M.91%
Drawn from your commits12 months of merged commits · sample data

What is the bus factor of a codebase?

Wikipedia defines the bus factor as a measure of the risk that comes from information and capabilities not being shared among the members of a team. The name comes from a blunt question, what happens if someone is hit by a bus, and the same idea is also called truck factor or lottery factor. Put as a number, it asks how few people would need to vanish at once for the project to stop moving. The article states the worst case in one sentence: “A bus factor of one is a single point of failure” (Wikipedia, “Bus factor”, checked on 17 November 2026).

For a codebase, one number for the whole project hides what you need. Example: a team of twelve looks safe as a whole, and its billing module was still written by one person. The unit that matters is the module.

How do you see which modules depend on one developer?

The history already knows who wrote what. DeployIt reads the merged commits of the repositories you connect and keeps, among its statistics, a dataset named module_ownership: who wrote each module over the last 12 months, to see which ones depend on a single person.

Three reading rules apply to it, as they do to every statistic:

  • Only work that reaches each repository's landing branch counts.
  • Bots are excluded, and detected coding agents are counted separately.
  • An undeclared agent counts as human work.

The question is asked in plain language, with the Leadership profile. Claude calls stats_schema to learn what exists, then stats_query, and composes the table. The answer carries module names and people's names. It carries no line of code and no file path: for the Leadership profile, a filter removes them (filtered and tested; no filter is infallible).

The datasets are listed on the documentation page. The Leadership example on the home page shows the same kind of exchange: see what each team gets out of it.

How do you read the answer?

As a concentration, not a fault. A module usually rests on one person for a good reason: that person was trusted with the hard part, or was the only one available when it had to ship. The table says where knowledge sits. It says nothing about how well anyone works.

Three questions turn the list into a decision.

Is the module critical? You know which modules carry revenue or a legal obligation. One person behind a monthly export is not the same exposure as one person behind billing.

Who is the person? The people dataset holds each tracked person's role, their working time and whether they are a contractor. Example: a billing module that rests on a contractor whose assignment ends in March goes to the top of the list.

Is it recent? The window is the last 12 months. The answer describes who has been writing the module lately, and that is the person you would miss tomorrow.

What do you do about a module that rests on one person?

Four steps, in this order.

  1. Pair on the next change. The next ticket on the module is written by a second developer, with the usual author beside them. One change is enough to start.
  2. Rotate the reviews. Have the module's pull requests reviewed by colleagues in turn, not always by the same one. DeployIt counts a pull request as reviewed by a colleague when the reviewer is neither its author nor a bot: see what counts as a code review.
  3. Write the module's behaviour down by asking the code. Anyone with the Everyone profile can ask Claude how the module behaves, for example “What happens when a payment fails twice?”, and gets an answer drawn from the code, with its status; the Developers profile gets excerpts as well. Keep the verified answers where your team already writes: DeployIt generates no documentation, it answers. The method is in ask your codebase before you ask an engineer.
  4. Ask again next quarter. Same question, same words. If the share has not moved, the handover did not happen.

Wikipedia's article lists remedies of the same family (checked on the same day): reduce complexity, document the processes and keep that documentation current, cross-train.

What does this answer not say?

  • Who understands the module. It reads who wrote. A reviewer who knows the module by heart does not appear as an author.
  • What lives outside merged commits. An operating procedure, a supplier contact, a decision taken in a meeting.
  • Whether the code is good. That is another reading: the code score, which a language model gives to each commit.
  • Anything older than 12 months. Someone who wrote the module three years ago and still knows it is not in the table. Just after you connect your repositories, the table rests on the 6 months of history DeployIt reads at connection, not on 12.
  • What an undeclared agent wrote. It counts as human work.

It is also a statement about named people. DeployIt tracks each developer, and the company informs the people it tracks before it connects its repositories; the terms of service set the framework. Our advice: show the list to the people on it. They are the ones who will hand the module over.

What DeployIt does here

DeployIt is an MCP server. Your company gets one link, https://mcp.deployit.ai/<company>/<code>; each person adds it to Claude (on the web, on the desktop or in Claude Code) and signs up with a name and an email, which is not verified; their questions are logged under that name. Everyone starts with the Everyone profile: questions about the product, answered from the code; a filter removes the code, the file paths and the names of team members it recognises from the answers, without proving their absence, and a leak test tells you what still gets through. An administrator gives the Developers profile (excerpts) or the Leadership profile (developer statistics) to whoever needs it. Repositories are connected from GitHub or GitLab; DeployIt makes no commit, branch or pull request, and only adds one webhook per repository.

The whole product is described in what DeployIt does, on one page. For the other things a CTO can follow from the same statistics, see the engineering visibility playbook.

Next step: start the trial, connect your repositories, add your company link to Claude with the three steps of the connection guide and, with the Leadership profile, ask which modules depend on a single person; the demo answers with the Everyone profile, without statistics.

Price. Free plan: 15 questions a week for the whole company. A 30-day trial, no card. Plans from €290 a month excluding tax for up to 25 tracked developers: see pricing.

Ask your code from Claude

30-day trial, no card. Or try the demo first: add https://mcp.deployit.ai/demo to your Claude connectors.

Connect my code

Frequently asked questions

What is the bus factor of a codebase?

It is the smallest number of people who would have to leave before work on the codebase stalls. Wikipedia describes the bus factor as a measure of the risk that comes from knowledge not being shared in a team, and calls a bus factor of one a single point of failure (checked on 17 November 2026). In practice, the risk sits in the modules written by one person.

How do you measure the bus factor of a codebase?

Module by module, by looking at who wrote the code recently. DeployIt keeps a dataset that says who wrote each module over the last 12 months, built from merged commits; with the Leadership profile, you ask Claude which modules depend on a single person. The stats_schema tool gives the columns and the definition of each measure.

Is a low bus factor a sign that a developer is doing something wrong?

It is a concentration of knowledge, not a fault. A module usually rests on one person because that person was trusted with it. The answer says where to organise a handover; it says nothing about the quality of anyone's work.

How do you reduce the bus factor of a module?

Give the next change to a second developer, rotate who reviews the module's pull requests, and write its behaviour down. With DeployIt, anyone can ask Claude how the module behaves and keep the verified answers; DeployIt itself generates no documentation. Then ask the same question a quarter later to see whether the share has moved.

Who can see which modules depend on one person?

People with the Leadership profile, which an administrator gives person by person, and a warehouse or BI tool that presents a Data tool key. The Everyone and Developers profiles have no statistics. The company informs the people it tracks before it connects its repositories.

Continue reading

Connect my code