Skip to main content
skill CX Codex

to-linear — Claude Code skill: what it does, how to install

Turns specs, plans, or chat discussions into ordered Linear milestones and backlog issues with native dependencies. Requires explicit approval before any changes.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add PinguApps/Skills --skill to-linear -a claude-code
Open on GitHub

What to-linear does

The workflow transforms a PLAN.md file, an issue URL, or a conversation plan into an organized Linear backlog. It relies directly on the companion linear-ticket skill to manage issue contents, estimates, and tracker mutations. While linear-ticket handles individual ticket mechanics, to-linear resolves sources, calculates graph order, and controls the publishing sequence.

Destination selection is strictly manual. The agent never guesses your target team or project in Linear. It checks CONTEXT.md, ADRs, and existing issues to identify scope overlaps before drafting. Refactoring steps get ordered before the slices they enable. It also flags the unblocked parallel frontier, showing tasks that concurrent agents can pick up immediately.

Nothing reaches Linear until you approve the full proposal. The draft lists milestones, acceptance criteria, dependencies, provenance, and assigned executors (Agent or Human). Once confirmed, issues publish in topological order with Backlog status and native blockers.

What it helps with

  • Break down PLAN.md or a feature specification into Linear milestones and tickets
  • Identify unblocked issues that separate agents can execute concurrently
  • Prevent duplicate issues by reconciling against the existing Linear backlog
  • Map topological blockers and cross-milestone dependencies before creation

Example prompts for the agent

  • Break down the spec in spec.md into Linear milestones and tickets.
  • Turn our current conversation plan into a Linear backlog proposal.
  • Import root PLAN.md into the confirmed Linear project and show the draft first.

How to install to-linear

1Skills CLI (Vercel)

npx skills add PinguApps/Skills --skill to-linear -a claude-code

2Manually: put the files in place

~/.claude/skills/to-linear/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/to-linear/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about to-linear

How do I install to-linear in Claude Code?

Run npx skills add PinguApps/Skills --skill to-linear -a claude-code. The workflow will be placed at ~/.claude/skills/to-linear/SKILL.md.

What does to-linear do?

It reads planning documents or chat discussions and translates them into a structured set of Linear milestones and issues. It arranges items by topological dependencies and assigns them to Backlog status after your review.

What dependencies does to-linear require?

It requires the linear-ticket skill, which handles ticket-level mutations, estimates, and field verification. You also must confirm a valid target team and project in Linear before execution begins.

Source text

SKILL.md · MIT
---
name: to-linear
description: Break a plan, spec, referenced issue, or current conversation into approved Linear milestones and tracer-bullet tickets in a confirmed project, with native dependencies, Backlog status, and focused labels.
disable-model-invocation: true
---

# To Linear

Turn the primary source into an approved, ordered backlog. Read and apply [$linear-ticket](../linear-ticket/SKILL.md) before drafting: it owns all individual-ticket content, metadata, estimates, mutations and verification. This workflow owns destination selection, source resolution, slicing, whole-graph review and publication order. Pass its confirmed destination and approved proposal to `linear-ticket`.

## Process

### 1. Confirm the destination

Use `linear-ticket`'s explicit team/project selection and confirmation procedure before analysing or drafting. Never infer the destination for this workflow. Every ticket in the run uses that confirmed destination unless the user restarts selection.

### 2. Resolve the source, context, and existing tickets

Resolve exactly one **primary source** for scope, in this order:

1. An explicit source supplied with the invocation or explicitly designated by the user for this run: a file, issue identifier or URL, or pasted plan/spec. Fetch and read the full body and comments of a referenced issue.
2. Otherwise, the most recent settled plan or spec in the current conversation. If it points to an artifact, fetch and read that artifact fully.
3. Otherwise, root `PLAN.md`, when present; read it fully.
4. Otherwise, stop and ask the user for the source.

An explicit source wins even when `PLAN.md` exists. State which source was selected. Do not merge multiple plausible sources into new scope; ask when source selection is ambiguous or when a contradiction materially changes the intended outcome.

