Documentarian · cutting the stone000%
Modules

Documentation from your sources

Documentation that cites its source.

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

Docs start drifting the day they are written.

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 reads your sources.

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.

CodebaseWikisHelp centersAPI specs

How it works · Writes

It writes the documentation, not a summary.

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

It checks every claim against its line.

Claims carry a citation like auth.ts:42. Hover it and the real source lines appear. Nothing is left uncited.

How it works · Updates

It updates only what a push changed.

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

It answers with the evidence beside it.

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

Your agents, drawing on one source of truth. Coming

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

Documentation you can check, that stays current.

What sets it apart from a wiki someone meant to update, or a summary nobody can verify, and what comes next.

Cited, line by line

Every claim links to the file and line it came from. Hover a citation and read the code yourself.

Only what changed

A push rewrites the sections it affects and leaves the rest untouched. No full regeneration, no churn in review.

Structured for your kind of project

An API service gets different sections than a mobile app. Features get their own pages, with tables and diagrams where they help.

A graph, not a pile of pages

Sections link to each other and to the symbols and files they describe, so you can follow an idea through the codebase.

Answers with evidence

Ask a question and get an answer page with the source lines beside it, so you can see why it says what it says.

One index for every agent Coming

Agents query the same cited index over MCP instead of re-reading your sources on every task.

Your edits kept, every version explained Coming

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

Three ways to document a codebase.

Hand-written docs can be excellent, and a quick summary is fast. Neither keeps itself true.

CapabilityHand-written docsGeneric AI summaryDocumentarian
Stays current on pushWhen someone remembersRerun by handChanged sections rewrite
Every claim citedRarelyNoTo the file and line
Structured by project typeDepends on the authorOne generic shapeSections per project type
Cross-linkedBy handNoSections, symbols, files
Keeps your team's editsThey are the editsOverwritten on rerunKept, flagged when code moves Coming
Versions and changelogIf someone writes oneNoPer commit, with a changelog Coming
Answers questionsNoWithout sourcesWith evidence lines

YesPartlyNo

05 · What your team gets

Documentation that stays true, as a subscription.

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

Docs that match main

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

A source behind every sentence

Every claim links to the file and line it came from, so a reviewer checks instead of trusting.

claim → file:line

One index

One index for people and agents

Your team reads it as pages and asks it questions. Agents query the same index over MCP Coming

people · agents → one index

Onboarding

New engineers start from the real system

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

Point it at a repository. Read what it finds.

Connect GitHub or GitLab, pick a repository, and get cited documentation that keeps up with every push.