There is an important distinction that gets
lost in how AI documentation tools market themselves.
AI-assisted documentation: the engineer still writes.
The AI helps format, suggests improvements, fills gaps.
Human still required at the point of creation.
Auto-generated documentation: the engineer writes nothing.
The AI reads the codebase and produces documentation
from what is actually there. Human removed from
the creation step entirely.
These are not the same product solving the same problem.
Why the distinction matters.
AI-assisted documentation is a better tool
for the engineer who was going to write docs anyway.
The problem is that engineer is rare. Most engineers
are not writing documentation because they lack
a good writing tool. They are not writing it because
they do not have time and features always win.
An AI writing assistant does not change that calculus.
The engineer still has to decide to stop and write.
They still have to find the time. They still have
to maintain what they wrote as the code changes.
Auto-generation changes the calculus completely.
The documentation exists because the code exists.
Not because someone decided to write it. Not because
a sprint was dedicated to it. Not because the engineer
had an unusually slow week.
What this looks like technically.
The system reads the repository structure, source files,
existing comments, configuration files, and dependency
manifests. It generates structured documentation with
headings, descriptions, and cross-references.
The critical piece that most implementations miss:
output validation.
AI models hallucinate. They will confidently describe
a function that does not exist or an endpoint that
was removed six months ago. Before surfacing any
generated documentation, the output needs to be
checked against the actual repository structure.
Sections that reference non-existent files or
functions should be flagged or removed, not displayed
as fact. Uncertainty should be explicit, not papered
over with plausible-sounding text.
This is what separates documentation that engineers
actually trust from documentation that creates
false confidence.
Natural language Q&A as the complement.
Documentation generation solves the creation problem.
Q&A solves the retrieval problem.
Static documentation captures what was true when
it was generated. Codebases move faster than any
documentation system can keep up with.
A Q&A layer that reads the actual source files
and answers questions from what is currently there
gives teams access to current information regardless
of when documentation was last generated.
The combination — auto-generated docs plus
live codebase Q&A — is what makes the knowledge
actually accessible rather than just stored.
This is the approach behind git11.
Auto-generation with output validation. Natural
language Q&A from actual source files. Org-wide
access control. Audit logs. API access.
Read-only GitHub App. Nothing stored permanently.
Free at git11.xyz
What has been your experience with AI documentation
tools on a real production codebase?
- Om Yaduvanshi