Treat `CONTEXT.md`, applicable `AGENTS.md`, referenced sources, relevant ADRs, designs, code, and tests as supporting context. Read them when they affect ticket accuracy. `CONTEXT.md` is authoritative for domain language, boundaries, and durable decisions, but supporting context never silently expands the primary source.

Pass the primary source and stable reference to `linear-ticket` for provenance handling.

For broad work, use subagents for bounded, independent, read-only exploration such as separate module investigations, prior-art searches, or overlap checks. Continue other independent analysis while they work, then reconcile every result before drafting. The primary agent owns source selection, the complete proposal, user approval, and every Linear mutation; never create or edit Linear items concurrently through subagents.

After destination confirmation, apply `linear-ticket`'s scoped inventory and overlap review across the entire source before slicing. Reuse matching milestones and covered issues; present narrowed or omitted overlaps in the complete proposal. Apply its estimate discovery while drafting, keeping writes deferred until publication approval.

### 3. Draft milestones and tracer-bullet tickets

Draft each slice through `linear-ticket`, including Human and prefactoring work.

Look for necessary prefactoring before slicing and place qualifying outcomes before the slices they enable, using `linear-ticket`'s scope rules.

Plan milestone membership and numbering through `linear-ticket` and its [numbering reference](../linear-ticket/references/issue-numbering.md). Order the complete milestone set chronologically and topologically, with prerequisite milestones earlier. Apply the numbering rules to existing items included in an approved insertion or renumbering too.

Topologically order the complete proposal using `linear-ticket`'s prerequisite rules. Treat all milestones as one graph: a ticket becomes actionable when its own blockers finish, even while earlier milestones have open work. Identify the unblocked execution **frontier** for concurrent agents. For wide mechanical refactors that cannot land green as vertical slices, use ordered expand–migrate–contract tickets.

### 4. Review with the user

Present the selected primary source and the complete proposal in milestone order. For each milestone show existing/new status; for each ticket show title, existing/new status, blockers, opening user story, delivered outcome, acceptance criteria, executor (`Agent` or `Human`), labels, and source provenance. Include the proposed estimate and brief rationale for every new or edited ticket, explicitly identifying changes to existing estimates and any provisional scale assumption. Explicitly show omitted or narrowed overlaps and the initial frontier of independent agent tickets.

Ask the user to approve milestone names/order, ticket order, granularity, user stories, dependencies, overlap decisions, criteria, labels, applicable estimates, provenance, and parallel frontier. Do not publish until explicitly approved.

### 5. Publish and verify

Immediately before publication, refresh the complete scoped inventory and reconcile new overlaps and occupied numbers through `linear-ticket`. Create missing milestones in approved chronological order, preserving reused milestone names unless their changes were approved. Publish missing tickets through `linear-ticket`, milestone-by-milestone and ascending by title number, passing Backlog as the required initial state, all approved fields and per-issue mutations. Leave reused issues without approved edits untouched.

After every issue exists, perform `linear-ticket`'s separate native relation pass across the complete approved graph. Include every new issue and every reused issue with approved relation changes. Reconcile and verify all direct edges, including cross-milestone dependencies, against the full proposal.

Use Linear's native milestone/issue reordering capability when available. Otherwise creation order plus numeric titles is the source of truth; verify the returned order and clearly report any manual Linear reorder still required. Never invent milestone target dates merely to force ordering.

Apply `linear-ticket`'s saved-field, estimate, description and numbering verification to every new or approved edited issue. Re-read saved milestone names and verify the complete order against the approved proposal; surface unapproved legacy conflicts. Correct in-scope mismatches before reporting publication results and unresolved failures.

End with plain text `Milestone order: <first> → <second> → <third>` followed by issue identifiers/URLs in that same milestone and ascending-number order. Then write `Parallel frontier: <issues>` listing unblocked `Agent` tickets that separate agents can implement concurrently, or `Parallel frontier: none`.

© PinguApps · MIT · PinguApps/Skills

Similar skills

All skills for Notes, tasks and projects →

From the same set5

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor