Auto-Generated Tech Docs. Zero Drift.

Etchblok performs deep static analysis, resolves cross-file imports, and builds your call graph — generating tech docs that reflect your actual system, not an LLM’s best guess. When your code changes, your docs follow.

Request Early Access

3 steps. Under a minute.

Install the Etchblok GitHub app. Select your repo. Generate.

Etchblok demo

Etchblok reasons over your codebase to decide which guides your users need. Then writes them.

Overviews, getting started docs, tutorials, how-to guides, architecture explanations, and key concept breakdowns — all generated automatically.

Generated guides — left nav structure

Architecture docs built from your actual dependency graph.

We build a deterministic map of your system first, then generate the architecture docs. Etchblok produces living Mermaid diagrams and narrative guides that track actual system behavior as the system evolves. No tracing call hierarchies manually. No hand-drawn diagrams. No writing syntax in markdown files.

Before: original dependency structure
Architecture diagram — before
›
After: method signature updated
Architecture diagram — after

API references that know what’s actually public.

Most tools document everything they find, including internal methods, private helpers, and deprecated endpoints that were never meant to be public. Etchblok resolves your call graph to determine what’s truly public, traces cross-file inheritance, and generates references that reflect your actual API surface.

API reference with annotations

Other tools document your syntax. Etchblok documents your architecture.

Others
Etchblok
How it understands your code
Generative
Feeds your raw code into an LLM and infers meaning from text — reads your code like a document and writes plausible-sounding output.
Structural
First builds a deterministic map of your system via deep static analysis, cross-file import resolution, and call graphs — then uses that map to ground every generated doc in your actual code structure.
API visibility
Documents what it finds — public, private, deprecated, and internal endpoints treated the same.
Resolves imports and exports to identify your actual public API surface.
When code changes
Reads the diff and generates updates for what visibly changed — but has no structural context. Downstream documentation implications across dependent files are missed because the tool doesn’t know they’re connected.
Re-traces the call graph from the changed node outward — catching downstream documentation surfaces affected by the change, not just the file where the change occurred.
Cross-file dependencies
Each file documented in isolation — dependencies and inherited behavior frequently missed or wrong.
Resolves imports across your entire codebase — dependencies and inherited behavior fully traced.
Output accuracy
Variable. The LLM sees what changed, not the full structural context of why it changed or what depends on it.
High and grounded. The LLM sees your real dependency graph, not just raw text.
Architecture documents
No auto-generated architecture documents. Mermaid diagrams must be manually written by an engineer.
Auto-generates architecture documents with Mermaid diagrams derived directly from your dependency graph. When your underlying logic changes, the diagrams and docs update with it because they’re grounded in a deterministic map of your system.
Hallucination over complex code
Confidence degrades silently — the more complex the codebase, the more the model fills gaps with plausible-sounding fabrication.
Structural analysis scales linearly regardless of codebase size — symbols, signatures, and dependencies are resolved deterministically before any text is generated, eliminating the most dangerous class of hallucinations.

What Etchblok delivers

Zero Drift
When a PR is merged, Etchblok re-traces the call graph from every changed node outward — catching downstream docs that a diff alone would miss. If a change in one file affects documented surfaces across three others, Etchblok finds all three.
Zero-Friction Adoption
When your code changes, Etchblok detects it and generates a doc update for review. The update is created as a PR in the docs branch in your existing GitHub workflow. No new tools. No new processes.
Accuracy Grounded in Structure
Symbols, signatures, imports, and call relationships are extracted from your actual AST before a single word is generated. Every sentence in your docs traces back to a real symbol in your codebase — not an LLM’s inference from raw text.
Full Editorial Control
After generation, edit in GitHub or in our built-in editor — your choice. Review, refine, and publish.

Currently supports Python and JavaScript / TypeScript codebases. More languages coming.

Ship fast. Document accurately.

Request Early Access