Slack and Linear Integration: Why Context Still Gets Lost

Dott

An engineer (or an AI coding agent) opens a Linear issue that someone created from Slack three weeks ago. The title says "Fix export timeout" and the description is a single sentence copied from a chat message. The reason the bug matters, the enterprise customer who reported it, the approach the team agreed on and the shortcut they explicitly ruled out are all sitting in Slack somewhere.

Linear's Slack integration creates issues from Slack messages, syncs one thread's comments with the issue, posts notifications and expands Linear links into previews. It moves a link, one thread's comments and a few status changes, while the discussion, the decision and the background stay where they were typed.

Once you see where each piece of context gets stuck between the two apps, you can pick the right way to close the gap and know what each fix costs.

What teams expect the integration to do

When a team connects Slack and Linear, the natural assumption is that the two tools now share a brain. Whatever the team said in Slack should live on the issue, and whatever changes on the issue should show up in Slack.

In practice, people expect three things to happen automatically:

  • The issue carries the whole conversation. Anyone picking up the ticket later expects to read the reasoning, the edge cases and the final decision right at the top of the issue.
  • The issue stays current as the conversation continues. When two engineers jump into a huddle or start a side thread to check a database constraint, the ticket should reflect what they figured out.
  • Slack hears about anything that changes in Linear. If a product manager cuts the scope in half during triage or reassigns the work, the people watching the original Slack thread expect to see that update where they were talking.

The integration is great at moving messages, yet those three expectations ask it to do a job it was never built to do.

What the native integration actually does

Linear's integration page for Slack, titled Create issues from Slack messages and sync threads, with a Create a new issue dialog showing team, title, description, assignee and status fieldsLinear's own page names the two things the integration does: it creates issues from Slack messages and it syncs threads.

Linear's Slack integration page and documentation (seen on 2026-11-17) lay out the exact boundaries of what moves between the two tools. The integration is included on every Linear plan, from Free ($0) to Basic ($10 per user per month billed yearly), Business ($16 per user per month billed yearly) and Enterprise.

