Someone clicked around the page and left ten comments. There are two ways to get those comments to an agent that can act on them: as a file, or over MCP.
| JSON export | MCP server | |
|---|---|---|
| How the agent gets it | You download a file and point the agent at it | The agent calls a tool with the share link |
| Per-comment detail | CSS selector, the element, computed styles, the CSS rules that matched, the ancestor chain | CSS selector, the comment text, its status and replies |
| Needs the extension | Yes — the export is produced in the browser | No — the server answers from the stored review |
| Works for comments someone else left |
Yes, if you open their review link and export from it | Yes — their link is all the agent needs |
| Good for | CSS and layout fixes, where the matched rules save the agent a hunt | Working straight from a link a client or tester sent you |
The two differ in detail because of where the data comes from. Computed styles and
matched CSS rules exist only in a browser with a live layout engine. The extension
has one, so its export carries them. The server has no layout engine, so the MCP
payload marks itself as a subset (producer: "server", targetDetail: "none"). For an agent
working inside your repository that is usually fine: the CSS is right there,
unminified.
In the popup, Export comments as JSON — available both while you
are annotating and while you are viewing a shared review. You get
wft-comments-<host>-<date>.json.
Every comment in it carries the selector of the element it is about, what that element is, its computed styles, the CSS rules that matched it and its ancestor chain. That is enough for an agent to go from "this heading is too tight on mobile" to the rule in the stylesheet without ever opening a browser.
Drop the file in your repo and ask for the batch:
I exported feedback comments from a website review tool as wft-comments-example.com-2026-09-27.json.
For each comment in the file:
1. Skip it if target.found is false (note it instead — the element is gone).
2. Use target.selector and target.element to find the matching markup/component in this repo.
3. Use target.matchedRules[].source to find the stylesheet, and target.matchedRules[].selector
to find the rule to edit — target.styles is the computed result, not what to copy in.
4. Apply the fix described in the comment's "text".
Report back which comments you fixed, which you couldn't map to a file, and which were skipped.
formatVersion before it starts, and treat
target.found: false as a hard stop for that comment rather than
reconstructing the element from coordinates. The full field reference is in the
JSON format documentation.
If the review already exists as a share link, the agent can read it itself, and answer it. The MCP server exposes four tools:
get_review takes the share link (or the bare review id) and returns
the review as JSON: page URL and title, capture time, viewport, and the numbered
comments with their CSS selectors, each with its status (open or resolved) and
its replies.reply_to_comment posts a reply to one comment, named by its pin
number or id, and can mark it resolved in the same call.set_comment_status resolves or reopens a comment without a
reply.page_snapshot_instructions goes the other way: it tells an agent
that drives a browser how to make a review itself. See below.Replies and status changes appear on the review page for everyone holding the link, the same as if someone had typed them there. The tools and the skill tell the agent to post only when you ask it to answer or close the comments; that is an instruction to the model, not a lock.
page_snapshot_instructions means you can ask for a review instead of
making one: "snapshot this page and comment on what looks wrong". It needs an agent that controls a browser,
through chrome-devtools MCP, Playwright MCP or its own code. The tool captures
nothing itself. It returns the steps and the code to run in the page, and the agent
comes back with a share link. Since the browser is the agent's, the capture can be of
a page behind a login or on localhost, though images and fonts stay links to the
original, so a reader who cannot reach them will not see them. Like any review, the
copy is stored on our server and anyone with the link can read it. Pages with a strict
Content Security Policy can block the code, and the steps say what to do then; the
browser extension is not affected by it.
The server is remote: it runs inside Website Feedback Tool at
https://website-feedback-tool.com/mcp. There is nothing to install or
run and no keys to set, so you connect it by URL. Claude Code:
claude mcp add --transport http website-feedback-tool https://website-feedback-tool.com/mcp
Codex, in ~/.codex/config.toml:
[mcp_servers.website-feedback-tool]
url = "https://website-feedback-tool.com/mcp"
Any other client that speaks streamable HTTP:
{
"mcpServers": {
"website-feedback-tool": {
"type": "http",
"url": "https://website-feedback-tool.com/mcp"
}
}
}
Then the conversation is just the link:
Read this review and fix what it asks for:
https://website-feedback-tool.com/reviews/<id>
Add "then reply to each comment and resolve the ones you fixed", and the agent answers
each open comment it worked on with what it changed and where (or why it did not), and
closes only those it fixed. Comments already resolved are left alone.
Replies are signed the way you tell it to sign them. Without an instruction it uses your
name when it knows it (from the conversation or git config user.name), and
otherwise signs them AI assistant.
It also comes as a Claude plugin: the same URL plus a fix-review skill
that tells the model what to do with a review once it has one. Want the plugin? Email
privacy@website-feedback-tool.com
and we'll send it over. The URL alone is enough for the tools.
Start with the export. It needs no setup beyond a download, and it carries the most detail per comment. That detail matters most for the CSS and layout nits that make up most design feedback.
Reach for MCP when the feedback arrives as a link rather than a file: a client reviewed staging and sent you a URL, and you would rather say "read this and fix it" than open the review, export it and attach the file. Nothing stops you doing both — the MCP payload is a subset of the same format plus each comment's status and replies, so an agent written against one understands the other.