Pincushion for Windsurf.

Visual feedback that lands in your IDE. Stakeholders drop pins on your live app; Cascade reads them via MCP — selector, DOM snippet, screenshot, viewport, thread, project context, and acceptance criteria — and ships the change from inside Windsurf.

Get started — free See the full product →

The flow

Stakeholder drops a pin on any element of your live app via the Chrome extension or the one-line script-tag widget
You open Windsurf and run the /pins or /implement workflow (Pincushion ships Windsurf workflows in .windsurf/workflows/)
Cascade receives the pin's full work packet via MCP — no copy-pasting screenshots, no translating feedback into prompts
Cascade finds the source code, makes the change, calls fix_and_resolve with branch + PR URL
Deploy hook auto-resolves the pin on production. Stakeholder sees "Resolved in PR #142, deployed at 3:24pm"

Install (60 seconds)

Add Pincushion to ~/.windsurf/mcp.json (or via Windsurf Settings → Cascade → MCP Servers → Add Server):

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

Prefer not to run a local server? Point Windsurf at the hosted endpoint instead — cloud-synced pins, nothing on your machine:

{
  "mcpServers": {
    "pincushion": {
      "serverUrl": "https://pincushion.io/api/mcp?token=YOUR_LICENSE_KEY"
    }
  }
}

The local server is repo-aware (it can grep your source and name branches); the hosted endpoint covers the cloud-side tools. Most people start local. Run npx pincushion-mcp login once to link your license key.

Slash commands available after install

/pins — show all open pins on this project
/implement — run the full approved-pin loop (claim → fix → resolve)
/resolve <id> — claim and close one pin
/critique <url> — Pincushion AI drops ≤3 UI/copy/a11y pins on the page
/feedback-summary — project overview

Stop translating visual feedback into Cascade prompts. Drop a pin. Your agent gets the full context in one MCP call.

Why this matters more in an agentic IDE

Cascade is built to take a task and run with it — multi-file edits, terminal commands, iterating until the change works. The quality of that run is set almost entirely by the quality of the task description. "Fix the button the client mentioned" produces a clarifying-question loop; a Pincushion pin produces a straight run, because the task arrives with the selector (.checkout-form .btn-submit), the DOM around it, the viewport it broke at, and the client's exact words in the thread. You're not prompting the agent about the feedback — the feedback is the prompt.

It also composes with how Windsurf teams already work: pins are grouped into per-page implementation packets, so /implement naturally maps to one branch and one PR per page of feedback. The commit SHA, branch, and PR URL land back on each pin, and the deploy hook closes the loop on production — reviewers watch their own pins move from open to "resolved, deployed, verified" without asking you for status.

What's in the work packet

CSS selector — Cascade greps the repo with it and lands on the right component
DOM snippet — disambiguates repeated components and reveals page state
Screenshot + viewport — what the reviewer saw, at the size they saw it
Thread + acceptance criteria — what "done" means, in the stakeholder's words
Project context + likely files — so the first file the agent opens is usually the right one

Pricing

Reviewers and stakeholders are always free — unlimited, no accounts to buy. The developer free tier includes one project, unlimited manual pins, and 25 AI actions a month, and every signup starts a 14-day Pro trial. Pro is $19/mo: unlimited automation, realtime push to Windsurf (pin → IDE in under a second), unlimited projects, and access controls.

Also using other editors? Pincushion works the same way in Cursor, Claude Code, VS Code, and Antigravity. New to the idea? Read what a visual feedback MCP server actually does.

Get started — free Back to home