# The Inherited-Codebase Knowledge Map: Git History to Booked Experts

*Produce a per-module table of named experts, each tagged still-here, departed-reachable, or gone, with a truck factor and a dated transfer plan, in about two weeks.*

- Canonical URL: https://www.refolk.ai/guides/inherited-codebase-knowledge-map
- Pillar: Engineering and open source
- Format: Playbook
- Published: 2026-11-06
- Last reviewed: 2026-11-06
- Reading time: 23 min
- Keywords: how to find who knows legacy code, bus factor from git history per module, inherited codebase knowledge transfer plan, contact former developers of legacy system, truck factor calculation degree of authorship, hire former employee as consultant knowledge transfer

## Key takeaways

- In the original study of 133 GitHub systems, 65% had a truck factor of 2 or less, so a low number on an inherited codebase is normal and is the reason each module needs a plan.
- One tool reported a bus factor of 6 on full history and 1 on the last year of history, because coverage metrics count departed authors as present, so always rerun with a recency window.
- In one repository, 108 of the last 400 commits (27%) were authored by an AI agent, and simulations show agent-attributed code changes the truck factor in 73% of runs, with a median drop of 2.
- AVL's truck-factor estimate was correct for only 19 of 35 repositories (54%) in one replication, so current engineers should confirm every named truck-factor set, and any module figure above about 5 should be treated as unverified.
- Public retention records for former staff share one shape: a salary-pegged rate, an hour cap, a term of about six months, and a written duty to train named staff.
- In Refolk's index, 32,211 US profiles list COBOL, and 14 of a 25-profile sample hold founder, C-level, or VP titles, so departed legacy authors often need executive-grade outreach and pricing.

You inherited a codebase through a reorg, an acquisition, or a leadership change. Now you need to know, module by module, who actually understands it, which of those people are still here, and how to get paid time with the ones who left before something breaks. This playbook is for engineering managers, technical founders, developer-relations leads, and the technical sourcers who support them. It takes you from raw git history to four things, in about two working weeks: a per-module table of named experts, a truck factor for each critical subsystem, bot and agent commits removed, and a dated knowledge-transfer plan for each orphaned module.

## What an inherited-codebase knowledge map contains

An inherited-codebase knowledge map is one table with a row per critical module. Each row names the people who understand the module, gives each person's status (still-here, departed-reachable, or gone), and records the module's truck factor and a dated transfer plan. The rest of this guide exists to fill that table in correctly.

The truck factor (also called bus factor) is the smallest number of people whose departure would leave most of a module's files with nobody who knows them. Most writing on it stops at the number, and the number alone does not tell you who to call. In JetBrains' survey of practitioners, 61% of respondents said they wanted the names of key engineers and of the critical, low-bus-factor modules, not just a score.

Each row of the map holds:

- **Module**: a directory or service you have decided is critical.
- **Criticality**: high, medium, or low, set by you.
- **Truck factor**: the per-module figure, from full history and from a recent window.
- **TF set**: the named people the algorithm removed to reach its threshold.
- **Status per person**: one of the three statuses below.
- **Contact route and legal clearance**: for anyone not on the current roster.
- **Transfer plan**: who teaches whom, on what dates, under what agreement.

| Status | Means | Default action |
|---|---|---|
| Still-here | On the current roster | Protect their time, pair a second engineer |
| Departed-reachable | Left; verified route; legally clear | Scoped, paid sessions |
| Gone | No route, declined, or blocked | Document and rebuild internally |

Key people leave more often than you might think. One study of truck-factor developer detachment found it in 315 projects, 16% of the dataset. If the code came to you through a change of control, assume some of your TF set has already gone.

## Which truck-factor method fits a module-level map?

Use a degree-of-authorship algorithm, specifically AVL. Run it on each critical module separately, on both full history and a recent window. Commit-coverage "bus factor" numbers from dashboards measure something else, and they usually look safer than reality.

