# Linear

> Use when working with Linear issues — browse backlog, triage, plan implementations, propose improvements, and execute. Orchestrates subagents for context-efficient issue processing.

- **Type:** Skill
- **Install:** `agentstack add skill-twanahc-claude-linear-skill-claude-linear-skill`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [twanahc](https://agentstack.voostack.com/s/twanahc)
- **Installs:** 0
- **Category:** [Productivity](https://agentstack.voostack.com/c/productivity)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [twanahc](https://github.com/twanahc)
- **Source:** https://github.com/twanahc/claude-linear-skill

## Install

```sh
agentstack add skill-twanahc-claude-linear-skill-claude-linear-skill
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Linear Issue Workflow

## Overview

Orchestrate Linear issue workflows: browse your backlog, pick issues, create implementation plans, and execute them — all while keeping your main context clean via subagents.

## Prerequisites

- `LINEAR_API_KEY` environment variable must be set
- Get your key at: Linear Settings → API → Create Key
- `export LINEAR_API_KEY="lin_api_..."`

## API Script

All Linear API calls go through:

```bash
bun ~/.claude/skills/linear/scripts/linear-api.ts 
```

Commands:
- `list-teams` — discover teams
- `list-projects [--team KEY]` — list projects (optionally by team)
- `list-states --team KEY` — workflow states for a team
- `list-issues --team KEY --status NAME --assignee NAME --label NAME --limit N`
- `get-issue IDENTIFIER` — full issue details (e.g., BLU-42)
- `search-issues ` — full-text search
- `create-issue --title T --team KEY --description D --priority 0-4 --label L --project P --assignee A --parent ID`
- `update-issue IDENTIFIER --priority N --assignee A --label L --project P --title T --description D`
- `update-status IDENTIFIER "State Name"`
- `add-comment IDENTIFIER "comment body"`

## Workflow

```dot
digraph linear_workflow {
    rankdir=TB;
    "User invokes /linear" [shape=doublecircle];
    "Browse, specific, or propose?" [shape=diamond];
    "Spawn linear-triage subagent" [shape=box];
    "User provides issue IDs" [shape=box];
    "Spawn linear-propose subagent" [shape=box];
    "Present proposals to user" [shape=box];
    "User picks proposals to create?" [shape=diamond];
    "Create Linear issues" [shape=box];
    "For each issue: spawn linear-plan subagent" [shape=box];
    "Present plans to user" [shape=box];
    "User approves plans?" [shape=diamond];
    "For each plan: spawn linear-implement subagent" [shape=box];
    "Summarize results" [shape=doublecircle];

    "User invokes /linear" -> "Browse, specific, or propose?";
    "Browse, specific, or propose?" -> "Spawn linear-triage subagent" [label="browse"];
    "Browse, specific, or propose?" -> "User provides issue IDs" [label="specific"];
    "Browse, specific, or propose?" -> "Spawn linear-propose subagent" [label="propose"];
    "Spawn linear-propose subagent" -> "Present proposals to user";
    "Present proposals to user" -> "User picks proposals to create?";
    "User picks proposals to create?" -> "Create Linear issues" [label="yes"];
    "Create Linear issues" -> "For each issue: spawn linear-plan subagent";
    "Spawn linear-triage subagent" -> "For each issue: spawn linear-plan subagent";
    "User provides issue IDs" -> "For each issue: spawn linear-plan subagent";
    "For each issue: spawn linear-plan subagent" -> "Present plans to user";
    "Present plans to user" -> "User approves plans?";
    "User approves plans?" -> "Present plans to user" [label="revise"];
    "User approves plans?" -> "For each plan: spawn linear-implement subagent" [label="yes"];
    "For each plan: spawn linear-implement subagent" -> "Summarize results";
}
```

### Step 1: Determine Scope

Ask the user:
- **Browse backlog**: "Let me look through your issues and help you pick" → Spawn a **linear-triage** subagent
- **Specific issues**: User provides issue IDs (e.g., "BLU-42, BLU-57") → Skip to Step 2
- **Propose improvements**: "Analyze the codebase and suggest things to add/fix/improve" → Go to Step 1b

### Step 1b: Propose (if "propose" selected)

Spawn a **linear-propose** subagent using the Task tool:

```
Task tool:
  subagent_type: general-purpose
  prompt: |
    You are a Linear proposal agent. Read and follow the skill instructions at:
    ~/.claude/skills/linear/linear-propose/SKILL.md

    Team key: 
    Focus area: 
    Project root: 

    The Linear API script is at: ~/.claude/skills/linear/scripts/linear-api.ts
    Run it with: source ~/.bashrc && bun ~/.claude/skills/linear/scripts/linear-api.ts 
```

When the subagent returns proposals:
1. Present the proposals to the user in a clean table
2. Ask which proposals to create as Linear issues
3. For each approved proposal, create a Linear issue using the API script
4. The user can then optionally proceed to Step 2 (Plan) with the newly created issues

### Step 2: Plan

For each selected issue, spawn a **linear-plan** subagent using the Task tool:

```
Task tool:
  subagent_type: general-purpose
  prompt: |
    You are a Linear planning agent. Read and follow the skill instructions at:
    ~/.claude/skills/linear/linear-plan/SKILL.md

    Issue to plan: 
    Project root: 

    The Linear API script is at: ~/.claude/skills/linear/scripts/linear-api.ts
    Run it with: source ~/.bashrc && bun ~/.claude/skills/linear/scripts/linear-api.ts 
```

**Parallelism decision:**
- Independent issues (different areas of codebase) → spawn plan subagents **in parallel**
- Overlapping issues (same files/modules) → run **serially**
- Ask the user if unsure

### Step 3: Review Plans

Present each plan summary to the user. Wait for explicit approval before proceeding.

### Step 4: Implement

For each approved plan, spawn a **linear-implement** subagent using the Task tool:

```
Task tool:
  subagent_type: general-purpose
  prompt: |
    You are a Linear implementation agent. Read and follow the skill instructions at:
    ~/.claude/skills/linear/linear-implement/SKILL.md

    Issue: 
    Plan:
    

    Project root: 
    Main repo root: 

    The Linear API script is at: ~/.claude/skills/linear/scripts/linear-api.ts
    Run it with: source ~/.bashrc && bun ~/.claude/skills/linear/scripts/linear-api.ts 

    MANDATORY: You MUST pull latest from main and work in a git worktree.
    Never work directly on main. The skill instructions explain the setup.
```

Same parallelism rules as Step 2. Worktrees are mandatory — each implementation subagent creates its own worktree automatically per `linear-implement` Step 1.

### Step 5: Summary

After all subagents complete:
- Summarize what was implemented
- List any follow-up issues created
- Report any failures or blockers

## Context Strategy

**The orchestrator (you) should hold minimal context:**
- Issue identifiers and one-line summaries only
- Delegate all codebase exploration to subagents
- Delegate all code writing to subagents
- Only hold plan summaries (not full plans) after Step 2

This keeps the main context clean for processing many issues in one session.

## Important

- **Auto-set "In Progress"**: When an issue is selected for planning or implementation, immediately set it to "In Progress" — no confirmation needed. Picking an issue = starting work.
- **Confirm before closing**: Never auto-close or mark issues "Done" — always let the user decide when to close.
- If a subagent encounters blockers, surface them to the user immediately
- Announce write operations (create issue, update status, add comment) before executing them

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [twanahc](https://github.com/twanahc)
- **Source:** [twanahc/claude-linear-skill](https://github.com/twanahc/claude-linear-skill)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-twanahc-claude-linear-skill-claude-linear-skill
- Seller: https://agentstack.voostack.com/s/twanahc
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.