More teams are starting from a prompt now, not a canvas. You describe the thing, an agent builds it, you ship it. It's faster. But the place your team used to leave feedback, Figma comments, was attached to the canvas you just skipped. So the notes have nowhere to land.
What's actually happening to Figma
Figma went public in the summer of 2025. A year on, the stock sits well below where it opened and a long way off its first-month highs (mid-2026). Revenue is still growing. This isn't a "Figma is dying" post.
The slide tracks one specific worry: tools that let you generate a working UI without opening a canvas at all. Anthropic shipped Claude Design in April 2026. Cursor has design features. The bet the market is making is that fewer projects will start in a design file. That's the same shift you're living if you build straight from a prompt.
Here's the part nobody priced in. The canvas was never just where the design lived. It was where the conversation lived. Skip the canvas and you don't just lose a mockup step, you lose the room everyone gave feedback in.
Figma comments weren't about pixels. They were the one place your whole team could point at something and say "this is off."
Skipping the canvas skips the comments too
Think about what a Figma comment actually did. A teammate, a client, a PM with an opinion on the copy, none of them opened an IDE. They opened a file, clicked the thing, and typed. The builder saw exactly which element, in which frame, with the thread right there.
When the work moves straight to a deployed app, that whole loop has no home. The reviewer is looking at the live site. You want their input on the live site. But the tools they know are Figma (no connection to what shipped) and Slack (every note becomes a screenshot with a red circle).
So they send the screenshot. You decode it. You write a prompt to your agent. The agent asks which element, which page, which viewport, because the screenshot doesn't say. You spend ten minutes rebuilding context that should've been captured the moment they clicked.
Where the notes go now, and why each is rough
Comment back in Figma anyway. Works right up until the built app stops matching the file, which is fast. After that your reviewers are commenting on a canvas that no longer describes what's live.
Screenshots in Slack. The honest default. Zero setup, everyone gets it. The cost is all in translation, and it compounds with every reviewer and every iteration.
Preview deploy toolbars. Vercel and Netlify preview comments are genuinely good for pre-merge review. The catch: reviewers need an account on your host, the comments live on the preview not production, and the output is a note for a human to read, not a work item your agent can pick up.
What the missing layer needs to do
Whatever replaces the Figma comment for a built app has to do the things the canvas did well, in the new place:
| What the canvas gave you | What a built-app loop needs |
|---|---|
| Anyone could comment, no install | Reviewers click a link or use a shared extension. Free, no dev toolchain |
| A comment pinned to a real element | Anchored by CSS selector + page URL, survives reloads and mobile |
| Builder saw frame, state, intent | Builder or agent sees selector, DOM snippet, screenshot, viewport, thread |
| Thread stayed on the thing | Thread stays on the pin, not scattered across Slack |
| Resolved when the change shipped | Resolved in a real commit + PR, re-checked on the deployed site |
That last row is the one the canvas never quite did. "Was this actually fixed?" was always a follow-up conversation. On a live product you can close that loop automatically.
How Pincushion fills the gap
The review happens on the deployed product, and the people reviewing aren't opening an editor.
- Reviewers install nothing real. An extension you share once, or a link. They click anything on the live site and type. Reviewers are free and unlimited.
- The pin captures what a screenshot can't. Selector, DOM snippet, screenshot, viewport, and the full thread, bundled as an agent-ready work packet.
- Your agent reads pins over MCP. One call in Cursor, Claude Code, Codex, or Windsurf pulls the whole context. It doesn't have to ask what was meant.
- The loop closes. When the pin's resolved it carries the branch, commit, and PR. The deploy hook links the production URL, and the fix gets re-checked on the live site.
Same loop you had in Figma, point, discuss, fix, close, just on the thing that actually ships.
Figma isn't the villain here
This isn't an anti-Figma piece. For early exploration and handing design decisions to engineers, the canvas still earns its place. The point is narrower. The day your source of truth becomes the deployed app, the feedback loop has to move there too. Right now, for most teams skipping the canvas, it just falls into Slack and gets lost.
That's the layer we're trying to be. Not the canvas. The room where your team points at the live app and says "this is off," and the note turns into a fix.
Pincushion is free to start: pincushion.io