Degree of authorship (DOA) is a score per developer, per file. It has three inputs: first authorship (did they create the file), deliveries (how many changes they made to it), and acceptances (how many changes other people made, which dilutes their claim). A developer counts as a file's author when their normalized DOA is above 0.75. AVL, named for Avelino et al., works by removal. It takes out the developer who authors the most files, then the next one, and keeps going until more than 50% of files have no author left. The number of people removed is the truck factor. The people removed are the TF set.

Tools define "bus factor" in ways that don't line up. Check which definition your dashboard uses before you compare numbers.

| Method | Authorship rule | Stop or flag rule |
|---|---|---|
| AVL | normalized DOA > 0.75 | over 50% of files abandoned |
| RIG | blame lines; file abandoned at 90% | over 50% of files abandoned |
| csDetector | AVL-based | 2 or fewer leave, over 40% abandoned |
| kimun | 75% of main author's blame lines | over 50% of code |
| repowise | commit count, up to 5,000 commits | top authors covering 80% |
| mcp-git-historian | commits per directory | one author over 80%, 3+ commits |

The split that matters is this. AVL and kimun ask who would have to leave. repowise and mcp-git-historian ask who covers most of the commits. Coverage counts an author whether or not they still work there.

### Why per module, not per system

The 50% stop rule was tuned to match developers' judgement of when a whole system is in crisis. The answer key behind that tuning came from a survey of 35 open-source teams. When practitioners are asked directly, they say a project gets into trouble once more than about 20% of its files are abandoned. So for someone inheriting a codebase, a single system-wide TF overstates safety. A payments module can be completely orphaned while the repository as a whole stays under the 50% bar. Computing TF per module closes that gap.

Low numbers are normal. In the original study of 133 GitHub systems, 87 (65%) had a TF of 2 or less, and fewer than 10% had a TF above 10. A 1 or 2 should not surprise you. It is the reason that row needs a plan.

### Why a recency window

Kimun 0.36.0 reported a bus factor of 6 on one repository's full history and 1 when run with `--since 1y`. The code was the same in both runs. The window simply dropped authors who had stopped committing. When you inherit a codebase, counting departed authors as present is exactly the wrong assumption.

No published source sets a standard window. The only related figure I found is a median knowledge "halving time" of 4 months, reported by practitioners in the JetBrains survey. My working practice is to run full history and a one-year window, and to read the gap between the two as a measure of how much knowledge has already left.

### How far to trust the number

- Ferreira et al. compared algorithms and found AVL and CST the most accurate. Even so, the highest error was 11, and accuracy fell as the true TF rose.
- When they varied the threshold, the original 50% rule still gave the best agreement with developers.
- A later replication from Lund found AVL correct for 19 of 35 repositories (54%).
- Replacing DOA with degree of expertise (DOE), as the Knowledge Islands work does, made AVL more accurate.

A minimum absolute DOA of 3.293 is often quoted next to the 0.75 cutoff. I could not confirm it from primary sources. If your result depends on it, check the configuration that ships with the release of the ASERG/UFMG Truck-Factor tool you are running. Treat any module TF above about 5 as unverified until current engineers confirm the set.

### Cross-checking with evidence outside commits

Commits show who wrote the code, not who can debug it at 2 a.m. JetBrains built a multimodal bus factor that combines code reviews, version-control data, and meetings data. Beyond that, I found no validation study for CODEOWNERS files, incident or on-call records, architecture decision records, or issue threads, and no published weights for combining them. Use these sources to confirm or contradict the commit evidence, not to build a score.

#### Evidence layers for naming a module expert

1. **Team confirmation** - Current engineers confirm or reject each named expert
2. **Incident and on-call responders** - Who actually fixed the module when it broke
3. **Reviews and CODEOWNERS** - Who approved changes and who is listed as owner
4. **Commit authorship (DOA or DOE)** - Who wrote the files and kept changing them

*Commit authorship is the base layer, each layer above can confirm or contradict it, and no published weighting exists for combining them.*

## How do you remove duplicate identities, bots, and agent commits?

Merge each human's aliases into one identity with a .mailmap. Tag bots and AI agents as separate non-human identities, and leave them out of the authorship input before you compute anything. If you skip this step, the truck factor comes out wrong in two ways at once.

A .mailmap is a file at the repository root that maps alternate names and emails to one canonical author. Git uses it when you pass `--use-mailmap`. It fixes two problems:

- **Duplicates.** An engineer who committed from a work laptop, a personal address, and a renamed corporate domain shows up as three identities, each with a low DOA. None of them crosses 0.75, so their files look abandoned.
- **Non-human authors.** Bots and agents pile up commits. Of roughly 40 million authors in open-source git commits, about 400,000 are bots. The World of Code identity map classes 0.52% of author IDs as bots and another 2.48% as bad attribution.

Agent commits are the newer and bigger problem. In one repository, 108 of the last 400 commits were authored as "Devin AI" and 4 by dependabot.

**27% - Share of one repository's last 400 commits authored by an AI agent**

108 commits were authored as Devin AI, and 4 more came from dependabot.

#### One repository's last 400 commits, cleaned

| Stage | Figure | Note |
| --- | --- | --- |
| Last 400 commits | 400 | one repository, raw log |
| Minus Devin AI commits | 292 | 108 agent-authored removed |
| Minus dependabot commits | 288 | human commits left to score |

*Removing agent and bot identities left 288 of 400 commits as evidence of human understanding.*

Once an agent wrote the code, authorship no longer implies understanding. In simulations where AI-generated code was attributed away from developers, the truck factor changed in 73% of runs, mostly downward, with a median decrease of 2. If agent commits stay credited to the human who prompted them, you overstate how well that human knows the module.

```bash
# Distinct identities before and after the mailmap
git log --format='%aN <%aE>' | sort -u | wc -l
git log --use-mailmap --format='%aN <%aE>' | sort -u | wc -l

# Trailer identities are not mapped automatically; resolve them one by one
git check-mailmap "Jane Doe <jane@old-domain.example>"
```

Three mechanics to know:

- **Email-only rules are not always enough.** In the Devin case, the fix also needed rules that match on name, because an email-only rule could not reach the agent identities.
- **Trailers are not mapped.** Git applies .mailmap to authors but not to `%(trailers)`, so Co-authored-by credit is never merged. Resolve trailer names separately with `git check-mailmap`.
- **Tools may skip the mailmap.** Before a fix, kimun's blame path did not turn the mailmap on. Check that your tool uses it in both its blame and its log paths.

Open-source helpers exist for both jobs: GitAuthority for merging aliases, and the BIMAN detector for spotting bots. Whichever you use, have a human sign off on the final mapping.

> **Watch out:** Never map an agent to its operator
>
> Mapping an agent identity such as codex onto the human who ran it makes agent output look like human understanding.
> Give every agent and bot its own tagged identity and leave it out of the DOA input.

> Authorship implies understanding only when a human wrote the code and can still be asked about it.

## The two-week procedure, step by step

Eight steps take a repository to signed knowledge-transfer agreements in roughly nine to ten working days. Legal clearance runs alongside the people search. The last step runs for months, but it starts inside the two weeks.

#### Git history to signed knowledge-transfer agreements