Here is what each feature carries across:

  • Create an issue from a message. Click More actions, Connect to apps, Create new issue… on any Slack message to open a dialog where you pick the team and fill in the title and description (a team's default template text appears in the description field). This is also where the synced thread is created.
  • Linear Agent for Slack (@Linear). You can mention @Linear in a Slack discussion to take actions in Linear based on your conversation's context, such as asking @Linear make feature requests from this thread. Workspace admins can also add custom guidance in the Slack integration settings to shape how the agent creates issues.
  • Synced threads. When you create an issue from a Slack message, you can create a synced comment thread at the same time. If Linear is available in that channel, replies in the Slack thread flow into a single comment thread on the Linear issue, and comments made inside that synced Linear thread post back to Slack. The Slack thread also gets an update when the issue is completed, canceled or marked as a duplicate. Private channels require running /invite @Linear first, and synced threads are not available in DMs.

Linear Docs section Sync threads showing an issue's Activity with a Slack thread in #all-rideshare, a message asking @Linear to create an issue based on this thread, a reply from brian and a Post to Slack button, with a note that synced threads are not available in DMsA synced thread shows up on the issue as one comment thread. The note under it sets the edges: private channels need an invite, and DMs don't sync.

  • Link existing issue and /linear. From a message's action menu you can link it to an existing Linear ticket, or you can attach a Slack message URL inside Linear. Both options drop a reference link without creating a synced thread or sending terminal updates. Typing /linear creates a lightweight issue from the message box and does not work inside Slack threads, support Slack sync or upload files.
  • Notifications. Team notifications broadcast issue activity (creation, comments, status changes and project updates) to a dedicated Slack channel. You can also turn on project and initiative updates, custom view notifications and personal DM notifications.
  • Link previews. Pasting a Linear URL or mentioning an issue ID in Slack expands a preview showing the title, description, status, assignee and creation date, and mentioning an ID adds a reply with the issue link in the thread. URLs from private Linear teams never unfurl.
  • Linear Asks. Only Linear members can create issues through the standard integration. Linear Asks, included on Business and Enterprise plans, lets anyone in the Slack workspace send requests to Linear and keeps a synced comment thread.
  • Slackbot via MCP. Slackbot can be connected to Linear's MCP server to read and update Linear data from Slack.

What crosses and what stays

InformationSlack to LinearLinear to Slack
The message an issue was created fromYes, as the new issueThe synced thread, when Linear is in the channel
Replies in the synced threadYes, as comments in one comment threadYes, comments in that synced thread appear in Slack
Replies when the issue was only linked or pastedNoNo
DMs, other threads, other channels, huddlesNoNo
Issue completed, canceled or marked duplicateNot applicableYes, the synced thread is updated
Description edits, priority, scope, assignee changesNot applicableNot in the thread. Team notifications can post activity to a channel
The decision the thread reachedOnly as one comment among the othersNot applicable

Every "Yes" in that table is raw text moving exactly as it was typed. Nothing in the plumbing reads the thread and writes down what it concluded.

Where the context gets lost

Because the integration moves individual messages and specific status events, the actual reasoning behind a piece of work falls into the gaps between the two tools.

Diagram of where information is lost between Slack and Linear: in Slack, everything outside the thread stays in Slack while the one linked thread crosses, the integration carries a link, the thread's comments and done, canceled or duplicate, and in Linear the synced comment thread arrives while the description and fields stay in LinearThe two dashed boxes are where context is lost: one on each side. The integration only connects the two solid ones.

1. The decision is in reply 14

A customer support lead posts in #bugs-prod that CSV exports are timing out for large accounts, and creates a Linear issue from that first message. Over the next hour, three backend engineers debate twenty replies in the thread: they suspect a slow Postgres query, realize the query is fine, blame the Node stream buffer, and finally agree on reply 14 to switch the export job to a background worker and skip pagination for now.

With thread sync on, all twenty replies land in Linear inside one comment thread, in chronological order. The issue description at the top still says "CSV exports timing out for large accounts." The actual decision sits buried as comment 14 of 20, unmarked, and if Linear had not been invited to the channel when the issue was created, none of the twenty replies are in Linear at all.

2. The conversation moved somewhere else

Halfway through the #bugs-prod thread, the tech lead messages the database owner in a DM to ask if the background worker queue can handle 50-megabyte payloads. They jump into a five-minute Slack huddle, realize the current Redis instance will run out of memory during billing runs, and decide the export job must write directly to S3 instead.

Linear's docs state plainly that synced threads are not available in DMs and files from direct messages cannot be attached to issues. Even if they move the debate to #infra-redis, the sync only watches the one original thread in #bugs-prod. The single most important constraint on how to build the fix never reaches the ticket.

3. The issue changed in Linear and Slack never heard

On Tuesday morning, the engineering manager runs triage in Linear. Looking at the quarter's roadmap, they rewrite the issue description to cover only accounts on the Enterprise tier, drop the priority from Urgent to Medium, and reassign it to next sprint.

A synced Slack thread only receives comments posted directly inside that synced comment thread, plus terminal status updates when the issue is completed, canceled or marked as a duplicate. Description edits, scope reductions, priority changes and reassignments do not post into the synced thread. The support lead watching #bugs-prod still thinks a full fix for every customer is shipping today. Team notifications can post issue activity to a dedicated feed channel like #linear-feed, which sits in a completely different place from where the conversation happened.

4. The issue was linked, never synced

Sometimes an engineer creates the ticket in Linear first, then pastes the Linear URL into the Slack thread so everyone has the link. Other times someone uses Link existing issue from the Slack message menu, attaches the Slack URL inside Linear, or types /linear to spin up a quick ticket.

In Slack, the pasted link expands into a clean preview card showing the title, status and assignee, so the thread looks wired up. Under the hood, Linear's docs note that with Link existing issue "no terminal updates will be sent to the Slack thread, and no synced thread will be created," attaching a Slack URL sends "no updates or messages," and /linear "is not supported in Slack threads, for Slack sync." Even the unfurled card is a snapshot: per the docs, "Previews in Slack may not match the issue in Linear exactly." Every reply typed after that link stays in Slack forever.

This missing context used to cost twenty minutes of an engineer's morning while they hunted down the right person in Slack. Today, teams also hand tickets directly to AI coding agents, and an agent reads the Linear issue without going fishing through unlinked Slack channels or DMs. If you want to see what happens when an agent picks up a ticket, read How to Delegate a Linear Issue to an AI Agent and Get a PR Back.

Three ways teams patch it, and what each costs

No toggle in Linear's integration settings closes a structural gap. Teams that keep their issues readable use one of three approaches, and each comes with a trade-off.

1. A manual habit

The simplest fix is a team rule: one person owns the summary. Before a Slack thread goes quiet, the issue creator or the assigned engineer edits the Linear issue description to record three things: the decision the thread reached, the reason behind it, and what the team decided to leave out.

It works on every Linear plan and costs zero dollars. The catch is that it runs entirely on human discipline. It fails during incident weeks when the team is busiest, and nobody notices that a summary is missing until three weeks later when someone opens the ticket cold.

2. Zapier or another automation tool

Zapier's Linear and Slack page titled Connect Linear and Slack to power AI-driven automation, with a Choose a Trigger box for Linear and a Choose an Action box for SlackZapier pairs a trigger in one app with an action in the other. It moves an event across, as it happened.

When a team gets tired of missing status updates or copy-pasting messages, they usually bring in Zapier's Linear and Slack integration. Zapier pairs Linear triggers (New Issue, Updated Issue, New Issue Comment) and actions (Create Issue, Create Comment, Update Issue) with Slack triggers (New Message Posted to Channel, New Reaction Added in a Channel, New Mention) and actions (Send Channel Message, Retrieve Thread Messages).

Zapier is great at moving fields when an event fires. You can build a Zap that posts a Slack message whenever an issue's priority or description changes in Linear (patching scenario 3), or one that creates an issue whenever someone reacts with a ticket emoji. What it cannot do on its own is read twenty replies and tell which one was the decision, unless you add an AI step and prompt it yourself. Each action counts toward your task limit, and every custom Zap becomes another piece of internal plumbing to maintain. On Zapier's pricing page (seen on 2026-11-17), the Free plan includes 100 tasks a month and restricts you to two-step Zaps (one trigger and one action), Professional starts at $19.99 a month billed annually ($29.99 billed monthly) for 750 tasks, and Team starts at $69 a month billed annually for 2,000 tasks.

3. An agent that reads the conversation

To turn a messy thread into an updated issue description without relying on someone's memory, you need software that can read the conversation and write the conclusion into the ticket. Two options handle this inside Slack and Linear.

Linear Agent (@Linear) is built right into Linear's Slack integration. When a thread settles on a plan, anyone with a Linear account can mention @Linear in the thread and ask it to create or update issues from the conversation's context, guided by whatever rules the admin set in Linear's Slack settings. The trade-off to watch is timing: @Linear acts at the moment you mention it, so its summary captures the thread up to that reply, and anything people debate afterwards goes back to being ordinary synced comments. It is also unavailable in externally shared Slack Connect channels, requires /invite @Linear in private channels, and in group DMs it must be invited when the group DM is first created.

Merlin is an AI coworker that lives across Slack, Linear and GitHub, running the Claude Code and Codex setups that engineers already have on their own machines. In a Slack thread, anyone can mention @Merlin and ask it to find, create or update a Linear issue with the conclusion the thread just reached. Inside Linear, delegating an issue to Merlin or mentioning it starts an agent session directly on the ticket, where it reads the issue context and posts its thoughts, live status, plan and actions as it works, and teammates can steer it with follow-ups.

Linear issue MRL-482 delegated to Merlin: the activity shows Ana delegating it and Merlin moving it from Todo to In Progress, then Merlin's agent session with its thoughts, three completed actions and a response linking the pull request, followed by Ana's follow-up asking about annual plans and Merlin's reply that the same pull request now covers themAn issue delegated to Merlin starts an agent session on the issue itself, so the work and the follow-ups stay with it.

Merlin's limits are worth knowing up front. Like @Linear, it acts when triggered (by a mention, a DM, a delegated issue or a scheduled automation), and it requires one of the team's machines to be online running Claude Code or Codex. Its memory starts off by default in a new workspace, is scoped to the Slack channel where a fact was learned, and a run started from Linear only reads public channel memory without saving new entries. Its summaries can also be inaccurate or incomplete, so a human still needs to glance at the ticket, and Slack's agent interface requires a paid Slack plan. Merlin has no free tier after its 14-day Team trial: workspace plans on its pricing page (seen on 2026-11-17) are Starter at $9 a month (up to 3 active users, 1,000 requests), Team at $59 a month (up to 50 active users, 5,000 requests) and Scale at $99 a month (up to 200 active users, unlimited requests), while model usage stays on each machine owner's own Claude Code or Codex plan.

For a wider look at agents that operate inside Linear, see Best Linear AI Agents in 2026.

One rule applies to every agent on the market: an agent only sees the channels it has been invited into. A decision made in a private DM between two engineers stays invisible until someone brings it back to the channel.

A checklist for keeping context with the issue

Whether you stick with the native integration or add an agent on top, these eight habits keep the reasoning attached to the work:

  1. Start from the message action menu. Create tickets using More actions, Connect to apps, Create new issue… with thread sync turned on, or mention @Linear at the end of the discussion.
  2. Invite Linear to private channels early. Run /invite @Linear whenever you spin up a private project or incident channel so the first issue created there gets a synced thread.
  3. Spot the un-synced links. Treat pasted Linear URLs, Link existing issue and /linear tickets as static bookmarks that carry zero replies across.
  4. Put the decision in the description. When a long thread lands on an answer, edit the top of the Linear issue to state the decision, the reason and the non-goals, and name one person on the thread to own that edit.
  5. Bring side-channel outcomes back. If a huddle or a 1-on-1 DM changes the technical approach, post a two-sentence summary in the original synced Slack thread so it lands on the issue.
  6. Announce scope changes in the synced thread. When triage changes the priority, assignee or scope in Linear, drop a quick comment in the synced thread on the issue so the people in Slack hear about it.
  7. Read the issue cold before handing it off. Before assigning a ticket to an engineer who was out of the channel or delegating it to an AI agent, read the title and description alone and ask if they could build the right thing from what is written there.
  8. Automate the part that hurts, and review the output. Use Zapier if you need field changes broadcast to Slack, use @Linear or Merlin if you want the thread summarized into the ticket, and always have a human verify the final description.

FAQ

A small team creating a handful of tickets a week can keep its context intact with the manual habit of editing the description before leaving a thread. A team that keeps getting surprised by quiet scope changes in triage can wire up a Zapier notification. A team that regularly hands tickets to engineers or coding agents who weren't in the room will want an agent like @Linear or Merlin to read the thread and write the conclusion onto the issue.

Try Merlin for free

Hand work to Claude Code and Codex from Slack, Linear and GitHub. Free for 14 days, no API keys, no card required.

Get started for free

Keep reading