ONE MODEL OF THE WHOLE SYSTEM
Screens on one side, tables on the other
Every screen your users see, every table your data lives in, and everything a request passes through in between — frontend services, API routes, backend services, databases — joined into one model. Drag to turn it; point at anything to light the chains that run through it.
THE REPORT
Twelve tabs, one map of the system
Each tab answers a different question about the same model. This is the real report for RealWorld’s Conduit — a React frontend and an Express/Prisma backend — exactly as ClarifyDoc generated it. Pick a tab.
What screens exist, what’s on them, and what runs when someone clicks?
Every page and component with its route, the elements on it, and the handler each event calls.
Who calls this, what does it call — and which table does it end up touching?
Any function as a double tree — callers left, callees right — across the HTTP boundary and through dependency injection, down to the tables it touches.
How is the system put together — from services down to file imports?
C4 drill-down from containers to components to files, plus a type graph, a coupling matrix and a code-to-datastore view.
What does the schema look like, and which code reads or writes each table?
The ER diagram recovered from ORM code and SQL, with every function that reads or writes each entity.
Which endpoints exist, who may call them, and with what payload?
Every endpoint with its auth, API versions and request body — matched to the frontend calls that use it.
Which endpoints and screens end up writing to which tables?
From each endpoint and screen to the database writes, reads and API calls it ends up making.
How healthy is the codebase, why — and what should we fix first?
An A–F grade with the penalties behind it, ranked suggestions, security findings, cycles and dead code.
If I change this file, what breaks?
What a change to a file reaches — dependents, screens, routes and tables — with a plain-language verdict.
Where is the hardest code to maintain — and is it also what changes most?
Complexity per file and function; with git history, the churn × complexity hotspots.
What’s structurally odd that nobody thought to ask about?
God nodes, surprising connections, and how much of the graph was extracted versus inferred.
What do we depend on — and is it actually used?
Every declared package across ecosystems, and whether the code actually imports it.
What is this codebase, at a glance?
The headline numbers, sub-projects, frameworks and trace confidence on one page.
Every tab is explained in the product tour — or open a live report and click around yourself. Looking for a code visualiser? Here is every diagram it draws.
ONE MAP, EVERY ROLE
Built for your whole team
The same deterministic model, framed for the questions each person actually asks. Start where you sit.
Ship in unfamiliar code, without the archaeology
Stop grepping. Follow the code the way it actually runs.
- Trace any click down to the table it writes
- Blast radius before you touch a thing
- Feed real structure to your AI assistant
Diagrams that regenerate instead of rot
A living model of the system, assembled from the code itself.
- C4 drill-down from the real link graph
- Deployment topology from your compose files
- One ER model across every repo and tier
See the asset you can't currently see
Turn a critical, opaque codebase into something you can reason about.
- De-risk rebuilds and modernization
- Cut onboarding from weeks to days
- 100% local — code never leaves the building
The problem: most software teams are flying blind
The documentation is outdated, the diagrams were drawn three rewrites ago, and the only complete description of how the system actually works is the code itself — spread across repos, languages and tiers, readable only by the few people who wrote it.
- Your software is a critical asset — with no unified picture of it
- Nobody can say which screen calls which endpoint, or which table it writes to
- Documentation goes stale the day after it is written
- Knowledge lives in a handful of developers’ heads
- Scoping changes and rebuilds is guesswork
- AI coding assistants guess at an architecture they can’t see
- Modernization decisions rest on uncertainty
Why teams use ClarifyDoc
The source code is already the one complete, current description of your system. ClarifyDoc makes it readable to everyone who needs it — without asking anyone to write documentation.
Answers that cross every boundary
Which screen calls this endpoint, and which table does it write? ClarifyDoc follows the chain from click to handler, HTTP call, route, service and table — through dependency injection, across languages and across repos.
Facts you can check
Everything comes from parsing the code, so the same commit always gives the same map. Each link says whether it was extracted, inferred or ambiguous, and points at a file and line.
Changes without surprises
Blast radius shows what a file change reaches — screens, routes, tables. The impact view turns your uncommitted diff into the screens, routes and tests to check before you open the pull request.
An AI agent that stops guessing
The extension’s built-in MCP server — set up for Claude Code, Cursor, Windsurf, Codex or Gemini CLI in one command, skills and hooks included, and ready in Copilot with none — lets your agent ask for routes, traces, the data model and the impact of a diff — and get answers with path:line references, for a fraction of the tokens. How it works →
Documentation that can’t go stale
Re-runs only re-read files whose content changed. Analyze on save in VS Code, or re-run from the command line in CI — the map keeps up with the code instead of being redrawn by hand.
Legacy and modern, in one picture
A Delphi client, a .NET service and a React frontend become one graph. 50+ languages, from TypeScript and Go to Delphi forms, VB6, Fortran and PowerShell.
Calls to endpoints that no longer exist
A frontend call that no backend route answers is flagged at the call, in the editor’s Problems panel, with a quick fix to the route that does exist — before it ships as a 404.
Review what your AI agent changed
The Impact view turns a diff into the routes, screens, tables and tests it reaches. Compare API Surface lists what the branch changes in the API itself: a route removed, a guard lost, a body that now requires a field.
A gate that fails only on what a PR introduces
In GitHub Actions or GitLab CI, a pull request gets one comment with the API changes and the findings it adds, SARIF in code scanning, and a red check only for what it broke — never for the debt it inherited.
HOW IT WORKS
From complex code to a clear map
One scan reads your codebase — a monolith or a whole folder of repos — and turns it into a model you can browse, search and hand to others.
Point it at your code
A repo, a folder of repos or a git URL. ClarifyDoc detects languages, frameworks and project markers, so a Delphi client next to a .NET service next to a React frontend becomes one system.
Deterministic extraction
Tree-sitter parsing and convention passes pull out routes, functions, calls, ORM entities, screens and interactive elements. Every file is content-hashed, so results are reproducible.
The graph links up
Calls are joined to their definitions — through dependency injection and across the HTTP boundary — into screen → API → database chains. In VS Code, the language servers you already have resolve what text alone can’t — no Docker.
Explore — and stay current
Open the report in VS Code or any browser. Re-runs only re-read the files that changed, so the map keeps up with the code.
FASTER THAN READING THE CODE BY HAND
A detailed map in minutes, not months
Precision joining frontend calls to backend routes (recall 0.966), scored against labels written by hand on real repositories at pinned commits.
Pure static analysis: same input, same output. Nothing invented, nothing hallucinated.
Tree-sitter parsing plus convention passes — TypeScript to Delphi, Go to Fortran, SQL to OpenAPI and Protocol Buffers.
Every file versioned by content hash — you can tell exactly what changed between runs.
50+ languages, mixed freely
One workspace can hold all of them, along with the templates, schemas, API contracts and deployment files around them. Routes come from Express, NestJS, Next.js, Remix, tRPC, gRPC, GraphQL resolvers, ASP.NET, Spring, Javalin, Django, FastAPI, Flask, Laravel, Rails, Gin, Actix, Axum, serverless functions and more; screens from React Router, TanStack Router, Expo Router, React Navigation, Jetpack Compose and SwiftUI; tables from EF Core, Hibernate, MyBatis, TypeORM, Sequelize, Mongoose, Prisma, Drizzle, SQLAlchemy, Eloquent, ActiveRecord, GORM, Diesel, migration chains and plain SQL.
An in-house HTTP client, route registrar or database helper? A few lines of
.clarifydoc/config.json say what it means, and its calls link like any framework’s.
Security: your source code stays yours
ClarifyDoc runs where your code already is — your laptop, your editor or your CI. Nothing is uploaded, and nothing is sent to a model.
- Runs 100% locally — no account, no telemetry
- No AI in the extraction pipeline, so nothing is used to train models
- Reads your files and never modifies them
- Deeper call resolution uses the language servers already in your editor — no Docker needed
- The report is one self-contained file: open it with the network off
- Open source under the MIT license — audit the extractors yourself
Every network request any part of ClarifyDoc can make, what starts it and what it sends: What leaves your machine →
GET STARTED
Interested in unlocking the truth behind your source code?
Pick whichever fits how you work. All three run the same analysis.
In VS Code
Install the ClarifyDoc extension and run ClarifyDoc: Analyze Workspace. The report opens beside your code, and CodeLens, hovers and the Problems panel fill in. No Node.js install, no configuration.
code --install-extension ClarifyDoc.clarifydoc-vscodeBest for developers · Open in VS Code · Cursor, Windsurf, VSCodium: Open VSX
From the command line
For scripts and CI: one command writes the JSON and a self-contained report you can send to anyone. Install it from npm with npm install -g clarifydoc, or run it with npx and install nothing.
npx clarifydoc analyze ./my-app --htmlBest for scripts and sharing · every command
On every pull request
The GitHub Action analyzes the base once, then only what the PR changed. It comments the API changes and new findings, uploads SARIF, and fails only on what you choose. GitLab CI has the same in its Code Quality widget.
uses: clarifydoc/cli@mainBest for teams · the full workflow
Removing it again
ClarifyDoc writes only where you ask it to, and nothing outside the project except the extension itself and, if you set one up, an agent’s MCP entry. To remove everything:
- The extension: Uninstall in the Extensions view, or
code --uninstall-extension ClarifyDoc.clarifydoc-vscode. Its launcher lives in the extension’s own storage. - The analysis: delete the
.clarifydoc/folder in each project you analyzed. Nothing else was written into the project unless you asked. - Agent setup, if you ran it: the
clarifydocentry in that agent’s MCP config (claude mcp remove clarifydocfor Claude Code), the.claude/skills/clarifydoc-*folders, the ClarifyDoc hooks in.claude/settings.json, and the block between<!-- clarifydoc:start -->and<!-- clarifydoc:end -->inAGENTS.md. - Git hooks, if you added them: the lines between
# clarifydoc:startand# clarifydoc:endin.git/hooks/post-commit,post-mergeandpost-checkout.
There is no account to close and nothing stored anywhere else.