Comprehension-Debt System of Record
See how much of your codebase no human has recently written, reviewed, or explained.
AI agents are writing most of your new code. The code may be fine — but every unreviewed merge adds another file nobody has been near since. Comprehension debt: code no human has recently written, reviewed, or explained — measured from the record, not a survey. Install the read-only GitHub App and Fathohm maps yours from your own commit and review history — then gives your team a way to pay it down.
Start with one you already know
The share of a repository no human has written or prompted in 180 days. Not comprehension debt — git keeps no review record.
38%gone dark
No human has written or prompted 38% of its 5,024 code files — 9 MB — in the last 180 days.
Check it yourself
git clone --filter=blob:none https://github.com/react/react.git npx fathohm read react --now 2026-08-12T00:00:00Z
The clock is pinned so you get our reading, not today’s — the share is measured over the 180 days before that instant, so an unpinned run would measure a different window and disagree for the wrong reason.
#32 of 100 by dark share · the whole index →
One command, and it keeps answering
Reading the share is where it starts. The same binary puts names to the code only one person has touched, shows what your reading looks like the day one of them leaves, and takes any single score apart into the four factors that made it.
Example repository — the same illustrative data as the Map above. Every line is the CLI’s own output, pinned by a test.
34% of this example repo: no human has recently written, reviewed, or explained it.
The Map: every file, sized by lines of code, colored by comprehension score.
Illustrative Map — example data, not a real customer repo. Yours is built from your actual commit and review history.
See it on code you already know
We scored six well-known open-source repos with the same read-only pipeline. The most indebted one has almost no AI-written code — comprehension debt tracks how deeply humans review, not who wrote it.
Riskiest blind spots in this example
| Path | Score | Authorship | Why it's risky |
|---|---|---|---|
| services/billing/reconcile.ts | 0.06 | Agent-authored | Agent-authored, merged with 0 review comments. Touches payments. |
| services/billing/invoices.ts | 0.14 | Agent-authored | One-line approval, no discussion. |
| services/sync/engine.ts | 0.15 | Agent-authored | 2,000-line agent PR, approved in 4 minutes. |
| services/billing/tax.ts | 0.16 | Agent-authored | Single reviewer, skimmed. |
| services/sync/conflict.ts | 0.22 | Agent-authored | Only reviewer left the team in March. |
A score you can take apart
Comprehension is scored 0–1 per file, deterministically, from four visible factors. No black boxes: the same history always produces the same score, and every number decomposes on hover. A file below 0.30 is a blind spot — code no human on your team has recently written, reviewed, or explained.
Human review depth
weight 0.40Priced on what a review said, not on how many times someone typed. A paragraph of review is one unit; each inline thread comment is one unit; a review that blocked the merge is at least one unit whatever its length. Four units is full credit, so “lgtm” is worth about a fiftieth of one and a silent approval is worth zero.
Human author recency
weight 0.25When a human last meaningfully wrote here. Understanding fades slowly at first and steeply later, so recency decays on an eased curve over 180 days: code one person hand-wrote, unreviewed, stays above the line for about two months.
Bus factor
weight 0.25How many distinct humans have had substantive contact with this code. Three is full credit; someone who only prompted an agent here counts as a quarter of a person.
Question answerability
weight 0.10Currently zero on every file, deliberately. It used to come from an engineer’s own rating of their own answer — which made the score’s input the subject’s opinion of itself, worth enough to carry a file across the blind-spot line. We removed it rather than ship it. The weight stays held open, unearned, until an answer can be checked by someone who did not write it, so the highest score any file can currently reach is 0.90.
Measure, then notice
A number nobody acts on is a vanity metric. Fathohm maps the debt, then tells you every week what moved and where the risk concentrated.
Measure
The Map
Every file, sized by how much code it holds and coloured by comprehension score. Hover any cell for the factor breakdown behind its number; switch the colouring to authorship to see what agents wrote. Directories aggregate, so a repo with thousands of files still reads at a glance.
Notice
The weekly digest
Once a week Fathohm files a digest to your dashboard inbox: your top new blind spot, how your debt moved since last week, the three riskiest paths, and the one file worth picking up next. Trends chart those same snapshots over time.
Debt you can actually pay down
Measuring comprehension debt is the easy half. The hard half is that the only thing which genuinely reduces it is a person understanding the code. So the paydown loop is built around a human answering questions — not a tool making a number go down.
Step 1
Pick a file
Your work queue ranks every blind file worst-first — highest churn, then size — so you're never guessing where to start. The weekly digest picks out the single one worth doing next.
Step 2
Read the briefing
Fathohm generates a module briefing from your source, read transiently and never stored. It's the orientation a teammate would have given you, if one still had it.
Step 3
Answer three questions
Write each answer in your own words, then rate how well you could — could, partially, couldn't. Neither moves this file's score, and that is the point: you would be grading your own work. The answer becomes documentation your teammates can read, attributed to you and retractable at any time; the rating is recorded against the day someone who did not write it can check it.
Not every blind spot is worth paying down. Accept the risk with a reason and the file leaves your queue — but the blind-spot number does not bend. Accepted is not understood, and the Map keeps saying so.
Scales with your team
When more than a few people share a codebase, comprehension needs governing as well as measuring.
Comprehension policies
Declare a floor for a critical path — nothing under auth/ may score below 60. Evaluation is deterministic and names the exact files and scores that breached it, never a bare pass or fail.
Decision ledger
Accepted risks, paydown sessions, and policy edits merge into one sorted history of who governed what, when, and why. Exportable.
Ownership mapping
Your CODEOWNERS file, parsed with GitHub's own last-match semantics, so every blind spot shows who owns it.
Roles
Admin, member, viewer. Roles gate actions — accepting a risk, running a session, editing a floor — never what you can see. A viewer reads the same numbers an admin does.
Why this is safe to install
Read-only, always
The GitHub App requests read scopes only. It never writes to your repos, never executes your code, never opens PRs.
Your source is never stored
We ingest commit and review metadata — paths, events, review depth. Source code is read transiently for module summaries and never persisted.
No black-box scores
Every score decomposes into its factors, everywhere it appears. If we can't show you why, we don't show you a number.
Correctable by design
Authorship detection (co-author trailers, agent committer signatures) is published openly, and you can correct any label we get wrong.
Two ways in, and the difference is what git records
Git records every commit’s author and date. It records no reviews at all. So the two surfaces answer two different questions, and neither one is a trimmed-down version of the other.
In your terminal
Answers who has left the building: the share of your code no human has written or prompted in the last 180 days, exactly, from the git history on your disk. Comprehension debt comes back as a range, because git cannot close it.
npx fathohm
No account, no telemetry, nothing added to your project. It reads commit metadata, never your file contents — verify that by running it offline. MIT, on npm.
The hosted Map
The read-only GitHub App reads the review record git does not carry, which is what settles the range into one number. It backfills your history, scores every file, and adds the Map and the weekly digest.
Never writes to your repos, never executes your code, never opens PRs. Free to install; uninstall from GitHub at any time.
Not ready to install?
Tell us how much of your code is agent-written, and we will write when there is a way in that fits your team.