Pincushion gives you design feedback on your live web app or native mobile crit wall that your coding agent can act on. Clients, teammates, or your designer friend drop pins on any element — free, no setup — and each pin carries selector or hotspot context, screenshot, viewport, thread, and project context. Your coding agent (Cursor, Claude Code, Codex) lands the change in your IDE via an MCP server.

How does Pincushion work with AI agents?

Pincushion includes an MCP server that connects to AI coding agents like Claude Code, Cursor, and VS Code Copilot. Agents can read feedback pins, claim them, implement the code change, and resolve them — all without manual ticket management.

Yes. The Free tier includes 1 project with unlimited manual pins, 25 AI actions per month, full MCP integration, and open commenting — and every signup starts with a 14-day Pro trial. Referrals stack: invite another developer and you both get +25 AI actions/mo for 3 months. Run out mid-month? A one-time $10 AI Action Pack adds +100 actions (valid 12 months, no subscription). Pro ($19/mo) adds unlimited automation, unlimited projects, Realtime sync, and access controls — lock pins to a company domain or require an invite. Team ($49/mo) adds 3 seats and team collaboration. Reviewers and stakeholders are always free.

Can stakeholders send feedback by email?

Yes. Every project gets an email address (pin+ @in.pincushion.io). A teammate or client can forward a note or screenshot to it and Pincushion turns the email into a pin on the project — subject and body become the thread, an attached image becomes the screenshot, and any project URL mentioned in the email sets the page. No extension, no account, their native tool.

What is an agent work packet?

An agent work packet is a Pincushion pin that carries everything a coding agent needs to land the fix in one MCP call: CSS selector, surrounding DOM snippet, screenshot, viewport size at pin-drop time, comment thread, project context, and optional acceptance criteria. The pin is the spec — your agent doesn't need a separate ticket or a manual prompt.

What is post-deploy verification?

When a deploy ships pins that were resolved by your agent, Pincushion AI revisits the page in your next IDE session and writes back a verdict — verified, regressed, or inconclusive — directly onto each pin. Stakeholders see the verdict on the pin so they know the fix actually landed correctly. Available on Pro and Team plans.

How fast does Pincushion ship feedback?

Pincushion tracks time-to-fix — the duration from pin drop to pin resolution — and surfaces median, p25, and p75 to Pro and Team accounts. The metric needs at least 5 resolved pins before it renders, so the number is never a single-pin lie. The aggregate across all Pincushion users is on the landing page when the dataset is meaningful.

Point. Pin. Fixed.

Your client, teammate, or designer drops a pin on your live web app — or on a mobile crit wall generated from native app screens. Your coding agent (Cursor, Claude Code, Codex, Windsurf) reads it and ships the fix, with the selector or hotspot, screenshot, and thread in one MCP call. Reviewers are always free, nothing to install on their end.

Add to Chrome — Free Connect your agent →

We'll email you the Chrome install link

✦ Every account starts with 14 days of Pro — realtime sync & unlimited AI actions, no card. Then free forever: 1 project, unlimited manual pins, 25 AI actions/mo.

See it on your own page in 60s, no install →

Works with

Cursor Claude VS Code Windsurf Codex

acme-app.vercel.app

AcmeApp

Build something beautiful today

Get Started

Learn More

Josh

.hero > h1 Open

"Make this headline more compelling — try Welcome Home"

.cta-button Open

"CTA should say Start Free Trial"

.nav > .logo Done

"Logo needs more padding"

hero-section.html

styles.css

1<section class="hero">

2 <div class="hero-inner">

3 <h1>Build something beautiful today</h1>

3 <h1>Welcome Home</h1>

4 <p>The platform for modern teams</p>

5 <div class="cta-row">

6 <a class="cta-button">Get Started</a>

7 </div>

8 </div>

9</section>

11

Pin resolved. Changes shipped.

Pin feedback

AI reads & ships

Resolved

How it works

Four steps.
Zero friction.

Anyone drops a pin

Your reviewer — client, teammate, designer friend — right-clicks any element on the live web app and types a note. For native iOS apps, generate a mobile crit wall from simulator screens so they can comment on the flow in a browser. No account dance, no paid seat, nothing to install on their end. We grab the selector, hotspot, XPath, or coordinates behind the scenes. They can even just email it: a note or screenshot sent to your project's pin+…@in.pincushion.io address becomes a pin too.

Discuss in place

Threaded comments appear right on the page. Context stays where it belongs — not in a Slack thread from last Tuesday.

Your agent picks it up

The pin arrives via MCP in Cursor, Claude Code, Codex, or Windsurf — selector, screenshot, viewport, thread, and project context in one call. No translating screenshots into prompts.

The loop closes

Resolving records the commit, branch, and PR. The deploy hook links the live deploy, and Pincushion AI re-checks the fix on the deployed site — so your reviewer sees their note shipped and verified, not just "marked resolved."

Features

The feedback loop,
finally closed.

Agent slash commands

Type /pins, /my-pins, or /resolve in any supported IDE and your agent instantly pulls the relevant feedback and acts on it. Works in Claude Code, Cursor, VS Code, Windsurf, and Antigravity — zero extra config.

MCP agent integration

One command: npx pincushion-mcp. Your AI reads pins, claims them, writes the change, and resolves — all via Model Context Protocol.

Pincushion AI

An AI teammate, free on every plan. Run /critique and Pincushion AI drops UI/copy/a11y pins on your page. Mention @pincushion in any thread for a follow-up. Runs in your IDE on your tokens — page analysis and model execution stay local; resulting pins sync like any human pin.

Mobile crit walls

Turn iOS simulator screens into a browser-based critique wall with semantic hotspots. Reviewers comment without installing anything; your agent still gets source hints, screen context, and a repeatable mobile-wall publish refresh path after changes land.

Roles & permissions

Owners, developers, and commenters — each with exactly the right level of access. Commenters are always free. You only pay for developers.

Pin any element

CSS selectors, XPath, visual coords — all captured automatically. Works on any site.

Threaded comments

Inline discussions right on the element. Context stays where it belongs.

An agent work packet, not a feedback item

Other tools hand feedback to developers. Pincushion hands it to your coding agent — selector, DOM snippet, screenshot, viewport, thread, project context, and acceptance criteria, all in one MCP call. Resolved pins keep the commit SHA, branch, and PR URL attached to the implementation record.

Slack & Teams notifications

Pipe pin activity into the channels your team already lives in. Subscribe to ready-for-dev pins, @-mentions, and follow-up replies — or opt in to every new pin and resolved change. Per-page filters, named subscriptions, one-click OAuth install.

Share a report, no install

Every project gets a public link at pincushion.io/r/<token>. It's a live screenshot of the page with real pin markers, threads, and status. Anyone with the link can view it, reply, or drop a new pin right in the browser, no extension, no account. Click into a resolved pin to see what the page looked like before, the PR that fixed it, and when it shipped.

Chrome & every MCP editor

Chrome extension for stakeholders who want it installed, or send a share-report link if they'd rather not. MCP integration + a VS Code/Cursor extension for Cursor, Claude Code, VS Code, Windsurf, and Antigravity. Real-time cloud sync keeps everyone on the same page. Works on production, localhost, staging, if it renders in a browser, you can pin it.

Developer Setup

Connect your agent.

Pick your editor. pincushion's MCP server works with any agent that supports Model Context Protocol. On Next.js or Vite? One npm install makes every dev build and preview deploy pinnable — no extension needed for reviewers. Built it with Lovable, Bolt, or v0? One script tag makes the generated app reviewable by anyone.

View MCP on GitHub

VS Code & Cursor extension

VSIX install

The Pincushion extension auto-configures the MCP server and adds @pincushion as a Copilot Chat participant — works in both VS Code and Cursor.

Download VSIX (v0.2.0)

After downloading, run code --install-extension pincushion-feedback-0.2.0.vsix (or drag the file into Extensions → Install from VSIX…). Marketplace listing also pending — VSIX is the canonical install for now.

Available commands after install: @pincushion /pins — show all open feedback
@pincushion /my-pins @you — your @mentioned pins
@pincushion /resolve <id> — claim & close a pin
@pincushion /feedback-summary — project overview
@pincushion /implement — run the full approved-pin loop

Plus deploy-time AI critique via the deploy webhook — runs /critique on every push and auto-resolves landed pins.

Cursor

Marketplace

Install the MCP server with one click via the Cursor deeplink — the bundled Marketplace listing is still pending review.

Add Pincushion MCP to Cursor Install from Cursor Marketplace Coming soon

Or add manually to ~/.cursor/mcp.json:

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

Claude Code

1 command

Run this once in your project root. Claude Code registers pincushion as an MCP server automatically.

# run in your project root claude mcp add pincushion -- npx pincushion-mcp --project-dir . --cloud-sync

After adding, prompt your agent: "Check pincushion for open feedback" — it will call get_actionable_pins and start working.

Claude Desktop

Config file

Add to claude_desktop_config.json. On macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

{ "mcpServers": { "pincushion": { "command": "npx", "args": [ "pincushion-mcp", "--project-dir", "/absolute/path/to/project", "--cloud-sync" ] } } }

Replace /absolute/path/to/project with your repo path. Restart Claude Desktop after saving.

Windsurf

Config file

Open Windsurf → Preferences → MCP, or edit ~/.windsurf/mcp.json directly.

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

Antigravity

Config file

Add to your Antigravity MCP config file. Use . for the project dir if running from your repo root, or provide an absolute path.

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

Any MCP Client

npx

Any editor or agent runtime with MCP support can connect using npx. Point --project-dir at your repo root.

# command npx pincushion-mcp --project-dir /path/to/repo --cloud-sync # sign in once to link your license: npx pincushion-mcp login # (or set PINCUSHION_LICENSE_KEY=your_key)

Also works with:

Zed Cline Continue Goose Amp Codex CLI Any MCP-compatible agent

VS Code

Cursor

Claude Code

Claude Desktop

Windsurf

Antigravity

