Pincushion is the visual feedback layer for AI coding agents. Stakeholders drop pins on any element of your live app — each pin carries selector, screenshot, viewport, thread, and project context — and 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 pins, full MCP integration, and open commenting. Pro ($19/mo) adds 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.

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.

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.

Q: 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.

The visual feedback layer for AI coding agents. Drop a pin on any element — your agent gets the selector, screenshot, viewport, and thread context, and lands the change in your IDE. Stop turning feedback into tickets. Turn it into agent-ready code work.

Add to Chrome — Free Connect your agent →

We'll email you the Chrome install link

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

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.

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.

Chrome & every MCP editor

Chrome extension for stakeholders. MCP integration + VS Code marketplace 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.

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", "."] } } }

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 .

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" ] } } }

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", "."] } } }

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", "."] } } }

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 # optional: cloud sync (requires license key) # env: 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

Install VS Code Extension

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

Why pins behave differently here

Three concepts that make the loop close itself.

Agent work packet

More than a screenshot.

Every pin carries the CSS selector, surrounding DOM snippet, viewport size, full comment thread, project context, and optional acceptance criteria — all in one MCP call. Your coding agent gets the same picture you do, without you translating anything into a prompt.

Post-deploy verification

Proof the fix shipped.

When a deploy includes pins your agent resolved, Pincushion AI revisits the page and writes back a verdict — verified, regressed, or inconclusive — directly onto the pin. Stakeholders see proof. Pro & Team.

Time-to-fix

The metric that matters.

Feedback tools brag about how fast they collect bugs. Pincushion brags about how fast bugs close. Median pin-to-PR, with a 5-pin minimum so the number is never a lie. Pro & Team for your projects; aggregate below.

Pricing

Start free.
Scale when ready.

No surprises. No hidden fees. Cancel anytime.

Monthly

Annual Save 20%

Free

$0 /forever

No credit card required

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

Unlimited stakeholder seats — free forever
Unlimited pins, comments & MCP tool usage
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)
Pincushion AI critic — unlimited, runs in your IDE on your tokens
Slack & Teams routing for ready pins & mentions
1 project · Cloud sync (30s polling) · Slash commands for all IDEs
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

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

3 editor seats included
Additional editor 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)	✓	✓	✓
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)	—	✓	✓
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 no usage caps — upgrade for unlimited projects and Realtime sync. 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.

Four steps.
Zero friction.

Drop a pin

Team discusses

Pincushion AI critiques

Agent-ready in your IDE