Copy a Whole Linear Task Tree into AI as Markdown (Parent + Sub-Issues + Comments)

Copy a whole Linear task tree into AI as Markdown

You open a Linear parent issue you scoped three weeks ago. It has 28 sub-issues. Half are done, a few are “In Progress,” and you genuinely cannot remember the shape of the thing anymore — what it was supposed to do, what’s left, whether the work that’s marked complete actually matches what you wrote.

So you do what most team leads now do reflexively: you start copy-pasting the ticket into ChatGPT or Claude and ask, “summarize where this stands.” Or you drop it into Claude Code and ask, “is all of this actually implemented in the codebase?”

The instinct is right. The problem is the copying. Linear’s native command copies one issue at a time, and reassembling a parent plus every sub-issue and its comments by hand is dozens of clicks of manual concatenation. This article is about why that workflow has become standard, why Markdown is the format that makes it work, and how to do the copy in a single click.

TL;DR — Copy Linear Task + Sub-tasks as Markdown walks the whole issue tree for you and stitches the parent, every sub-issue, and the comments into one clean Markdown document — ready to paste into Claude Code, ChatGPT, or Cursor. It runs locally, only on linear.app, and nothing it reads leaves your browser.

The real problem: context loss, not laziness

Pasting a ticket into an AI to “remind yourself what it’s about” feels like a small thing. It isn’t. It’s a workaround for one of the most expensive hidden costs in knowledge work: context switching.

The widely cited University of California, Irvine research (Gloria Mark) found it takes roughly 23 minutes to fully regain focus after an interruption (summary via BasicOps). For people who reason about code, the cost is higher, because the interruption destroys a complex mental model that then has to be rebuilt from scratch (Context Switching Statistics 2026).

A team lead or project manager lives in that state by definition. Gerald Weinberg’s long-standing rule of thumb on juggling concurrent work — quoted across the engineering-management literature — puts the loss at around 20% of available time at two projects, 40% at three, and 60% at four (PanDev Metrics). When you’re switching between five initiatives, you don’t hold the details of any single Linear tree in your head. You can’t.

So instead of reconstructing it manually, you outsource the reconstruction to a model. That’s not a hack — it’s a rational response to cognitive load. The only thing standing between you and a 10-second answer is getting the full task context out of Linear cleanly.

Why people are pasting tickets into AI

Two distinct jobs drive this behavior, and they map to two different people on the same team.

1. The lead / PM: “What is this even about, and where does it stand?”

A parent issue with 30 sub-issues is a wall of state changes, half-written descriptions, and threaded comments. Reading it top to bottom takes ten minutes you don’t have. Pasting the whole tree into an LLM and asking for a status rollup — “which sub-issues are blocked, what’s the critical path, summarize the open questions in the comments” — collapses that into a few seconds. The model is doing structured summarization over context you no longer hold.

2. The developer / tech lead: “Did the AI actually build all of this?”

This is the verification job, and it’s become critical as AI writes a growing share of code. The honest weakness of agentic coding tools is what Anthropic’s own Claude Code best-practices guide calls the “trust-then-verify gap” — the agent produces a plausible-looking implementation that quietly skips edge cases. Their recommended fix is explicit: review the diff against the plan and check that every requirement is implemented, reporting gaps rather than style preferences.

To run that check, the model needs the requirements — and in most teams the requirements live in the Linear tree, not in a PLAN.md file. This is the heart of spec-driven development, where the specification is the source of truth and code is validated against it (Augment Code). So the workflow becomes: copy the parent issue and all its sub-issues out of Linear, paste it into Claude Code, and ask it to confirm each item is actually present in the codebase. The entire check depends on getting a faithful, complete copy of the task tree.

Why Markdown is the right format for this

You could paste raw HTML or a screenshot. You shouldn’t. Markdown has quietly become the default interchange format between tools and LLMs, for two concrete reasons.

Token efficiency. LLMs read in tokens, and formatting characters cost tokens. Converting verbose HTML to clean Markdown has been measured to cut token consumption by roughly 20–30% (SearchCans) — which means more of your task actually fits in the context window, and the model spends its attention on content instead of markup (ReleasePad).

Structure the model can read. Markdown headings, lists, and code blocks preserve the hierarchy of your content — what’s a parent, what’s a sub-task, what’s a comment. That structure gives the model a roadmap and measurably improves comprehension and retrieval accuracy on structured tasks (AnythingMD). A Linear issue tree is inherently hierarchical, so Markdown maps onto it almost perfectly.

