Cited, line by line
Every claim links to the file and line it came from. Hover a citation and read the code yourself.
Documentation from your sources
Documentarian reads your sources, from the codebase to the wikis and help centers around it, writes structured docs where every claim points to where it came from, and updates only what each push changed.
01 · The problem
Code changes every week. The pages describing it stay where they were, and nobody can tell which sentences are still true.
02 · How it works · Reads
It starts with the codebase: every file parsed, symbols and imports mapped, the project type detected. Wikis, help centers and specs are read alongside it, so the docs match what your team already wrote.
How it works · Writes
Sections are chosen for the kind of project, each feature gets its own page, and reference tables, architecture diagrams and sub-sections come with it.
How it works · Checks
Claims carry a citation like auth.ts:42. Hover it and the real source lines appear. Nothing is left uncited.
How it works · Updates
Each push is compared with what Documentarian already knows. The affected sections are rewritten; everything else stays exactly as it was.
Next, edits your team makes stay theirs, and every version of the docs keeps its changelog. Coming
How it works · Answers
Ask a question and get an answer page with the source lines beside it, so you can see why it says what it says.
Next · Agents
Every agent reads the same verified index instead of re-scanning your code, wikis and help center for each user and each task. N users with N agents each would mean N² scans. With Documentarian it is one index, kept current on every push, and a fraction of the token spend.
03 · Why it holds up
What sets it apart from a wiki someone meant to update, or a summary nobody can verify, and what comes next.
Every claim links to the file and line it came from. Hover a citation and read the code yourself.
A push rewrites the sections it affects and leaves the rest untouched. No full regeneration, no churn in review.
An API service gets different sections than a mobile app. Features get their own pages, with tables and diagrams where they help.
Sections link to each other and to the symbols and files they describe, so you can follow an idea through the codebase.
Ask a question and get an answer page with the source lines beside it, so you can see why it says what it says.
Agents query the same cited index over MCP instead of re-reading your sources on every task.
Your team can edit any section, and the edit stays. An update never overwrites it; when the code moves under it, it is flagged for review instead. Every version of the docs is kept and tied to the commit it describes, and each push comes with a readable changelog of what changed in the docs, and why.
04 · Compared honestly
Hand-written docs can be excellent, and a quick summary is fast. Neither keeps itself true.
| Capability | Hand-written docs | Generic AI summary | Documentarian |
|---|---|---|---|
| Stays current on push | When someone remembers | Rerun by hand | Changed sections rewrite |
| Every claim cited | Rarely | No | To the file and line |
| Structured by project type | Depends on the author | One generic shape | Sections per project type |
| Cross-linked | By hand | No | Sections, symbols, files |
| Keeps your team's edits | They are the edits | Overwritten on rerun | Kept, flagged when code moves Coming |
| Versions and changelog | If someone writes one | No | Per commit, with a changelog Coming |
| Answers questions | No | Without sources | With evidence lines |
YesPartlyNo
05 · What your team gets
Connect a repository once. From then on the docs follow the code: every push, every claim, for the people and the agents who rely on them.
Current
Each push is read as it lands. The sections it touched are rewritten; the rest stays as your team approved it.
push → diff → rewrite
Cited
Every claim links to the file and line it came from, so a reviewer checks instead of trusting.
claim → file:line
One index
Your team reads it as pages and asks it questions. Agents query the same index over MCP Coming
people · agents → one index
Onboarding
They read pages written from the code they will work in, with the sources one click away, not from someone's memory of it.
page → source → code
06 · Start
Connect GitHub or GitLab, pick a repository, and get cited documentation that keeps up with every push.