A visual feedback MCP server: give your coding agent eyes on the browser.

Your coding agent can edit any file in your repo, run your tests, and open a PR. What it can't do is see what your reviewer sees: the misaligned button on the deployed site, at 390px, in the empty state. A visual feedback MCP server closes that gap — it turns what people see in the browser into structured context your agent can act on.

The gap, precisely

MCP (Model Context Protocol) is how coding agents talk to external systems: an MCP server exposes tools, the agent calls them. Cursor, Claude Code, Codex, Windsurf, and Copilot agent mode all speak it. Most MCP servers connect agents to developer systems — databases, issue trackers, docs. But the highest-value context for UI work comes from a system agents have no native access to: a human looking at the rendered product.

Today that context reaches the agent through the worst possible channel: a reviewer takes a screenshot, describes the problem in prose, and you re-type it as a prompt. Every hop loses information. Which element? Which page state? Which viewport? The agent starts guessing, and you spend the session answering its clarifying questions — about facts the reviewer's browser knew precisely at the moment they clicked.

The reviewer's browser knows the selector, the DOM, and the viewport. A screenshot throws all of that away. An MCP feedback server keeps it.

What the server actually delivers

With Pincushion, a reviewer clicks an element on the live app and types a note — via the Chrome extension or a one-line script-tag widget. That click produces a pin whose payload is designed for agent consumption, not human archaeology:

CSS selector of the exact element — the agent greps your source with it
DOM snippet around the element — disambiguates repeated components
Screenshot — what the reviewer actually saw
Viewport dimensions — "broken on mobile" becomes "broken at 390×844"
Page URL and project context — which deploy, which project, which likely files
The comment thread — the discussion, including acceptance criteria if the reviewer added them

The agent reads pins through MCP tools: get_actionable_pins lists everything waiting for attention; implement_approved_pins returns approved pins grouped into per-page implementation packets with a suggested branch name; claim_pin marks work in progress so two agents don't collide; fix_and_resolve closes the pin with the commit SHA, branch, and PR URL attached. There's even assign_pin_to_agent, which dispatches a single pin straight to a local agent loop — one click from "stakeholder complaint" to "agent working on it."

Why structure beats screenshots: a concrete example

Reviewer feedback: "This price looks wrong on my phone."

	Screenshot in Slack	Pin via MCP
Which element	Guess from the crop	`.pricing-card--pro .price-amount`
Which state	Unknown	DOM snippet shows annual toggle active
Which viewport	"my phone"	390×844
Where in the repo	You search manually	Agent greps the selector, finds `PricingCard.tsx`
What happens next	You write a prompt	Agent implements, opens PR, resolves the pin

Setup in one snippet per editor

The npm package is pincushion-mcp. Claude Code:

claude mcp add pincushion -- npx pincushion-mcp --project-dir . --cloud-sync

Cursor, Windsurf, or Antigravity (mcp.json):

{
  "mcpServers": {
    "pincushion": {
      "command": "npx",
      "args": ["pincushion-mcp", "--project-dir", ".", "--cloud-sync"]
    }
  }
}

Or skip the local process entirely and point any MCP client at the hosted endpoint, https://pincushion.io/api/mcp, authenticating with your license key (Authorization: Bearer, x-license-key, or ?token=). The local server is repo-aware — it can grep your source and suggest branch names — so most people run it locally. Editor-specific walkthroughs: Cursor, Claude Code, Windsurf, Copilot, VS Code, Antigravity.

The loop closes both directions

Reading feedback is half the job. The server also writes back: when the agent resolves a pin, the commit, branch, and PR URL land on the pin, so the reviewer sees exactly what shipped. On deploy, a hook links the production URL, and Pincushion AI can revisit the page and record a verdict — verified, regressed, or inconclusive — on the pin (Pro). Feedback stops being a one-way inbox and becomes a round trip with receipts.

Pricing is simple: reviewers are always free and unlimited. The developer free tier is one project, unlimited manual pins, and 25 AI actions a month; signup starts a 14-day Pro trial ($19/mo after — unlimited automation, realtime push to your IDE, unlimited projects, access controls).

Related: how to review an app built with AI, piping client feedback into Cursor, and comparisons with BugHerd, ruttl, and Feedbucket.

Install Pincushion — free Set it up in Cursor