diff --git a/content/docs/api/index.mdx b/content/docs/api/index.mdx
index 664d0a7..7a5e987 100644
--- a/content/docs/api/index.mdx
+++ b/content/docs/api/index.mdx
@@ -1,39 +1,87 @@
---
title: "API"
icon: "Braces"
-description: "How to reach the Stunt Double platform programmatically: the MCP server, the public docs server, versioning and discovery."
+description: "Every way to reach Stunt Double from code or an agent: the MCP server for your workspace, the no-account Index and docs servers, Markdown docs and llms.txt, and the public discovery files."
---
-# Stunt Double API
+# API and agent access
-Stunt Double exposes its platform through a **Model Context Protocol (MCP)**
-server at `https://app.stuntdouble.io/api/mcp` (Streamable HTTP, OAuth 2.1).
-Drive your workspace from Claude, your own agents or any MCP client, without
-writing a bespoke integration.
+Stunt Double has no REST API for workspaces. Code and assistants act on a
+workspace through the **Model Context Protocol (MCP) server**, which covers
+projects, actors, checklists, runs, interviews, automations and feedback. Around it sit a few public, read-only surfaces that
+need no account: an MCP server for the Stunt Double Index, one for the docs,
+and plain-text files that describe the product to agents.
-- **[MCP server](/mcp)**: authentication, scopes and what a connection can reach.
-- **[Connect](/mcp/connect)**: set up Claude, Cursor, ChatGPT and other clients.
-- **[Tools](/mcp/tools)**: every tool, prompt and resource, grouped by what it acts on.
+| Surface | Endpoint | Sign-in |
+| ------------------------------------- | -------------------------------------------------------------- | --------- |
+| Workspace MCP server | `https://app.stuntdouble.io/api/mcp` | OAuth 2.1 |
+| Workspace MCP server, tools on demand | `https://app.stuntdouble.io/api/mcp/dynamic` | OAuth 2.1 |
+| Index MCP server | `https://app.stuntdouble.io/api/mcp/index` | None |
+| Docs MCP server | `https://www.stuntdouble.io/api/docs-mcp` | None |
+| These docs as Markdown | `https://docs.stuntdouble.io/llms.txt` and any page with `.md` | None |
+| Discovery files | `https://www.stuntdouble.io/.well-known/...` | None |
-## Public docs server
+## Your workspace: the MCP server
-Agents that haven't signed in can still connect. A read-only MCP server at
-`https://www.stuntdouble.io/api/docs-mcp` needs no authentication and exposes
-the documentation as resources. It has no tools: to act on a workspace,
-connect to the product server above.
+The workspace server acts as the signed-in person, with OAuth 2.1 in place of
+API keys, and reaches only the workspaces they belong to. Runs are
+asynchronous: a client starts one and polls until it finishes.
+**[Connect](/mcp/connect#endpoints)** compares the full and on-demand
+endpoints, **[MCP server](/mcp)** covers scopes and what a connection can
+reach, and **[Tools](/mcp/tools)** lists every tool, prompt and resource. For a
+walkthrough, see **[Automate Stunt Double from Claude](/tutorials/automate-with-mcp)**.
-## Versioning
+## Read-only servers with no account
-A client negotiates the MCP protocol version at `initialize`. Breaking changes
-ship alongside the old behavior, never in place, and deprecations are announced
-in the [changelog](https://www.stuntdouble.io/changelog) at least 90 days
-before removal.
+- **Index.** `https://app.stuntdouble.io/api/mcp/index` carries the three
+ [Stunt Double Index](/index-ranking) read tools (`get_index_report`,
+ `list_index_sessions` and `search_index_domains`) with no sign-in. See
+ [Index lookups with no account](/mcp/connect#index-lookups-with-no-account).
+- **Docs.** `https://www.stuntdouble.io/api/docs-mcp` exposes llms.txt, the
+ homepage as Markdown, the OpenAPI spec and the MCP manifest as resources.
+ It has no tools: to act on a workspace, connect to the workspace server.
-## Discovery
+## These docs, for agents
-| What | Where |
-| --------------------- | -------------------------------------------------------- |
-| MCP manifest | `https://www.stuntdouble.io/.well-known/mcp.json` |
-| AI Catalog | `https://www.stuntdouble.io/.well-known/ai-catalog.json` |
-| OpenAPI spec | `https://www.stuntdouble.io/openapi.json` |
-| Site index for agents | [`/llms.txt`](/llms.txt) |
+Every page on this site has a Markdown twin. Append `.md` to its URL
+(`https://docs.stuntdouble.io/concepts.md`), or request the page with
+`Accept: text/markdown`.
+
+| File | What it holds |
+| -------------------------------------------------- | ------------------------------------------------ |
+| [`/llms.txt`](https://docs.stuntdouble.io/llms.txt) | An index of every page, linked to its Markdown |
+| [`/llms-full.txt`](https://docs.stuntdouble.io/llms-full.txt) | Every page in one file |
+| [`/.well-known/agents.md`](https://docs.stuntdouble.io/.well-known/agents.md) | When to use these docs and how to act for a user |
+| `/sitemap.xml` | Every page with its last change |
+
+## Discovery files on stuntdouble.io
+
+Agents and MCP directories find Stunt Double through these files on
+`https://www.stuntdouble.io`:
+
+| File | What it holds |
+| --------------------------------------- | --------------------------------------------------------------------------------------------- |
+| `/.well-known/mcp.json` | The MCP server manifest |
+| `/.well-known/ai-catalog.json` | A catalog of Stunt Double's MCP servers |
+| `/.well-known/oauth-protected-resource` | OAuth metadata for the MCP server: its authorization server and scopes |
+| `/.well-known/agent-skills/index.json` | The Agent Skills Stunt Double publishes |
+| `/openapi.json` | An OpenAPI 3.1 description of the public endpoints, with the MCP server as a single operation |
+| `/llms.txt` | What Stunt Double is, for agents |
+
+The Stunt Double Index publishes its own at `https://index.stuntdouble.io`:
+`/llms.txt`, an MCP server card at `/.well-known/mcp/server-card.json`, each
+domain's findings as a prompt for a coding agent at
+`/d/{domain}/fix-prompt.md`, and the score badge at `/badge/{domain}.svg`.
+
+## Versioning and limits
+
+- **MCP.** A client negotiates the protocol version at `initialize` and sends
+ it back in the `MCP-Protocol-Version` header.
+- **Public endpoints.** The OpenAPI spec follows semantic versioning. A
+ breaking change ships under a new path or header value alongside the old
+ one, never in place, and a deprecation is announced in the
+ [changelog](https://www.stuntdouble.io/changelog) at least 90 days before
+ removal.
+- **Rate limits.** Uncached public endpoints on stuntdouble.io allow 120
+ requests a minute per client, and say so in `RateLimit` and
+ `RateLimit-Policy` headers. A refused request gets a 429 with `Retry-After`.
diff --git a/content/docs/concepts/index.mdx b/content/docs/concepts/index.mdx
index 3f05f81..b79b53a 100644
--- a/content/docs/concepts/index.mdx
+++ b/content/docs/concepts/index.mdx
@@ -1,146 +1,146 @@
---
title: "Concepts"
icon: "compass"
-description: "Actors, checklists, interviews, workflows, and insights: the building blocks of Stunt Double and how they relate."
+description: "Short definitions of Stunt Double's building blocks (workspaces, actors, checklists, interviews, automations, issues and more) and how they relate, with a link to the page that goes deeper on each."
---
# Core concepts
Stunt Double is organized around a small number of building blocks. This page
-explains each one and how they fit together.
+defines each one and how it relates to the others. For how to use them, follow
+the link at the end of each section.
-| Term | In one line |
-| --- | --- |
-| Workspace | Your team: members, billing and every project |
-| Project | One product or surface, and everything that tests it |
-| Actor | An AI user with instructions and knowledge that drives a real browser |
-| Checklist | Plain-language checks an actor verifies, each with evidence |
-| Interview | A structured study run with persona participants, ending in a report |
-| Live session | An actor using your product in real time while you watch and steer it |
-| Automation | A graph of steps that runs checklists on a schedule or an event |
-| Comment | A pin a real visitor drops on your page through the feedback widget |
-| Insight | A notable observation surfaced from a run |
+| Term | In one line |
+| ------------ | ------------------------------------------------------------------------------------ |
+| Workspace | Your team: members, billing and every project |
+| Project | One product or surface, and everything that tests it |
+| Actor | An AI user with instructions and knowledge that drives a real browser |
+| Checklist | Plain-language checks an actor verifies, each with evidence |
+| Interview | A structured study run with persona participants, ending in a report |
+| Live session | An actor using your product in real time while you watch and steer it (early access) |
+| Automation | A graph of steps that runs checklists on a schedule or an event |
+| Comment | A pin a real visitor drops on your page through the feedback widget |
+| Issue | A problem a run, review or comment found, tracked until it is fixed |
+| Goal | What a project is trying to achieve, with the evidence linked to it |
+| Idea | A recommendation your actors write after exploring the product together |
+| Topology | A map of your product's screens and the paths between them |
+| Device | A Mac in your workspace that runs work against sites inside your network |
## Workspaces and projects
A **workspace** is the top-level container for your team. It owns members,
-billing, and every project. A **project** sits inside a workspace and groups the
-actors, checklists, and runs for one product or surface. Teams working on
-several products keep them separated by using a project per product.
+billing and every project. A **project** sits inside a workspace and groups the
+actors, checklists, interviews and runs for one product or surface, so a team
+with several products keeps them apart. A project's overview leads with its
+latest run, anything running now and what changed since your last visit.
## Actors
-An **actor** is an AI assistant you create. It is defined by its instructions
-and its knowledge:
+An **actor** is an AI user you create, named by the role it stands in for
+("Busy shop owner"), never as a person. Three things define it:
-- **Instructions** describe the actor's role and how it should behave.
-- **Knowledge** is the reference material the actor can draw on, such as facts
- about your product or test credentials.
+- **Instructions**: who it is and how it behaves, written to the actor.
+- **Personality**: how skeptical, how technically literate and how quickly
+ frustrated it is, set on sliders and applied everywhere it works.
+- **Knowledge**: what it can look up mid-run (expertise, processes, reference
+ facts and test accounts), opened only when a task needs it.
-Under the hood, an actor drives a real browser and works through your product
-the way a person would, observing the page, taking an action, observing the
-result, and repeating until the task is done. It can also read email sent to
-its own inbox, which is what makes signup and verification flows testable.
-Actor inboxes, and actors that stay signed in between runs, come with the
-Startup plan and above.
+An actor drives a real browser and works through your product the way a
+person would: observe the page, act, observe the result, repeat. On the
+Startup plan and above it also gets an inbox of its own for sign-up and
+verification emails. See
+**[Build an actor that behaves like your audience](/tutorials/first-actor)**.
## Checklists
-A **checklist** is an automated verification workflow. You describe the steps you
-want checked in plain language, and an actor runs through them in a hosted
-browser. Each step is reported as passed or failed, with a screenshot and a
-short explanation.
-
-
-
-Checklists are the fastest way to catch regressions in flows that are tedious to
-test by hand, such as signup, checkout, or onboarding.
+A **checklist** is a set of checks written in plain language, each describing
+an outcome that should be true. An actor runs through them in a browser and
+reports each one as passed or failed, with a screenshot and a short
+explanation. A check can block the run, add to a score or just record what the
+actor saw. Checklists are the fastest way to catch regressions in flows that
+are tedious to test by hand, such as sign-up, checkout or onboarding. See
+**[Write checklists that catch real regressions](/tutorials/effective-checklists)**.
## Interviews
-An **interview** is a structured conversation Stunt Double runs with your users.
-You define sections and questions, the platform conducts the interview, and it
-produces a report summarizing what it learned. Interviews are useful for user
-research and feedback gathering at a scale that manual interviews cannot reach.
+An **interview** is a structured study run with persona participants: your
+actors, or personas generated for the study. You write a guide of questions
+and tasks, each participant works through your product and answers in
+character, and every round ends in a report of themes, quotes, the screens
+behind them and a usability score. See
+**[Run a user interview](/tutorials/running-an-interview)**.
## Live sessions
-A **live session** puts you beside an actor while it works: the browser on one
-side, the chat on the other, and the steps it takes underneath. Give it a task
-or interview it in character, change direction mid-task, or take the browser
-and drive it yourself. Sessions run in a cloud browser or, from the desktop
-app, in a browser on your own Mac. See
+A **live session** puts you beside an actor while it works, so you can steer
+it, interview it in character or take over the browser. Live sessions are in
+early access and switched on per workspace. See
**[Run a live session](/tutorials/live-sessions)**.
## Workflows
-A **workflow** (an **automation** in the dashboard) chains steps into a single repeatable automation. Where a
-checklist verifies a flow, a workflow is meant to get something done end to end,
-and can combine several actions into one run.
+A **workflow**, called an **automation** in the dashboard, is a graph of steps
+started by a trigger. Where a checklist verifies one flow, an automation
+decides when checklists run and what happens with the result: post a comment
+on a pull request, notify a channel, branch on a condition. See
+**[Automate multi-step workflows](/tutorials/building-workflows)**.
## Comments and the feedback widget
-Actors report what an AI persona experienced. **Comments** cover the other half:
-what a real visitor experienced. The **feedback widget** is a small script you
-add to your own site, letting visitors drop a pin anywhere on a page and leave a
-comment in the place it applies to.
+Actors report what an AI persona experienced. **Comments** cover the other
+half: what a real visitor experienced. The **feedback widget** is a small
+script you add to your own site, so visitors can drop a pin anywhere on a page
+and leave a comment where it applies. Each comment arrives with a screenshot,
+the page and device details, and only domains you approve can send them. See
+**[Collect stakeholder feedback on a prototype](/tutorials/feedback-widget)**
+and the **[feedback widget reference](/integrations/feedback-widget)**.
-Each comment arrives with a screenshot, the page URL, the pin position, and
-device details, and lands in the project's Comments view grouped by page. From
-there you reply in the thread and move each one through **new**, **reviewed**,
-**resolved**, or **dismissed**.
+## Issues, goals and ideas [#insights]
-
- The widget is identified by a per-project API key that lives in your page source, so the real
- access control is the **domain allowlist** on the project: the widget API only answers requests
- from domains you have approved. Workspace admins can narrow that further, or switch the widget off
- across the whole workspace, from Settings → Security.
-
+**Issues** are the problems a project needs to fix. Failed checks, open design
+review notes and new comments show up on the project's **Issues** page on
+their own, each linked to its evidence, and become tracked issues in a click.
+See **[Review runs and act on them](/tutorials/reviewing-runs)**.
-See **[Collect stakeholder feedback on a prototype](/tutorials/feedback-widget)**
-for installation and triage.
+**Goals** say what a project is trying to achieve, such as "New visitors finish
+sign-up without help". Link feedback and ideas to the goal they support, so the
+evidence for each goal sits in one place.
-## Insights
+**Ideas** come from a co-create session: say what you want to learn and pick
+the actors, and each explores the product before they turn what they found into
+ideas and recommendations. Problems they find become issues.
-As actors work, Stunt Double surfaces **insights**: notable observations drawn
-from a run, such as a confusing step, a broken link, or an unexpected result.
-Insights turn raw session recordings into something you can act on without
-watching every replay.
+## Topology
-## Issues and goals
+A **topology** is a map of your product: its screens, the paths between them
+and what changed since the last version. An actor crawls the site to draw it,
+and pages that checklist runs and interview participants visit are added as
+you test. Topology is in preview.
-Each project has an **Issues** tab. Problems your runs and reviewers have
-already found appear there on their own: failed checks, open design review
-notes, untriaged comments and insight findings, each linked back to its
-evidence. Turn one into a tracked issue in a click, then move it through open,
-in progress, resolved or dismissed. The highest severity sits at the top.
+## Devices
-**Goals** say what a project is trying to achieve, such as "New visitors finish
-sign-up without help". Link insights and feedback to the goal they support, so
-the evidence for each goal sits in one place. A goal is active until you mark
-it completed or archive it.
+A **device** is a Mac in your workspace running the desktop app, on any paid
+plan. On the Startup plan and above, runs against a site only reachable inside your network
+go through a device, using that Mac's network and sign-ins. See
+**[Devices](/integrations/self-hosted-workers)**.
## Recordings and replays
Everything an actor does is recorded. For any run you can replay the session,
-step through each action, and see the screenshot captured at that moment. This
-is what makes a failed checklist or a surprising interview answer easy to
+step through each action and see the screenshot captured at that moment, which
+is what makes a failed check or a surprising interview answer easy to
diagnose.
## Next steps
-Ready to automate this? See the **[API overview](/api)** and the
-**[MCP server](/mcp)**, and connect the tools your team already uses from
-**[Integrations](/integrations)**.
+To drive any of this from code or an assistant, see **[API and agent
+access](/api)** and the **[MCP server](/mcp)**. To connect the tools your team
+already uses, see **[Integrations](/integrations)**.
diff --git a/content/docs/getting-started/index.mdx b/content/docs/getting-started/index.mdx
index b6c5709..decde44 100644
--- a/content/docs/getting-started/index.mdx
+++ b/content/docs/getting-started/index.mdx
@@ -1,12 +1,14 @@
---
title: "Quickstart"
icon: "rocket"
-description: "Create a workspace, add your first actor, and run a checklist against your product in a few minutes."
+description: "The first-run path: create a workspace, give Stunt Double your URL, watch the first checklist run and read its evidence."
---
# Quickstart
-This guide takes you from a new account to your first checklist run.
+This is the one path from a new account to your first run and its evidence.
+Everything it skips (writing actors, tuning checks, interviews) is a tutorial
+of its own, linked at the end.
-### Create a project
+### Tell it what to test
+
+Enter your product's URL. Stunt Double reads the site, writes actors for the
+people who use it and picks the flows worth checking first, as checklists in
+your first **project**. It takes a couple of minutes, and the project also
+gets a first agent readiness score from the
+**[Stunt Double Index](/index-ranking)**.
-Inside the workspace, create a **project** for the product or surface you
-want to test. A project keeps related actors, checklists and runs together, so
-a team with several products keeps them apart.
+No URL yet? Choose **I don't have a URL yet** and describe the product and who
+it is for instead. The checklists wait, and run as soon as you add a URL to the
+project.
-### Create an actor
-
-An **actor** is an AI user that does the work. Open **Actors** in the
-sidebar, choose **Create actor**, and pick a template or start from scratch.
-Then give it:
+### Watch your first run
-- **Instructions** that describe who it is and how it behaves.
-- **Knowledge** it can draw on: facts about your product, test accounts,
- conventions to follow.
-
-Out of the box an actor drives a real browser and reads email sent to its own
-inbox, so it works through your product the way a person would. For a first
-run, a one-paragraph description of your audience is plenty.
-
-
+When setup finishes, choose **Watch your first run**. An actor opens a hosted
+browser and works through the first checklist while you watch. To run any
+other checklist, open it from **Checklists** and press **Run**.
-### Write and run a checklist
-
-In the project, open **Checklists** and choose **Create checklist**. A
-checklist is a set of checks written in plain language, for example:
+### Read the evidence
-1. Open the pricing page.
-2. Confirm the Pro plan shows a monthly and an annual price.
-3. Start sign-up and confirm it reaches the email step.
+Every run is recorded. Open the finished run to see each check's result with
+the screenshot the actor took and its explanation, then replay the session if
+you need more. Failed checks also wait for you on the project's **Issues**
+page.
-Create the checklist, then press **Run** on its page. The actor opens a
-hosted browser and works through each check.
-
-### Review the run
+### Add a check of your own
-Every run is recorded. Open it to replay the session, inspect each check's
-result and screenshot, and see any **insights** the platform surfaced.
+Open **Checklists**, choose **Create checklist** and pick a template or
+**Start from scratch**. Write each check as a plain-language outcome, such as
+"Confirm the Pro plan shows a monthly and an annual price", choose the actor
+and URL, then create the checklist and press **Run**. The actor works out the
+clicks.
+
+ A hosted browser can't reach a site that is only available inside your
+ network. On the Startup plan and above, a Mac in your workspace runs those
+ checks instead. See
+ **[Devices](/integrations/self-hosted-workers)**.
+
+
## Next steps
Claude,
- select **Download .mcpb** and open the file with Claude Desktop (needs
- Node 18 or later).
-- **Claude (web or desktop), manual**: in Claude, open Settings > Connectors >
- Add and paste the URL `https://app.stuntdouble.io/api/mcp`.
-
-See **[Claude](/mcp/clients/claude)** and **[MCP](/mcp)** for more detail.
-
-The first time Claude uses a Stunt Double tool, a browser window opens to sign
-in and authorize. No API keys.
+Add Stunt Double to Claude as a connector, either the one-click Claude Desktop
+extension or the server URL in Claude's connector settings.
+**[Connect a client](/mcp/connect)** has both. The first time Claude uses a
+Stunt Double tool, a browser window opens to sign in and authorize. No API
+keys.
@@ -17,44 +17,16 @@ persona before merge, with results reported where engineers already look.
## Setup
-1. **Connect your coding agent** (plugin preferred, MCP config as a fallback):
+1. **Connect your coding agent.** For Claude Code, the
+ [Stunt Double plugin](/mcp/clients/claude-code-plugin) bundles the MCP
+ server with skills and agents; Cursor has a
+ [plugin](/mcp/clients/cursor) too. Any other MCP-capable agent takes the
+ server URL, as **[Connect a client](/mcp/connect)** describes. You authorize
+ in the browser on first use; no API keys.
- **Claude Code:** install the
- [official Stunt Double plugin](https://claude.ai/customize/plugins/id/9cd49c97-13c2-4844-bc3d-53ef7956c1ef%40anthropic-plugin-directory)
- from Claude's plugin directory (server plus skills and agents), or add the
- server, or install the plugin from the terminal:
-
- ```bash
- claude mcp add --transport http stuntdouble https://app.stuntdouble.io/api/mcp
- ```
-
- ```bash
- claude plugin marketplace add stunt-double/stuntdouble-mcp
- claude plugin install stuntdouble@stuntdouble
- ```
-
- **Cursor:** install the
- [Stunt Double Cursor plugin](https://github.com/stunt-double/stuntdouble-mcp)
- (MCP server plus skills, rules and agents). From the
- [Cursor marketplace](https://cursor.com/marketplace) once listed, or add the
- repo as a team marketplace (Dashboard → Plugins → Team Marketplaces → Add
- Marketplace → Import from Repo), then install `stuntdouble` from Customize.
-
- **MCP only** (Cursor without the plugin, Windsurf, or any other JSON-config
- client):
-
- ```json
- // .cursor/mcp.json or ~/.cursor/mcp.json
- { "mcpServers": { "stuntdouble": { "url": "https://app.stuntdouble.io/api/mcp" } } }
- ```
-
- You authorize via browser on first use; no API keys. **[MCP](/mcp)** has
- setup for more clients.
-
-2. **Connect GitHub** to your workspace (**Integrations** > GitHub >
- **Connect GitHub**, then **Install GitHub App** for the repositories you
- choose) so agents can read PRs and post results, and workflows can trigger
- on GitHub events. See **[GitHub](/integrations/github)**.
+2. **Connect [GitHub](/integrations/github)** for the repositories you work
+ in, so agents can read PRs and post results, and automations can trigger on
+ GitHub events.
3. **Teach your agent the habit.** Add a note to your repo's agent
instructions (`CLAUDE.md`, `.cursorrules`, etc.) so verification happens by
@@ -120,8 +92,8 @@ run.
## Workflow: from bug report to fix without a human repro
-Feedback captured by Stunt Double (pinned to a page, with screenshot and
-device info) is agent-readable:
+Comments people leave through the [feedback widget](/guides/feedback-widget)
+(pinned to an element, with a screenshot and device info) are agent-readable:
> “Triage the new feedback on the dashboard project; reproduce anything that
> looks like a bug.”
diff --git a/content/docs/guides/feedback-widget.mdx b/content/docs/guides/feedback-widget.mdx
index 8635026..9ed4b38 100644
--- a/content/docs/guides/feedback-widget.mdx
+++ b/content/docs/guides/feedback-widget.mdx
@@ -1,7 +1,7 @@
---
title: "Stakeholder feedback"
icon: "feedback"
-description: "Install the feedback widget so visitors pin comments in context, then triage them alongside what your actors find."
+description: "When to put the feedback widget on staging, a beta or production, and how to turn what people pin into checks that run on every deploy."
---
AI personas tell you what a careful, unhurried user would hit. Real visitors
@@ -11,8 +11,9 @@ your own site, and anyone looking at a page can drop a pin on the exact spot
that confused them and say why.
What arrives is not a support ticket with "the page is broken" in it. It is a
-comment anchored to a coordinate, with a screenshot of the page as that person
-saw it, the URL, the viewport, and which version of the page they were on.
+comment attached to the element it is about, with a screenshot of the page as
+that person saw it, the URL, the viewport, and which version of the page they
+were on.
PMs and designers running prototype and staging reviews, founders collecting
@@ -20,43 +21,35 @@ saw it, the URL, the viewport, and which version of the page they were on.
Slack with no idea which page or build they came from.
-## Setup, in about five minutes
+## The pieces, in order
Comments' },
- { label: 'Install', sub: 'One script tag' },
- { label: 'Allow', sub: 'Your domains only' },
+ { label: 'Install', sub: 'One script tag per site' },
+ { label: 'Decide who', sub: 'Domains and sign in' },
+ { label: 'Collect', sub: 'Pins on the real page' },
{ label: 'Triage', sub: 'Reply and resolve' },
+ { label: 'Guard', sub: 'Checks for repeat issues' },
]}
/>
-Enable **Comments** on the project, paste one script tag before `