Choose How to Start Your Documentation
After you create a workspace, Hyperdocs gives you three ways to populate it with documentation. Each path leads into the same block editor, so you can switch approaches or combine them later. The choice you make here determines how your first content arrives — not what you can do afterward.
The Three Starting Options
When your workspace is ready, you will see three options for getting documentation into it:
•Template Docs — open the block editor with a pre-built starter structure you can edit immediately.
•Import existing Docs — paste the URL of a live documentation site and Hyperdocs fetches, converts, and saves the pages for you.
•Generate from GitHub — connect your GitHub account, pick a repository and branch, and Hyperdocs generates a first draft of documentation from your codebase.
Option | Best For | What You Get |
|---|
Template Docs | Writers who want to author content manually | A pre-built set of pages ready to edit in the block editor |
Import Docs | Teams migrating existing documentation | A planned path to bring in content you already have |
Generate from GitHub | Dev teams who want docs generated from code | Auto-drafted documentation based on repository commits |
Option 1: Start with Template Docs
Choosing Template Docs opens the documentation editor with a ready-made page structure. No setup is required — you land directly in the block editor and can start writing, renaming pages, and organizing folders right away.
This option is best when you want to write documentation by hand from scratch, or when you do not yet have an existing site to import or a GitHub repository to connect.
•Select Template Docs from the starting options screen.
•The editor opens with a starter page tree. Click any page to begin editing its content.
•Add new pages and folders, rename items, and arrange the navigation tree to match your documentation structure.
•When you are ready, publish your changes to make the documentation live on your site.
Option 2: Import Existing Documentation
The Import existing Docs option lets you bring in documentation from a live website by entering its URL. Hyperdocs detects the platform, discovers all pages, converts them to the block editor format, and saves the full tree to your workspace — without you copying and pasting anything manually.
Supported source platforms include GitBook and Mintlify. Hyperdocs fingerprints the site automatically, so you do not need to specify the platform yourself.
How the Import Works
The import runs as a live streaming job with three stages you can watch in real time:
•Detecting platform — Hyperdocs reads the site's HTML to identify whether it is a GitBook, Mintlify, or other supported source.
•Importing pages — each page is fetched and converted. A counter shows how many pages have been fetched out of the total discovered (for example, `3 / 12`).
•Saving to your workspace — the converted page tree is persisted to your workspace as editable draft documentation.
Once the import completes, you are redirected to the documentation editor where all imported pages are ready to review, edit, and publish. A prompt also appears suggesting you run a Docs Audit to compare the imported content against your codebase.
Steps to Import Documentation
•Select Import existing Docs from the starting options.
•In the Import existing Docs panel, enter the full URL of your existing documentation site in the URL field — for example, `https://docs.example.com`.
•Click Import Documentation to start the job. The button is disabled until a valid URL is entered.
•Watch the progress panel as it moves through the three stages. You will see the detected platform badge, a progress bar, and a live page counter.
•When the import finishes, you are taken to the editor. Review your imported pages, make any edits, and publish when ready.
If the Import Fails
If the import cannot complete, an Import Failed screen appears with an error detail and a list of things to check:
•Confirm the URL points to a publicly accessible documentation site — login-gated sites cannot be crawled.
•JavaScript-rendered single-page applications may not be fully crawlable.
•Click Try again with a different URL to return to the URL input and try a corrected address.
Replacing Existing Documentation
If your workspace already has documentation — either generated from GitHub or from a previous import — a confirmation dialog appears before the import starts. The dialog warns that the existing documentation will be replaced. Click Import Docs to proceed, or Cancel to keep the current content.
Option 3: Generate Documentation from GitHub
The Generate from GitHub option connects your GitHub account, lets you pick a repository and branch, and then runs a generation job that produces a structured first draft of documentation from your codebase. The generated pages land in the block editor as editable drafts — nothing is published automatically.
Connection Flow
The GitHub connection follows a step-by-step flow. Each step is shown in sequence:
•Connect GitHub account — click Connect Frontend Repository to open the GitHub App authorization flow in a new tab. Hyperdocs requests read-only access to your repositories. Your code is processed in memory and discarded after generation — it is never stored.
•Waiting for GitHub — after the tab opens, Hyperdocs polls for the authorization to complete. The screen shows a countdown and three steps to complete in GitHub: authorize the app, select repository access, and finish installation. The connection is detected automatically.
•Reuse an existing account — if you have already installed the Hyperdocs GitHub App on one or more accounts (from another workspace), a list of those accounts appears. Select one to link it to this workspace without going through the install flow again, or click Connect a different GitHub account to install on a new account.
•Select a repository and branch — once the account is linked, a searchable list of your repositories appears. Select the repository you want to generate docs from, then choose the branch to use. Each repository shows its name, visibility (Private badge if applicable), and a branch picker that loads available branches. The default branch is pre-selected.
•Generate Documentation — click Generate Documentation to start the generation job. The button is only active once a repository and branch are selected.
Generation Progress
Once the job starts, a progress screen shows four stages in sequence:
•Job queued — your request has been received and is waiting to start.
•Reading repository — Hyperdocs scans the file tree and parses the code structure from GitHub.
•Writing documentation — code is sent to AI and structured documentation pages are generated.
•Saving documents — the generated pages are persisted to your workspace.
A progress bar and percentage counter update as the job advances. When generation completes, a success confirmation appears and you are redirected to the documentation editor. If the job fails, an error message is shown and you can try again.
Privacy and Repository Access
Hyperdocs connects to GitHub with read-only access. Environment files and secret files are always skipped. Your repository code is processed in memory during generation and discarded immediately afterward — it is never written to disk or stored. Your code is never used to train AI models.
If a Repository Does Not Appear
•If your repository is not in the list, click Manage access on GitHub (shown below the repository list) to open the GitHub App's installation settings and grant access to additional repositories.
•If generation fails with a plan error, your workspace may have reached its generation credit limit. Upgrade your plan to continue.
Comparing the Three Options
All three options lead to the same block editor. The difference is how your initial content arrives:
•Template Docs — best when you are writing documentation from scratch and want a blank structure to fill in.
•Import existing Docs — best when you already have documentation published on a GitBook or Mintlify site and want to bring it into Hyperdocs without manual copying.
•Generate from GitHub — best when you have an active codebase and want a first draft generated automatically, so you start editing rather than writing from a blank page.
You are not locked into your initial choice. After setup, you can connect a GitHub repository from the Git Sync section, import additional content, or write new pages manually at any time.