1. **Define critical modules and scope** - List the directories that count as critical subsystems, with an owner and a criticality rating for each. About half a day; done when the module list exists and the owners agree with it.
2. **Resolve identities; tag bots and agents** - Write a .mailmap that merges each human's aliases, tag bot and AI-agent identities separately, and run git log --use-mailmap. About one day; done when every author string maps to one human or is tagged as a bot or agent.
3. **Compute per-module DOA or DOE and truck factor** - Run AVL on each module, on full history and on a one-year window, removing the top author until more than 50% of files are abandoned. About one day; done when each module has a TF figure and a named TF set.
4. **Cross-check with reviews, owners, and incidents** - Compare each TF set against code reviewers, CODEOWNERS, and incident responders, and ask current engineers to confirm or reject each name. One to two days; done when every module's expert list has been cross-checked.
5. **Classify every TF-set person** - Mark each person still-here, departed-reachable, or gone, using the HR roster and open-web search. About two days; done when every person has a status and either a contact route or a recorded reason there is none.
6. **Clear legal constraints in parallel** - Legal or HR reviews non-solicits, deal no-hire clauses, and NDAs while the people search runs. One to two days; done when each departed person is cleared or blocked in writing.
7. **Reach out and sign scoped engagements** - Contact cleared departed experts and agree on a rate basis, an hour cap, a term, and a duty to train named staff. Two to three days; done when the agreements are signed.
8. **Run transfer sessions and recompute TF** - Run sessions from week 3 through about week 26, with trainees making real changes to the code. Done when the recomputed TF for each orphaned module has gone up.

Roles: the engineering manager owns steps 1, 4, and 7. An engineer owns steps 2 and 3, a sourcer owns step 5, and legal or HR owns step 6. These durations come from a working plan, not a benchmark. A monorepo with dozens of critical directories will take longer on steps 3 to 5.

## How do you find departed authors and decide who is reachable?

Check the HR roster first to mark who is still here. Then search the open web for every departed member of a TF set, using the repository, the former employer, the module's stack, and the dates they committed as anchors. A person only counts as departed-reachable once you have a verified contact route and legal has cleared contact.

Commit metadata gives you better anchors than a name alone:

- **Canonical name and all aliases**, taken from the mailmap. Personal addresses in old commits are often still live.
- **Date range** of their commits to the module, which tells you which employer they were at.
- **The module's stack**, for example COBOL with CICS, or Perl with Oracle, which they probably still list.
- **Public GitHub activity** after their last commit here, which often names a new employer.

Doing this by hand across GitHub, LinkedIn, and the open web for twenty or thirty names takes up most of the two days in step 5. With [Refolk](/), a sourcer can ask for the whole set in plain English and get matched profiles back from all three sources. An example request: former engineers at the acquired company who committed to a named repository and now work elsewhere.

Watch for people who share a name. Confirm each match on at least two anchors, such as dates and stack, or employer and repository, before you reach out.

### Who you will actually reach

Legacy stacks have a large public talent pool, and many of the people in it have moved up.

| Query | Profiles | Leadership titles, 25-profile sample |
|---|---|---|
| COBOL, United States | 32,211 | 56% (14 of 25) |
| COBOL, United Kingdom | 3,758 | about 8% (2 CTOs of 25) |
| Perl, United States | 141,043 | 52% (13 of 25) |

**32,211 - US profiles listing COBOL in Refolk's index**

The US pool is 8.6 times the UK pool of 3,758, and US Perl is 4.4 times larger again.

In Refolk's index of professional profiles, 14 of a 25-profile sample of US COBOL holders have founder, C-level, or VP titles, and 1 lists "Freelance" as employer. Each title share comes from just 25 profiles, so treat them as low confidence. The likely reason is that the people who wrote legacy code are now mid-to-late career. Outreach often lands on executives whose time is worth far more than their old salary, and your rate and tone need to reflect that.

The same pool matters when an author is gone. An outside specialist who works in the same stack is your fallback for reading the code alongside your team.

