How AI agents audit a SaaS product to write its documentation

The phrase "AI writes your docs" is the kind of thing that sounds obvious until you ask how. Here is the actual flow Knowlistic's agent runs to produce living documentation — from the moment you hand it a demo account to the moment a Mintlify-ready Markdown bundle lands in your repo.

Setup: a sandboxed demo account

Everything starts with a demo account that you control. You create a sandboxed user inside your product — preferably one that can sign up, configure, and run workflows without touching production data — and hand the credentials to Knowlistic. The agent only ever logs into this account. It never touches production systems.

Why an account, not an API key? Because the goal is to document what users see, not what the API returns. The agent has to live the user experience to describe it.

Step 1: Recon

Before any audit runs, the agent does a fast recon pass. It crawls the public marketing site, the docs site if one exists, the auth flow, and the first few screens after sign-in. The output is an estimate: how many pages it will visit, how many tokens it will spend, what jobs-to-be-done it expects to find. You see this estimate before you commit to a full audit.

Step 2: The audit run

The full audit is where the work happens. The agent:

1. Signs up (or signs in) using the demo credentials.
2. Walks the onboarding flow end to end.
3. Identifies the product's main jobs-to-be-done and runs each one — creating a project, inviting a teammate, configuring an integration, exporting a report.
4. Captures structured observations at every step: copy, button labels, error states, empty states, configuration options, and where the flow branches.
5. Takes screenshots at the right moments — minimal, standard, rich, or interactive, depending on the audit profile you picked.

The agent runs in a real browser, not against a mock. If a button moves, it sees the new button. If a tier renames, it sees the new name. If a flow breaks, it logs the break.

Step 3: Outline and write

Observations become an outline. The outline is a tree of pages — Getting started, Concepts, How-to guides, Reference, Troubleshooting — that follows the structure most SaaS docs converge on. You can edit the outline before the agent writes anything.

Then the agent writes each page. Pages are Markdown, structured for the answer engines — clear definitions in the lede, short paragraphs, FAQ blocks where appropriate, semantic headings. Code samples and screenshots are inlined.

Step 4: Publish or export

You have two choices for what happens next:

• Hosted. The docs publish to your-product.knowlistic.app with a custom domain option. You get a fast reader, search, and analytics out of the box.
• Export. The agent emits Mintlify-ready Markdown that you can drop into your existing repo or sync to any docs platform.

Step 5: The recursive loop

Audit one is the most expensive. Every audit after that is cheaper, faster, and more accurate, because the agent remembers what it found last time. It diffs the new observations against the old, updates only what changed, flags pages that need human review, and skips pages that haven't moved.

Over time, the agent develops a model of your product that improves with every release. That's the part that no static tool can replicate.

Comment-driven learning

Readers can comment on individual sections. Comments feed back into the next audit's plan: if three users flag a step as confusing, the agent rewrites it. The docs get smarter the more people read them.

What you get at the end

• A complete, current docs site for your product.
• Mintlify-ready Markdown export.
• Schema and llms.txt configured so answer engines cite you accurately.
• A weekly (or daily) audit cadence that keeps everything current.
• An audit history so you can see what changed and when.

Living documentation isn't a doc tool. It's a workflow — and the agent is the part that makes it sustainable.