---
title: "doc0: Docs written from your code that stay current as you push"
description: "doc0 maps your GitHub repo into a code knowledge graph and writes a wiki from it that stays current as you push. Query both over MCP from Claude Code, Cursor, Slack, and Linear."
last_updated: "2026-10-16"
canonical_url: "https://www.doc0.dev/"
---

# doc0: Docs written from your code that stay current as you push

> doc0 maps your GitHub repo into a code knowledge graph and writes a wiki from it that stays current as you push. Query both over MCP from Claude Code, Cursor, Slack, and Linear.

Your agents write the code. doc0 gives you the context.

For engineering teams whose codebase lives in one person’s head: doc0 maps your repository, writes its wiki, and rewrites the pages a change touches as you push. Your team and your AI agents ask it from Slack, Linear or the editor.

[Start 3-day trial](https://www.doc0.dev/login) or [Book a demo](https://www.calendar0.app/book/alessandro-a/30min).

## Your codebase shouldn’t live in one person’s head.

Right now, that person is you.

- Onboarding: Every new hire asks you how the system works, one question at a time.
- Changing code: Your agents read raw files and guess what calls what.
- Trusting the docs: The docs you have went stale months ago, so nobody reads them.

And it isn’t just you. Of more than 28,000 professional developers asked by Stack Overflow:

- 30% hit a knowledge silo ten or more times a week.
- 49% often answer questions they’ve already answered.
- 53% say waiting on answers often disrupts their work.

Source: Stack Overflow, 2024 Developer Survey.

You can’t answer every question yourself. You can hand your team and your agents a wiki written from your code.

## From your repository to docs that stay current.

Connect a repo before lunch. Read its wiki after.

1. Connect your repo: Install the doc0 GitHub app on the repositories you choose.
2. doc0 maps your code: The functions, calls and imports it can read, linked only where your code proves it.
3. Your wiki is written: A technical wiki for engineers and a user guide for everyone else.
4. It stays current: As you push, doc0 rewrites the pages a change touches.

## See it on a real codebase.

Open a wiki doc0 wrote from a project you know, and ask it anything.

- [dubinc/dub](https://www.doc0.dev/docs/934e554a-e6a1-476f-bb2f-23e62d86c3fd/technical): The modern link attribution platform.
- [vercel/next.js](https://www.doc0.dev/docs/8f4009b0-65bd-4480-9b00-e201f0914bb3/technical): The React Framework.
- [mem0ai/mem0](https://www.doc0.dev/docs/faa36707-7c28-4f69-a18f-700ff61c704e/technical): The Memory Layer for AI Agents.
- [honojs/hono](https://www.doc0.dev/docs/552ca36e-f67e-41c3-a07a-def9bd9551b0/technical): Web framework built on Web Standards.
- [drizzle-team/drizzle-orm](https://www.doc0.dev/docs/e1b68fed-3c4e-4c95-b2ba-ebf050f78025/technical): A TypeScript ORM for SQL databases.
- [fuma-nama/fumadocs](https://www.doc0.dev/docs/e8872a72-1909-479c-b585-dc74c6e26726/technical): The beautiful & flexible React.js docs framework.

## Understand your app without reading the code.

doc0 reads your repository once and writes down how it works. You read pages, not files.

- Written from your code: A technical wiki for engineers and a user guide for everyone else, from the same repository.
- Current as you push: A change rewrites the pages it touches.
- Cited to the line: In the technical wiki, sections list the files and lines they were written from.
- Yours to edit: Edit any page. Your edits stay when the code changes.
- Diagrams of how it fits: Pages draw the flows and parts they explain.
- Also written from your code: an API reference when it detects endpoints, and a changelog from your merged PRs. You can publish the wiki on your own domain.

## Your docs come from a map of your code, not a guess.

doc0 first maps your repository: the functions, calls and imports in the languages it reads. A call joins the map only when your code proves it.

- Walkthroughs come from the map: A technical page about a flow is handed real call paths from the map and walks you through them, step by step.
- Names checked against your code: The functions and classes a page names are looked up in the map. When too many are missing, the page goes back for a rewrite.
- Quotes copied from your lines: A page quotes your code by pointing at its lines, and doc0 copies them in. Each link opens them at the commit the page was written from.

## Your team asks in Slack and Linear. Your agents ask from the editor.

Both get their answers from the same wiki and map, where the question comes up.

- A Slack bot and a Linear agent answer from the same index (Team plan).
- Every project ships an MCP server, so AI coding agents query the wiki and the code graph directly instead of guessing from raw files: search, page reads, symbol context, impact analysis, path tracing between symbols, open PRs likely to collide, and who knows an area of the code.

## See what a pull request changes before you read the diff.

doc0 turns a pull request into a map of the functions it adds, changes and removes, and the calls between them. It opens from the doc0 check on the pull request. Only the project's team can open it.

## Measured on public code you can check.

How precise the map is, how fast a wiki is written, and how well its claims hold up against the code.

- Calls checked against the TypeScript compiler: 99.9%, of the 8,786 calls doc0 drew in Next.js that the compiler could check, the compiler drew too.
- Time to write Hono’s wiki: 5 min 35 s, 263 files mapped and 48 pages written, in the run the video above shows.
- In a blind test on 10 public repos, more of doc0’s claims held up against the code than DeepWiki’s or Google CodeWiki’s, on all 10. [How we tested](https://github.com/alessandro-afloarei/doc0-benchmarks)

## For AI agents

- MCP endpoint per project: `https://www.doc0.dev/api/mcp/<projectId>/mcp` (Streamable HTTP). Call `doc0_get_minimal_context` first, then search or list pages, then read a page.
- Public projects need no account. For a private project, the client signs in over OAuth the first time it connects.
- Every public wiki has a page index at `https://www.doc0.dev/docs/<projectId>/llms.txt`, and every wiki page has a markdown twin: append `.md` to the page URL or send `Accept: text/markdown`.
- Site index: https://www.doc0.dev/llms.txt. Server card: https://www.doc0.dev/.well-known/mcp.json. OAuth metadata: https://www.doc0.dev/.well-known/oauth-protected-resource. How to authenticate: https://www.doc0.dev/auth.md.
- `npx @alessandro-afloarei/doc0 setup` installs the MCP entry, an always-on rule and a project skill for Claude Code, Cursor, Codex, OpenCode, Gemini CLI or Antigravity; `npx @alessandro-afloarei/doc0 remove` undoes it.

## Pricing

Prices are in EUR. Every plan starts with a 3-day trial.

- Pro: €24 per month billed annually, €30 billed monthly. For one person with private repos.
- Team: €200 per month billed annually, €250 billed monthly. Unlimited members, plus the Slack bot and the Linear agent.

## Connect your repository, and check the wiki it writes.

Connect a repo, spot-check the wiki, then decide. [Start 3-day trial](https://www.doc0.dev/login). Prefer to talk first? [Book a demo](https://www.calendar0.app/book/alessandro-a/30min).

- No copy of your repository: Your repository is cloned, analyzed in memory and deleted. We keep indexed chunks to write and update your docs, encrypted at rest and deleted with your project.
- Never used to train models: Your code is used for inference only, on every plan.
- You choose who sees what: Keep a project private, publish the technical wiki or the user guide on its own, and give each teammate a role.

## Questions before you connect a repo

### Why not just give Claude Code or Cursor my repo directly?

Honestly: on a small, well-organized repo, a bare agent does fine. doc0 earns its keep when the repo outgrows a context window, and the moment anyone besides that one engineer, human or agent, needs the same answers. Agents reading raw files rebuild your codebase's structure from scratch every session, burning tokens and inventing function names when context runs out. doc0 builds the structure once (symbols, call graphs, execution flows) and serves it to every tool over MCP. The same index also answers your PM in Linear and your support team in Slack.

### How is this different from DeepWiki?

DeepWiki gives you a wiki to read. doc0 gives you one to keep: it updates as you push, your edits survive regeneration, and one repo gives you both a technical wiki and a user guide. You also get private repos, team roles, custom domains, and an MCP server your AI tools query directly. In our published benchmark, blind judges scored doc0 ahead of DeepWiki on every one of 10 repos tested. Methodology and raw scores are public.

### How is this different from Mintlify or GitBook?

Mintlify and GitBook are editors: you write the docs, they publish them. doc0 writes the docs from your code, keeps them current as you push, and lets you edit on top. It parses your code into a symbol graph (functions, call chains, API endpoints), so the same source also answers your AI tools over MCP. No MDX files to write, no CI pipeline to maintain.

### Why not just run it locally?

Local code-graph tools re-index on every machine and only help the one engineer running them. doc0 is hosted (no per-machine indexing), always fresh (it auto-updates as you push), and shared (one graph serves Slack, Linear, and every AI tool your team uses). On top of the graph you also get a readable wiki, something a local indexer doesn't produce.

### Does it work with private repositories?

Yes. doc0 connects through a GitHub App. Your repository is cloned, analyzed in memory, and deleted after processing. We don't keep a copy. To write and update your docs we store indexed chunks of your code (encrypted at rest, deleted with your project) plus file hashes for change detection, and your code is never used for training. Private repositories are available on Pro, Team, and Enterprise.

### What happens to my edits when docs regenerate?

Your edits stay. doc0 tracks which source files each page came from, so a push regenerates only the pages your change affects. When a change touches text you edited, doc0 keeps your text and flags the page so you can review the update.

### How do you keep my code safe?

Your code is used for inference only and never to train models, and the AI models that generate your documentation keep no copy of it, on every plan. Sensitive account and project changes are recorded in an audit log, and SOC 2 and ISO 27001 certification is underway. The privacy policy lists every sub-processor and where it processes data.

### How does doc0 work with Claude Code, Cursor, Slack, and Linear?

Every doc0 project has an MCP server. Add it to Claude Code, Cursor, VS Code, Codex or Windsurf from the project's Connect agents page: public docs need no account, and private docs ask you to sign in the first time your client connects. Beyond search, agents get structural tools raw file access can't offer: impact analysis, path tracing between symbols, detection of open PRs likely to collide, and who-knows expertise mapping. The Slack bot and the Linear agent answer from the same index on the Team plan: mention doc0 on any Linear issue, or ask it in any Slack channel.

### How do I make my agent actually use doc0?

Installing an MCP server doesn't mean an agent uses it: left alone, agents drift back to searching raw files. Run npx @alessandro-afloarei/doc0 setup in your repo: it detects Claude Code, Cursor, Codex, OpenCode, Gemini CLI or Antigravity and installs three things per agent: the MCP server entry, an always-on rule that points the agent at your docs first, and a skill with triggers tuned to your project. npx @alessandro-afloarei/doc0 remove undoes exactly that. Public docs need no account; for private docs, copy the command from your project's Connect agents page, and each agent asks you to sign in the first time it connects.

### Does doc0 stop my agent from writing duplicate code?

It makes duplicates findable before they're written. Agents query the knowledge graph over MCP and get the existing implementation with its callers, so "write a new helper" becomes "use the one that exists." doc0 doesn't gate your agent's writes (no tool truthfully claims to), but an agent that sees the codebase's structure stops recreating it.

### What languages and frameworks are supported?

doc0 works with any GitHub repository regardless of language. It parses 14 grammars with tree-sitter (JavaScript, TypeScript, TSX, Python, Java, C, C++, C#, Go, Rust, Kotlin, PHP, Ruby, and Swift) and falls back to file-structure analysis for the rest. It detects endpoints in Express, NestJS, FastAPI, Django, Spring Boot, Rails, and 10+ more frameworks.

### Where does my code get processed?

Your repository is cloned, analyzed in memory, and deleted after processing. We keep file hashes, the indexed chunks we use to write and update your docs, and their embeddings, never a copy of your repository. Your code is never used for training. Generation, search and chat use third-party AI sub-processors; our full sub-processor list, with where each one processes data, is in the privacy policy.

### How much does it cost?

Pro and Team start with a 3-day trial. Pro (€30/mo) covers 500,000 lines of code a month, unlimited public projects, 5 private repos, custom domains, and export. Team (€250/mo) adds unlimited team members, 20 private projects, deep research, plus the Slack bot & Linear agent. Enterprise is priced per organization. Book a call.

### How do you measure documentation quality?

We publish our benchmark: blind LLM judges score doc0-generated wikis against DeepWiki and Google CodeWiki on 10 real repositories. Methodology, corpus, and raw scores are public in the benchmarks repository.

## Sitemap

See the full [sitemap](https://www.doc0.dev/llms.txt) for all pages, and the [public wiki gallery](https://www.doc0.dev/explore).

- [Privacy](https://www.doc0.dev/privacy)
- [Terms](https://www.doc0.dev/terms)