Skip to content
Skills Library
Management & product · Planning

linear-workflow

/linear-workflow

Configures a Linear team end to end - team structure, minimal workflow states, cycles, a small label taxonomy, a daily triage rotation, and priority SLAs with breach views. Use when someone asks "set up Linear for my team", "how should we structure teams and labels in Linear", "our Linear backlog is a mess", or "how do we handle inbound bugs in Linear". Do NOT use for writing the tickets themselves - acceptance criteria, story points, Definition of Ready - use jira-ticket-writer instead (its ticket anatomy applies to Linear issues too). For deciding sprint scope and capacity, use sprint-planni

Repository
skills ↗
Licence
MIT
Last repository change
13.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 13.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Configures a Linear team end to end - team structure, minimal workflow states, cycles, a small label taxonomy, a daily triage rotation, and priority SLAs with breach views. Use when someone asks "set up Linear for my team", "how should we structure teams and labels in Linear", "our Linear backlog is a mess", or "how do we handle inbound bugs in Linear". Do NOT use for writing the tickets themselves - acceptance criteria, story points, Definition of Ready - use jira-ticket-writer instead (its ticket anatomy applies to Linear issues too). For deciding sprint scope and capacity, use sprint-planni

Triggers from the description

set up Linear for my teamhow should we structure teams and labels in Linearour Linear backlog is a messhow do we handle inbound bugs in Linear
Original author description

Configures a Linear team end to end - team structure, minimal workflow states, cycles, a small label taxonomy, a daily triage rotation, and priority SLAs with breach views. Use when someone asks "set up Linear for my team", "how should we structure teams and labels in Linear", "our Linear backlog is a mess", or "how do we handle inbound bugs in Linear". Do NOT use for writing the tickets themselves - acceptance criteria, story points, Definition of Ready - use jira-ticket-writer instead (its ticket anatomy applies to Linear issues too). For deciding sprint scope and capacity, use sprint-planni

How it works

  1. Inputs to collect
  2. Operating procedure
  3. Worked artifact: team setup spec
  4. Deliverable
  5. Do NOT
  6. Quality bar
  7. Related skills
Original SKILL.md headings · 133 lines, 1,124 words
SKILL.md preview
---
name: linear-workflow
description: Configures a Linear team end to end - team structure, minimal workflow states, cycles, a small label taxonomy, a daily triage rotation, and priority SLAs with breach views. Use when someone asks "set up Linear for my team", "how should we structure teams and labels in Linear", "our Linear backlog is a mess", or "how do we handle inbound bugs in Linear". Do NOT use for writing the tickets themselves - acceptance criteria, story points, Definition of Ready - use jira-ticket-writer instead (its ticket anatomy applies to Linear issues too). For deciding sprint scope and capacity, use sprint-planning.
metadata:
  title: "Linear Workflow"
---

# Linear Workflow

Linear rewards lightweight, opinionated process; teams that port over a heavyweight Jira scheme get the worst of both worlds - ceremony without clarity. This skill sets up a team so issues flow predictably from idea to done, and inbound noise never silts up the backlog.

## Inputs to collect

1. Delivery units: which groups actually ship together? (Squads, not departments.)
2. Team size and count - decides whether sub-teams are justified yet.
3. Inbound volume: roughly how many bugs/requests arrive per week, and from where.
4. Current cadence, if any (1- or 2-week sprints, or none). If unknown, default to 2-week cycles and label it a default.
5. The 3-5 product areas people already use in conversation ("auth", "billing") - these become area labels.

## Operating procedure

Do the steps in order: states before cycles (cycles report on states), labels before triage (triage applies labels), triage before SLAs (SLAs are measured from triage decisions).

### Step 1: Team structure

- Create one **team per delivery unit** - a squad that ships together - not per function. A "Frontend team" and "Backend team" split guarantees every feature spans two boards.
- Keep team identifiers short (`ENG`, `WEB`) - they prefix every issue ID.
- Avoid sub-teams early; split only when a single team's backlog is genuinely unmanageable, which rarely happens under ~10 people.

### Step 2: Workflow states

Keep states minimal and meaningful. Five working states plus one terminal branch:

```
Backlog -> Todo -> In Progress -> In Review -> Done
                                        |
                                    Canceled
```

- **Backlog**: real but not committed.
- **Todo**: committed to the current cycle.
- **In Progress**: actively worked. Limit WIP to one or two per person - a third concurrent issue is a queue wearing a disguise.
- **In Review**: PR open, awaiting review.
- **Done / Canceled**: terminal. Canceled is a decision, not a failure; use it freely.

Every state beyond these needs a written answer to "what decision happens here?" - a state without a decision is a place issues go to die.

### Step 3: Cycles

- Enable cycles with a fixed cadence - 1 or 2 weeks. Pick one and keep it; switching cadence resets every velocity trend.
- Let unfinished issues **auto-roll** to the next cycle so nothing is silently lost.
- Use cycle velocity (completed issues/points) to forecast, never to punish. The moment velocity becomes a target, it gets gamed and stops meaning anything.
- Review the cycle graph at each cycle's end for two smells: scope creep (line rising mid-cycle) and chronic carryover (same issues rolling 3+ cycles - cancel or split them).

### Step 4: Labels

Small, structured taxonomy in label groups:

