Skip to content
Skills Library
Management & product · Planning

linear-ready

/linear-ready

Find Linear issues ready for an AI agent to pick up. Equivalent of `bd ready` for Linear workflows. Use when starting a session to find claimable work, or when asked "what's next" or "find work".

Repository
ai-config ↗
Licence
GPL-3.0
Last repository change
08.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
2
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

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

Licence

GPL-3.0, otwarta.

What it does and when to use it

Find Linear issues ready for an AI agent to pick up. Equivalent of `bd ready` for Linear workflows. Use when starting a session to find claimable work, or when asked "what's next" or "find work".

Triggers from the description

whator
Original author description

Find Linear issues ready for an AI agent to pick up. Equivalent of `bd ready` for Linear workflows. Use when starting a session to find claimable work, or when asked "what's next" or "find work".

How it works

  1. Prerequisites
  2. How It Works
  3. Label Convention
  4. Usage
  5. Agent Workflow
  6. Output Formats
Original SKILL.md headings · 158 lines, 598 words
SKILL.md preview
---
name: linear-ready
description: Find Linear issues ready for an AI agent to pick up. Equivalent of `bd ready` for Linear workflows. Use when starting a session to find claimable work, or when asked "what's next" or "find work".
---

# Linear Ready

Find Linear issues that are ready for an AI agent to work on — meaning
they match your filters and have no active (unresolved) blockers.

This is the Linear equivalent of `bd ready` in beads workflows.

## Prerequisites

1. **linear-cli** must be installed and authenticated:

   ```bash
   brew install schpet/tap/linear   # or: npm install -g @schpet/linear-cli
   linear auth login
   ```

2. **jq** must be available on PATH.

## How It Works

The script runs a **single GraphQL query** via `linear api` that fetches
candidate issues along with their blocking relations and blocker states.
It then filters client-side with `jq`:

- An issue is **ready** if it has no `blockedBy` relations pointing to
  incomplete issues (i.e. all blockers are in a `completed`, `canceled`,
  or `duplicate` state).
- An issue is **blocked** if any of its blockers are still active.

## Label Convention

Issues suitable for AI agent work should be tagged with the **"AI"** label
in Linear. This is the default filter; override with `--label`.

## Usage

Run the script from this skill's directory:

```bash
.agents/skills/linear-ready/scripts/linear-ready [OPTIONS]
```

### Options

| Flag                | Description                                      | Default            |
| ------------------- | ------------------------------------------------ | ------------------ |
| `--team <key>`      | Filter by team key (e.g. "ENG")                  | all teams          |
| `--label <name>`    | Label to filter for                              | `AI`               |
| `--project <name>`  | Filter by project name                           |                    |
| `--assignee <name>` | Filter by assignee display name                  |                    |
| `--unassigned`      | Show only unassigned issues                      |                    |
| `--priority <1-4>`  | Filter by priority (1=Urgent..4=Low)             |                    |
| `--limit <n>`       | Max results                                      | `50`               |
| `--state <types>`   | Comma-separated state types to include           | `backlog,unstarted` |
| `--include-blocked` | Include blocked issues in output                 |                    |
| `--json`            | JSON output for agent consumption                |                    |

### Examples

```bash
# Find all ready AI issues
linear-ready

# Find ready issues for a specific team
linear-ready --team ENG

# Find ready issues in a specific project
linear-ready --team ENG --project "Auth Rewrite"

# Find unassigned ready issues (good for picking up new work)
linear-ready --unassigned

# JSON output for programmatic use
linear-ready --json

# Include blocked issues to see the full picture
linear-ready --include-blocked

# Use a different label instead of "AI"
linear-ready --label "agent-ready"
```

## Agent Workflow

When starting a session or looking for work:

1. **Find ready work:**

   ```bash
   linear-ready --team ENG --json
   ```

2. **Pick an issue** — choose the highest priority unblocked issue from
   the output.

3. **Read the issue description** for full context:

   ```bash
   linear issue view ENG-42 --json
   ```

4. **Start work** — update the issue state to "In Progress":

   ```bash
   linear issue update ENG-42 -s started
   ```

   Or use `linear issue start ENG-42` which also creates a git branch.

5. **Implement** the task following the issue's acceptance criteria.

6. **Complete** — update the issue state when done:

   ```bash
   linear issue update ENG-42 -s completed
   ```

## Output Formats

### Pretty (default)

```
Ready issues (label: AI):

  ENG-42  [High]    Add display_name to user profile
          State: Todo | Project: User Features | Unassigned

  ENG-45  [Normal]  Fix auth token refresh race condition
          State: Todo | Assigned: alice

Blocked: 2 issue(s) hidden (use --include-blocked to show)
```

### JSON (`--json`)

```json
{
  "ready": [
    {
      "identifier": "ENG-42",
      "title": "Add display_name to user profile",
      "priority": 2,
      "priorityLabel": "High",
      "url": "https://linear.app/...",
      "state": { "name": "Todo", "type": "unstarted" },
      "assignee": null,
      "project": { "name": "User Features" },
      "activeBlockers": []
    }
  ],
  "blockedCount": 2
}
```

With `--include-blocked --json`, the full `blocked` array is included
with each issue's `activeBlockers` list showing what's blocking it.
Files in this package (2)
  • SKILL.md 5 KB
  • scripts/linear-ready 9 KB

Versions

The database has no other skills named linear-ready.

Database snapshot: 13.11.2026 · package version 14686d354ed1 (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

  • 100plan-to-linear
    Decompose an approved implementation plan into self-contained Linear issues with zero guesswork. Use when breaking down a plan into actionable Linear tasks via the MCP server.
  • 100use-linear-cli
    Use when driving Linear through linear-cli for issues, bulk operations, search, or git and PR workflows.
  • 96linear-project-management
    Use this skill when driving Linear projects and issues from an agent.
  • 95linear-issue-sync
    Sync Linear issues with local tasks. Use during daily planning or when user asks about Linear issues.
  • 95linear
    Manage issues, projects & team workflows in Linear. Use when the user wants to read, create or updates tickets in Linear.
  • 100cds-linear-issue-shaping
    Convert a plan of record into Linear-ready issues with dependencies, acceptance criteria, and sequencing. Use when a reviewed plan needs to become executable work in Linear.

Feedback and reports

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