Home | Blog | Integration

How to Connect Figma Comments to Linear Issues

Bridge design feedback and engineering work by connecting Figma comments to Linear issues – without copy-pasting context between tabs.

By Ellis Keane · 2026-03-31

Somewhere around the fourth time I watched a designer leave a detailed Figma comment, only for the engineer sitting three metres away to file a near-identical Linear issue two days later, I stopped thinking of it as a communication problem. It's a plumbing problem. The pipes between these two tools don't exist in the way everyone assumes they do.

The native Figma linear integration gives you link embeds and a plugin to create issues from frames. That's genuinely useful. But the part where a Figma comment thread about a button's hover state quietly becomes a two-week engineering rabbit hole, and nobody connects the dots until the sprint retro – that's the gap nobody's tooling actually addresses. And that's what this article is about: how to connect Figma comments to Linear issues in a way that doesn't depend on someone's memory.

What Linear's Figma Integration Actually Does (and Doesn't)

The native integration does two things well and nothing else.

Figma link embeds in Linear. Paste a Figma URL into any Linear issue or comment and it converts to an interactive preview. One caveat worth knowing: Linear's docs note that interactive in-app previews only work for publicly shared Figma files. Your private design files (read: most of them) will render as a static link with a thumbnail instead.

The Linear plugin for Figma. From inside Figma, you can create Linear issues that automatically link to specific frames, pages, or sections. You set the team, status, assignee, and project – all without switching tabs. You can also link to existing issues, which is handy when a design change touches something already in progress.

Linear's Figma integration is a one-way bridge: it helps you push design context into Linear. It does not pull engineering context back into Figma, and it doesn't connect comment threads across the two tools.

What it doesn't do:

Figma comments don't create Linear issues automatically. Someone has to manually use the plugin each time.
Linear issue updates don't flow back to Figma. If an engineer changes the status, adds a blocker, or re-scopes the work, the designer won't see it unless they go check Linear themselves.
There's no cross-tool search. "Where did we discuss the navigation redesign?" could mean Figma comments, Linear issues, or (heaven help you) both.

Setting Up the Figma to Linear Workflow

The setup takes about three minutes. Full details are in Linear's Figma integration docs, but here's the short version:

[ ] Enable the Figma integration in Linear workspace settings (requires admin on both sides)
[ ] Install the official Linear plugin from Figma Community (avoid third-party alternatives – they tend to break with API updates)
[ ] Test: select a frame, run the Linear plugin, and create an issue. Verify it links back to the frame.
[ ] Test: paste a Figma file link into a Linear issue and confirm the embed renders
[ ] Check your design files' sharing settings – private files will show static links, not interactive previews

That handles the obvious path: designer sees a task, designer creates an issue, engineer gets context. The trouble starts when the task isn't obvious at the time the comment is written.

The Classification Problem

Here's the scenario that breaks every Figma to Linear workflow I've seen:

A designer comments on a frame: "This loading state doesn't account for the empty state we discussed. Should we add a skeleton screen?" Three people reply in the Figma thread. A decision gets made. Nobody creates a Linear issue because the comment felt more like a design discussion than a task.

Two sprints later, the engineer builds the feature without a skeleton screen. QA flags it. Everyone spends twenty minutes in Slack trying to figure out whether this was ever discussed. It was – in Figma, where the comment thread is still sitting there, resolved and forgotten.

The problem isn't that people forget to use the Linear plugin. It's that design feedback exists on a spectrum, and the classification – "was that a task?" – happens retroactively, usually when someone realises the thing wasn't done.

Three heuristics that help: When reviewing a Figma comment thread, ask whether it (a) affects acceptance criteria for an existing Linear issue, (b) describes new work nobody has filed yet, or (c) contains a decision that changes scope. If yes to any of those, it should become a tracked issue. This won't catch everything, but it gives your team a shared vocabulary for "this comment matters."

What Actually Works (and What Doesn't)

The recommended setup: native plugin plus lightweight conventions plus a safety net. Use the Linear plugin for Figma whenever a designer identifies clear work – a component needs updating, a bug needs filing, a new screen needs building. Layer on a simple comment convention (our team uses an "Action:" prefix or tags the relevant engineer) to signal intent without heavyweight process. And accept that some things will slip through – build a weekly review where you scan recent Figma comment threads alongside the sprint board, looking for unresolved threads older than a week that might map to existing issues. Is this a perfect system for connecting Figma comments to Linear issues? No, it's a manual stopgap – but it's the most reliable manual stopgap I've found, and it buys you time until you can automate the classification layer.

What works

Native plugin for clear tasks – when a designer knows something is a task, the Linear plugin is fast and direct
Comment conventions – simple tags like Action: or engineer mentions to signal intent
Weekly comment-board review – scan unresolved Figma threads against the sprint board

What fails

Manual routing at scale – relying on humans to classify every comment breaks down during busy sprints
Keyword-based Zapier automations – Figma comment webhooks fire on all activity (replies, resolves, reactions), generating noise that requires constant filter maintenance
Ignoring the gap entirely – hoping people will "just check both tools" is not a strategy

Alternative: Zapier or Make. You can set up a trigger on new Figma comments to create Linear issues. The practical problem is that Figma's webhooks can generate high volumes of comment events – replies, resolved threads, emoji reactions all fire. Without careful filtering, you'll flood Linear with a new issue every time someone reacts to a comment with a thumbs-up, which is exactly the kind of progress that makes you question your career choices. With filtering, you're maintaining regex rules that drift out of sync with how your team actually writes comments. It's workable for small teams with predictable commenting patterns, but it becomes someone's part-time job to maintain.

Alternative: semantic signal intelligence. Instead of routing individual comments as issues, a system that understands both tools at a semantic level can recognise when a Figma comment thread overlaps with an existing Linear issue, or when a new comment implies untracked work. This is the approach we're building at Sugarbug – native scrapers for both Figma and Linear that classify signals and surface connections through a knowledge graph, so the link between a design discussion and an engineering task doesn't depend on someone remembering to click a button.

The goal isn't to turn every Figma comment into a Linear issue. It's to make sure that when a comment does imply work, the connection doesn't depend on someone's memory. attribution: Chris Calo

Frequently Asked Questions

Get signal intelligence delivered to your inbox.

Q: Can I create Linear issues directly from Figma comments? A: Yes, but not automatically. You need the Linear plugin for Figma installed, and someone has to manually run it each time. It lets you create issues linked to specific frames, set the team, status, assignee, and project – all without switching tabs. The gap is that nobody does this for comments that don't feel like obvious tasks at the time.

Q: Does Sugarbug automatically connect Figma comments to Linear issues? A: Sugarbug scrapes both Figma and Linear natively, classifies signals from each, and links them through its knowledge graph. When a Figma comment references work tracked in Linear, Sugarbug surfaces that connection without manual linking.

Q: Why don't Figma comment notifications show up in Linear? A: Because the integration is a one-way street. Linear embeds Figma design previews and lets you create issues from the plugin, but Figma comment threads don't flow into Linear as notifications. Updates aren't mirrored back, either – if an engineer changes an issue status, the designer has to go check Linear to find out.

Q: How do I know which Figma comments should become Linear issues? A: Use three heuristics: does the comment affect acceptance criteria for an existing issue? Does it describe a new piece of work nobody has filed yet? Does it contain a decision that changes scope? If yes to any of these, it should be tracked in Linear.