Linear itself made this bet. Its team shipped one-click “copy as Markdown” on docs specifically so you can feed pages into an LLM (Linear on X), and the issue command is documented as capturing full issue context “in a structured format for use in AI chat tools” (Linear Docs — Exporting Data).

Where Linear’s native copy stops

Linear’s built-in command is good — for a single issue. From the command menu (Cmd/Ctrl + K) or with Cmd ⌥ C, you can copy an issue's title, description, comments, and customer requests as Markdown. You can even multi-select issues in a list or board and copy them together.

But that’s a flat, manual selection — not a tree walk. To get a full parent-plus-children export today, you have to find and select every sub-issue yourself (including nested ones, and ones not currently loaded in the view), and the multi-select behavior doesn’t reliably stitch each issue together with its own comment thread the way you’d want for AI context. With a parent that has 30+ sub-issues, “do it by hand” means dozens of clicks and a lot of cleanup. That friction is exactly why people give up halfway and paste an incomplete picture into the model — which then gives an incomplete answer.

The one-click fix

**Copy Linear Task + Sub-tasks as Markdown** closes that gap. It walks the issue tree for you and assembles the whole thing into one document:

• Whole-tree copy — parent issue + every sub-issue + comments, in a single Markdown file.
• Exactly Linear’s Markdown — it reuses Linear’s own copy command under the hood, so the output is the same faithful Markdown Linear produces, not a re-scrape.
• Toggle what’s included — include or skip sub-issues and comments depending on whether you want a tight spec or the full discussion.
• Copy or download — copy everything to the clipboard, or save a .md file.
• Leaves your tab alone — it opens a single temporary background tab, drives it through each sub-issue, then closes it. Your active tab is untouched.

Because it reuses Linear’s native command, you get fidelity for free; because it automates the tree walk, you skip the manual concatenation entirely.

How it works, step by step

1. Install the extension from the Chrome Web Store (Chrome, Manifest V3).
2. Open any parent issue in linear.app.
3. Open the side panel and choose whether to include sub-issues and comments.
4. Hit copy (or download the .md).
5. Paste into Claude Code, ChatGPT, Cursor, or any LLM.

Prompts worth keeping

Once the whole tree is on your clipboard, the two jobs from earlier become one-liners:

• Status rollup (lead/PM): “Here’s a Linear epic and all its sub-issues. Give me a status summary: what’s done, what’s blocked, the critical path, and any open questions raised in the comments.”
• Implementation check (dev): “Here’s the full Linear task tree for this feature. Go through the codebase and tell me, sub-issue by sub-issue, which requirements are actually implemented and which are missing or incomplete. Report gaps, not style preferences.”

That second prompt mirrors the exact subagent-review pattern Anthropic recommends for catching the trust-then-verify gap — you’re just feeding it the spec from Linear instead of a separate plan file.

Privacy: what leaves your browser

Nothing it reads does. The extension runs entirely locally and only on linear.app. Its permissions are scoped to the job: host: linear.app (it runs nowhere else), tabs + scripting (to drive the temporary background tab through the tree), sidePanel (the copy controls), and storage (to remember your include/exclude preferences). There's no analytics, no telemetry, and no phone-home. The only data that ever moves is the Markdown you choose to paste into the AI tool of your choice — which is the same trust boundary you already accept every time you use that tool.

FAQ

Does this replace Linear’s native “Copy as Markdown”? No — it builds on it. For a single issue, Linear’s Cmd ⌥ C is perfect. This extension is for when you need the whole tree (parent + all sub-issues + comments) without selecting each one by hand.

Will it mess up the tab I’m working in? No. It works in a temporary background tab and closes it when done. Your active tab stays where it is.

Which AI tools does the output work with? Any of them. The output is plain Markdown, which is the preferred ingestion format for ChatGPT, Claude, Claude Code, Cursor, Gemini, and most LLM tooling.

Is it free? Yes — free, and it runs locally with no account.

Why Markdown instead of just a screenshot or copy-paste? Markdown preserves the hierarchy of the tree and uses fewer tokens, so the model gets more complete context and reasons over it more accurately. Screenshots lose structure; raw HTML wastes tokens.