+ Zed, Cline, Continue, Goose, Amp, Codex CLI, and any MCP client

Download VS Code Extension (VSIX)

Full setup instructions on desktop.

	Design-file comments	pincushion
Where you comment	A static design file	The product you've actually shipped
What you comment on	Pixels in a frame	Real DOM elements — CSS selector, XPath, coords
Source of truth	The design file (drifts from production)	The code that's actually running
Who acts on the feedback	Designer hands off, developer rebuilds	Pin lands in your IDE as agent-ready implementation context
Loop closes when	Designer marks the comment resolved	The change ships — pin auto-resolves on deploy
Stakeholder cost	Paid seat, or heavily limited guest access	Always free — no seat, no cap, ever

Pricing

Start free.
Scale when ready.

Stakeholders are always free: unlimited reviewers, no seats, nothing to install. You only pay to unlock more projects and Realtime. No hidden fees, cancel anytime.

Monthly

Annual Save 20%

Free

$0 /forever

Starts as a 14-day full-Pro trial — no card required

Stakeholders always free. Devs get the full agent-native workflow on one project.

Unlimited stakeholder seats — free forever
Unlimited manual pins, comments & the full MCP workflow
25 AI actions / month — agent dispatches, AI replies, AI critique pins & deploy verifications (manual work never counts)
Agent work packets — pins carry selector, DOM, viewport, thread & project context
Assign-to-agent — one MCP call dispatches the pin to your local agent loop
Branch / PR URL recorded on resolved pins
Implementation packets (pins grouped by page)
Slack & Teams routing for ready pins & mentions
1 project · Cloud sync (30s polling) · Slash commands for all IDEs
Unlimited AI actions
Realtime push to your IDE
Unlimited projects
Auto-link deploy URL + post-deploy verification
Time-to-fix metrics for your projects
Access controls (domain or invite-only)

Get started free

Pro

$19 /mo

$15 /mo

$19/mo

Billed monthly — switch to annual & save $48/yr

For teams shipping with AI coding agents

Unlimited AI actions — no monthly pool on dispatches, AI replies, critiques & verifications
Realtime push to your coding agent — pin → IDE in under a second
Auto-link deploy URL — every deploy writes the live URL back to its resolved pins
Post-deploy verification — Pincushion AI verifies the fix and writes a verdict (`verified` / `regressed` / `inconclusive`) on the pin
Time-to-fix metrics for your projects — median + p25/p75 of pin-to-resolve, with a 5-pin minimum so it's never noise
Access controls — open, domain-locked, or invite-only
Unlimited projects
90-day pin retention (Free is 30 days)
Everything in Free (agent work packets, assign-to-agent, PR linkage, AI critic, Slack/Teams)
Priority email support

Team

$49 /mo

$39 /mo

$49/mo

Billed monthly — switch to annual & save $120/yr

For teams with multiple developers

White-label crit reports — your logo on client-facing reports
3 developer seats included
Additional developer seats at $12/mo each
Unlimited commenters — free forever
Everything in Pro (Realtime, auto-link deploy, post-deploy verification, time-to-fix metrics, access controls)
Unlimited pin retention
Role management (owner, editor, commenter)
@mention routing between team members
Priority support

Full feature comparison Exactly what's in each plan. No fine-print surprises.

Capability	Free	Pro	Team
Visual pins on any page	✓	✓	✓
Unlimited stakeholder / commenter seats	✓	✓	✓
MCP server + slash commands (Cursor, Claude Code, Codex, Windsurf)	✓	✓	✓
Agent work packet (selector + DOM + viewport + thread)	✓	✓	✓
Assign pin to coding agent	✓	✓	✓
Branch / PR URL recorded on resolved pin	✓	✓	✓
Slack / Teams routing (low-noise defaults)	✓	✓	✓
AI actions (dispatches, AI replies, critiques, verifications)	25/mo + $10 top-up packs	Unlimited	Unlimited
Projects	1	Unlimited	Unlimited
Cloud sync	30s polling	Realtime	Realtime
Auto-link deploy URL on every deploy	—	✓	✓
Post-deploy verification (Pincushion AI verdict)	—	✓	✓
Time-to-fix metrics for your projects	—	✓	✓
Access controls (domain or invite-only)	—	✓	✓
White-label reports (your logo on client crits)	—	—	✓
Pin retention	30 days	90 days	Unlimited
Editor seats included	—	1 (you)	3 (+$12/seat)
Priority email support	—	✓	✓

How roles work: Developers connect their AI agent via MCP, use slash commands, claim pins, and ship the changes. Free tier covers one project with unlimited manual pins and 25 AI actions a month — upgrade for unlimited automation, unlimited projects, and Realtime sync. Not ready to subscribe? A one-time $10 top-up adds +100 AI actions whenever you run out. Stakeholders (designers, PMs, clients) drop pins, leave comments, and participate in threads — completely free, no seat required, ever. The people creating feedback never hit a paywall. You only pay for the developers whose agents do the work.

Cancel anytime

Payments secured by Stripe

No hidden seat fees for stakeholders

No extension browsing tracking

Point. Pin. Fixed.