The traditional workflow asks engineers to maintain two artifacts in parallel: the code and the docs that describe it. This is a coordination problem with a known outcome -- the faster-moving artifact wins, and the slower one rots. Code always moves faster.
The cost is not just stale READMEs. It is compounding. Every AI agent, every MCP client, every developer onboarding to a new codebase inherits the drift. A renamed parameter in the source becomes a hallucinated function call in the agent's output. A removed endpoint becomes a 404 in the tutorial.
The fix is not “write better docs.” The fix is to stop maintaining docs as a separate artifact entirely. Derive them from the source of truth. Verify them against it. Automate the entire loop.
Your AST already contains every function signature, every parameter type, every return value, every class hierarchy, every import relationship. This is not hidden knowledge -- it is structured data that no one has bothered to extract and serve to the tools that need it.
Documint parses your source tree with tree-sitter, extracts the symbol graph, SHA-256 hashes every node, and packages it as a .mint file. When your code changes, we diff the hashes. When a hash changes, we know exactly which doc sections are now lying. The AI patches them. The loop closes without human intervention.
We parse ASTs, not prose. Every function signature is SHA-256 hashed. When a parameter type changes from string to number, we know which doc paragraphs reference it -- down to the line. Detection is deterministic and runs in <2ms per symbol.
Agent context files -- CLAUDE.md, AGENTS.md, llms.txt, .mint -- are generated from the symbol table. Not written by hand. Not copy-pasted from a README. If the symbol table changes, the context files change with it.
`documint ci` runs in your GitHub Actions pipeline. Every push, every PR. If docs have drifted, the check fails and a patch PR is opened automatically. No quarterly doc audits. No "someone should update this" Slack messages.
The .mint file is the foundation. What follows is a connected graph where every API surface in every language is understood by every agent that needs it. Here is what we are building, honestly scoped.
A shared .mint registry. Publish your API's symbol graph. Any team, any agent, any MCP client can pull typed context for your library. Versioned, always current, no manual uploads.
When a dependency updates its API, detect drift in every downstream project that depends on the changed symbols. Cascade detection across the dependency graph, not just within a single repo.
TypeScript and Python are fully supported today. Rust, Go, Java, C++, Swift, and Kotlin are in progress. The target is every language tree-sitter supports -- which is most of them.
Documint speaks the Model Context Protocol natively. Any MCP client -- Claude, Cursor, Windsurf, VS Code, or your own tooling -- can request live, AST-grounded context for any project that publishes a .mint file. No custom integrations. No API wrappers. Just the protocol.
Documint is built by a solo engineer who spent too many hours updating docs that were already wrong by the time the PR merged. One person, one problem: make documentation a derived artifact, not a maintenance burden.