- **Type**: `bug`, `feature`, `chore`, `tech-debt` - exactly one per issue.
- **Area**: `area/auth`, `area/billing`, … - the 3-5 surfaces from your inputs.
- **Priority is a built-in field** (Urgent/High/Medium/Low) - use it; never duplicate it as labels.

Rule of thumb: if a label is not used in at least one filter or saved view, delete it. Ten labels that drive views beat forty that decorate.

### Step 5: Triage

Turn on **Triage** for all inbound (bugs, requests, integrations):

1. New issues land in Triage, unassigned.
2. A rotating triage owner (rotate weekly with on-call if you have one) reviews daily. For each issue: validate it is real and non-duplicate, apply Type + Area labels, set priority, then assign / move to Backlog or Todo / close as won't-fix.
3. Nothing sits in Triage longer than one business day. Triage is a decision point, not a holding pen.

### Step 6: SLAs

Encode response targets by priority:

- **Urgent**: acknowledged < 1 hour, In Progress the same day.
- **High**: triaged < 1 business day, scheduled into a cycle within the week.
- **Medium/Low**: triaged < 3 business days, scheduled when capacity allows.

Build saved views that surface breaches so nobody has to remember to check - e.g. "Urgent + not started".

### Step 7: Saved views

Create at minimum:

- **My active issues** - assignee = me, state In Progress / In Review.
- **Needs triage** - state = Triage (the triage owner's homepage).
- **Cycle at risk** - current cycle + priority High/Urgent + not Done.
- **SLA breach** - Urgent older than 1h unacknowledged, High untriaged past 1 day.

## Worked artifact: team setup spec

Copy, fill, and execute in Linear settings top to bottom:

```
LINEAR TEAM SETUP - [FILL: team name] ([FILL: 3-letter identifier])

States: Backlog / Todo / In Progress / In Review / Done / Canceled
WIP limit (social contract): [FILL: 1 or 2] per person in In Progress

Cycles: [FILL: 1 or 2] weeks, auto-roll unfinished ON, start day [FILL]

Label groups:
  type/     bug, feature, chore, tech-debt
  area/     [FILL: 3-5 areas, e.g. auth, billing, api]

Triage: ON. Owner rotation: [FILL: names, weekly]. Max dwell: 1 business day.

SLAs: Urgent ack <1h, in progress same day
      High triaged <1d, in cycle within week
      Med/Low triaged <3d
Views: My active issues / Needs triage / Cycle at risk / SLA breach
```

## Deliverable

Produce a filled team setup spec (above) plus the list of saved views with their exact filters - everything an admin needs to configure the team in one sitting, and the two social contracts (WIP limit, triage dwell time) written where the team will see them.

## Do NOT

- Do not add workflow states to model every nuance - each extra state is a place issues stall, because no one owns moving things out of it.
- Do not skip triage because volume is low today - the backlog fills with unvalidated noise precisely because no one notices it happening.
- Do not treat velocity as a target - it becomes gamed and meaningless within two cycles.
- Do not duplicate priority as labels - two sources of truth for urgency guarantees they disagree.
- Do not create teams per function - cross-team dependencies on every feature is the predictable result.

## Quality bar

- Five working states, and every additional state has a written decision it represents.
- Every label appears in at least one filter or saved view.
- Triage has a named rotation and nothing older than one business day sitting in it.
- The four core saved views exist and open to non-empty, correct results.
- SLA breaches are visible in a view, not dependent on memory.

## Related skills

The issues flowing through this workflow still need to be well written - user story, testable acceptance criteria, sane sizing. That anatomy lives in jira-ticket-writer and applies verbatim to Linear issues. Sprint scoping and capacity questions go to sprint-planning; if inbound is dominated by incidents rather than requests, pair triage with sev-triage.

Versions

The database has no other skills named linear-workflow.

Database snapshot: 13.11.2026 · package version 43f0b30496c3 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100jira-ticket-writer
    Writes ready-to-build Jira stories with user-story summaries, Given/When/Then acceptance criteria, subtasks, and story-point guidance, checked against INVEST and a Definition of Ready. Use when someone asks "write a Jira ticket for this", "turn these meeting notes into a story",…
  • 98linear-issue-tracking-best-practices
    Guides Linear's cycle-based workflow model — Issues, Projects, and time-boxed Cycles instead of Jira's sprint/board configuration, Linear's opinionated status workflow (Triage → Backlog → Todo → In Progress → In Review → Done/Cancelled), its keyboard-driven/low- friction issue…
  • 90linear
    Manage Linear issues, projects and cycles via the Linear MCP server. Use when the user wants to read, triage, create or update Linear tickets, plan a sprint, audit Linear documentation, or rebalance team workload.
  • 100triage
    Triage and prioritize Linear backlog issues using the linear CLI. Analyzes staleness, blockers, dependency health, and priority mismatches. Use when the user asks about backlog grooming, sprint planning, issue prioritization, managing stale tickets, or cleaning up Linear issues.
  • 100ops-linear
    OPS on-demand: This skill should be used when the user asks to \"linear sprint\", \"create a ticket\", or…
  • 100linear
    Manage Linear issues through Linear's hosted MCP server. Use when users ask to create a Linear ticket, update a Linear issue, add a Linear comment, move work between states, assign work, or look up Linear issue, team, or project details from Slack context.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.