I ran this search: `Engineers in the US with 10+ years of COBOL and CICS now working as independent consultants` - [see the full result list](https://www.refolk.ai/s/fhs7q70nj4).

*Returns matched profiles from GitHub, LinkedIn, and the open web, a fallback pool when a module's original author is gone or unavailable.*

### Triage by criticality and reachability

#### Which orphaned modules to act on first

Horizontal axis runs from Expert gone to Expert reachable. Vertical axis runs from Low criticality to High criticality.

| Quadrant | What it means |
| --- | --- |
| Critical and gone | Start an internal rebuild now; pair two engineers and add an outside specialist in the same stack |
| Critical and reachable | Engage first; sign scoped sessions in week 2 |
| Minor and gone | Accept the risk; document the module as you touch it |
| Minor and reachable | Keep the contact in reserve; call only when an incident needs it |

*Critical modules whose experts are gone need an internal rebuild started now, and critical modules with reachable experts get the first signed engagements.*

## What does a paid knowledge-transfer engagement look like?

A workable engagement copies the shape of public retention records. It has a rate pegged to the person's final salary or current market rate, a cap on hours per week or per term, a term of about six months, and a written duty to train named staff. Legal clears the deal agreements and the person's old contract before the first message goes out.

Public records of former employees retained as consultants:

| Organization | Rate | Cap | Term |
|---|---|---|---|
| NYC DFTA | $46.14/hr, about salary | none stated | 6 months |
| NYC Comptroller | $74/hr on $105,000 salary | about 12 hrs/week | Jan to early March peak |
| Neuronetics | $200/hr | 10 hrs/week | not verified |
| Hawaiian Electric | fixed fee | 500 hrs | 6 months |
| Leidos | $1,200/hr | 180 to 1,860 hrs per 12 months | ongoing |

What the records show:

- **Rate basis.** The Comptroller's $74 is 1.47 times the hourly equivalent of a $105,000 salary ($50.48, at 2,080 hours a year). DFTA paid about the salary equivalent. Leidos's $1,200 shows how high the rate goes for a senior executive.
- **Cap.** Hawaiian Electric's 500 hours over 26 weeks works out to about 19 hours a week. Leidos and Hawaiian Electric both cap consulting at 20% of the average over the prior 36 months. At Leidos, that cap is tied to when deferred compensation is paid out, so ask whether the person's old pay plan has a similar rule.
- **Training duty.** The DFTA letter says the former employee "will also train other staff to perform the aforementioned tasks in his absence." Put that sentence, with names, in your agreement. It is what turns paid help into a rising truck factor.
- **Confidentiality.** Neuronetics states that consultant confidentiality obligations are "in addition to, and not in lieu of" the person's obligations as a former employee. Expect both sets to apply.

### Legal constraints to clear first

- **Non-solicits** usually run six months to two years. Sample clauses cover people associated with the company within the last six months and exclude general advertising.
- **Deal no-hire clauses.** M&A templates bar each party from soliciting, hiring, or engaging the other party's employees without prior written consent. An acquirer who contacts the seller's departed engineers can breach this.
- **Who approached whom.** In New York, courts have found that a non-solicitation agreement may not be enforceable when the client approached the former employee. This depends on jurisdiction. Take it to counsel; don't plan around it.
- **The person's current employer.** Rules on outside work at their current job are not something you can check from public sources. Ask the person to check their own contract, and get their confirmation in writing.

The cleanest documented procedure I found is the post-employment consulting disclosure letter used by the NYC Conflicts of Interest Board. It records scope, rate, term, and the training duty in one place, and it makes a good model for your internal approval memo.

> **Rule:** No outreach before legal clearance
>
> Nobody contacts a departed engineer until legal has reviewed the acquisition agreement, the person's non-solicit, and any NDA.
> A deal no-hire clause can bar you from engaging the seller's former staff without prior written consent.

**First message to a departed module author**

```
Subject: Paid, capped help on [module] from your time at [Company]

Hi [Name],

I now lead the team that owns [module], which you built and maintained at [Company] from [first year] to [last year]. Your commits are still the clearest record of how it works.

I would like to pay you for a short, scoped engagement: up to [N] hours a week for [term], at [rate] per hour. Most of the time would be walkthroughs with [trainee 1] and [trainee 2], so they can own the module without needing you.

There is no obligation, and you may need to check your current employer's rules on outside work first. If a 20-minute call sounds worthwhile, reply with a couple of times that suit you.

[Your name]
[Role, Company]
```

*Send only after legal clearance; replace the bracketed fields and keep the hour cap and term explicit.*

**Knowledge-transfer engagement scope**

```
Purpose: Transfer working knowledge of [module(s)] to named staff
Modules in scope: [list, with repository paths]
Named trainees: [name, role]; [name, role]
Rate basis: [final salary / 2,080 x multiplier] or [market rate], per hour
Hour cap: [N] hours per week, [total] hours per term
Term: [start date] to [end date] (default about 6 months)
Training duty: Consultant will train the named trainees to perform [tasks] in the consultant's absence
Deliverables: [runbook for X]; [recorded walkthrough of Y]; [paired fix of one open issue]
Success measure: Recomputed truck factor for [module] rises from [baseline] by [end date]
Confidentiality: In addition to, not in place of, existing former-employee obligations
Disclosures: Consultant confirms their current employer's outside-work rules allow this engagement
Approvals: Legal review of the acquisition agreement and prior employment contract, dated [date]
```

*Attach this to the consulting agreement; legal adds the confidentiality and non-solicit language.*

## How this goes wrong: failure modes and false positives

Most bad knowledge maps fail in the same few places: the identity data, which metric was used, how much of the system it covered, and legal timing. Each failure below says what it looks like and how to check for it before the map goes to anyone.

1. **Split identities hide an expert.** *Looks like:* a module where nobody's DOA reaches 0.75, plus a long tail of similar names. That pattern can mean the module isn't orphaned at all; one person's work is spread across several aliases. *Check:* count distinct emails per name before and after the .mailmap, and confirm your tool's blame path uses the mailmap.
2. **A mailmap that folds agents into a human.** In one project, a pull request mapped "codex" to the repository owner while leaving github-actions and dependabot unmapped. *Looks like:* one human with implausibly high authorship across many modules, which suggests human understanding that may not exist. *Check:* grep the mailmap for agent names and confirm each one maps to a tagged non-human identity.
3. **Co-author trailers skipped.** Pairing partners and co-authors are under-counted, because git does not apply the mailmap to trailers. *Looks like:* someone the team calls an expert has almost no authored commits. *Check:* run `git check-mailmap` on every trailer identity.
4. **Coverage reported as bus factor.** Coverage metrics still credit inactive authors with knowledge, so the number looks safe: 6 on full history against 1 in a recent window. *Check:* rerun with a recency window, and find out which definition the dashboard uses.
5. **A system-wide TF hides orphaned modules.** The 50% stop rule can stay quiet while practitioners would already call the project in trouble at under 20%. *Looks like:* a comfortable repository figure while one service has a single author. *Check:* compute TF per module.
6. **High TF figures misestimated.** AVL's error reached 11 on large systems. *Looks like:* a reassuring TF of 8 or 9 on a module nobody on the team feels confident about. *Check:* treat any TF above about 5 as unverified until current engineers confirm the set.
7. **Squash merges credit the person who merged.** None of the sources I found cover this, so I can't say how common it is. *Looks like:* a tech lead or release manager "authoring" modules they reviewed but did not write. *Check:* for a sample of squashed pull requests, compare the authors on the pre-merge branch with the PR author. If they differ, take authorship from the branch.
8. **Outreach inside a deal no-hire window.** An acquirer engages the seller's departed engineers during the restricted period. *Check:* legal reviews the acquisition agreement before any outreach, with no exceptions for informal calls.
9. **A same-name false match.** The profile you found has the right name and the wrong career. *Check:* require two independent anchors, such as commit dates plus stack, or employer plus repository, before anyone is marked departed-reachable.

## Keeping the map current after handover

The map is done when each orphaned module's recomputed truck factor has gone up, not when sessions are booked. Recompute at each milestone of the engagement and at the end of the term, using the same mailmap, the same exclusions, and the same windows as the baseline.

- **Trainees must commit.** Knowledge transfer only shows up in the history when the people being trained change real code. Give each trainee real issues in the module during the term.
- **Review the mailmap on every recompute.** New agents and bots show up as teams adopt tools. An unmapped agent identity quietly undoes the cleanup from step 2.
- **Recheck legal windows.** A non-solicit that blocked contact in week 1 may lapse during the term. Ask legal for the end date and put it on the calendar.
- **Move people between statuses.** Departed-reachable people who decline become gone. Rebuild plans for gone, high-criticality modules need dates, not intentions.

> **Tip:** Diff the names, not just the number
>
> A TF that rises from 1 to 2 only counts if the new name belongs to a current staff member, not to a consultant whose term ends.
> Compare TF sets across recomputes and record who replaced whom.

#### Before you call the map done

- [ ] Every author string maps to one human or is tagged as a bot or agent.
- [ ] The mailmap contains no agent name mapped to a human identity.
- [ ] Each critical module has a TF from full history and from a one-year window.
- [ ] Every module TF above about 5 has been confirmed or corrected by current engineers.
- [ ] Every TF-set person has a status of still-here, departed-reachable, or gone.
- [ ] Every departed-reachable person's contact route is confirmed by two independent anchors.
- [ ] Legal has reviewed the acquisition agreement and relevant non-solicits before any outreach.
- [ ] Each signed agreement states a rate basis, an hour cap, a term, and named trainees.
- [ ] Every high-criticality module whose experts are gone has a dated rebuild or outside-specialist plan.
- [ ] A TF recompute date is on the calendar for each orphaned module.

## Frequently asked questions

### How do I calculate bus factor from git history per module?

Run a degree-of-authorship truck-factor algorithm on each critical directory separately, not on the whole repository. AVL counts a developer as a file's author when their normalized DOA is above 0.75. It then removes the top author, one at a time, until more than 50% of the module's files have no author left. Merge identities with a .mailmap and exclude bots and agents first. Then run it twice, on full history and on a recent window such as one year.

### What truck factor is too low for an inherited module?

Treat a module truck factor of 1 or 2 as orphan risk that needs a dated plan. It is common, though: 65% of the 133 systems in the original study had a TF of 2 or less. csDetector flags a smell when two or fewer departures would leave more than 40% of files abandoned. Practitioners say trouble starts below 20%. Treat figures above about 5 as unverified, because estimation error grows as the true TF rises.

### Should AI agent and bot commits count toward the bus factor?

No. Tag them as separate non-human identities and leave them out of the authorship input. An agent's commit does not mean any human understands that code. In simulations, attributing AI-generated code away from developers changed the truck factor in 73% of runs, usually lowering it by a median of 2. Never map an agent name onto the human who ran it in your .mailmap. That makes agent output look like human expertise.

### How much should I pay a former employee for knowledge transfer?

Start from their final salary as an hourly rate, then adjust for how senior they are now. In public records, one city agency paid $46.14 an hour, about equal to salary. Another paid $74 an hour against a $105,000 salary, about 1.47 times the hourly equivalent. A medical-device company paid $200 an hour, and a senior executive's agreement set $1,200 an hour. Cap the hours and set a term of about six months.

### Can I contact former engineers of a company we acquired?

Only after legal has reviewed the acquisition agreement. M&A templates often bar either party from soliciting, hiring, or engaging the other party's employees without prior written consent. Individual non-solicits usually run six months to two years. In New York, courts have found that a non-solicit may not be enforceable when the client approached the former employee. Rules vary by jurisdiction, so counsel decides before anyone sends a message.

### What do I do when a module's original author is gone?

Mark the module gone and start an internal rebuild right away. Pair two current engineers on it and bring in an outside specialist who works in the same stack to read the code with them. Legacy stacks have a large public talent pool: Refolk's index holds 32,211 US profiles listing COBOL and 141,043 listing Perl. Write the specialist into the same scoped agreement, with named trainees and an hour cap.

---

*From the Refolk guide library. I revise these guides rather than replacing them, so the current version is always at https://www.refolk.ai/guides/inherited-codebase-knowledge-map*
