Agent skill

linear-plan-mode

Maintains feature plans in Linear during Claude Code plan mode. The orchestrator creates and updates Linear issues directly using MCP tools. Use when in plan mode, planning features, or creating implementation plans that should be tracked in Linear.

Stars 2
Forks 0

Install this agent skill to your Project

npx add-skill https://github.com/jclfocused/claude-agents/tree/main/skills/linear-plan-mode

SKILL.md

Linear Plan Mode Integration

When in plan mode, maintain the plan in Linear alongside the plan file. The orchestrator handles all Linear operations directly — never delegate to sub-agents for issue creation or updates.

CRITICAL RULES (ALWAYS FOLLOW)

  1. ALL issues (parent and sub-issues) MUST have status "Todo" - Never use "Triage", "Backlog", or any other status for new issues
  2. Parent issues MUST have the "Feature Root" label - NOT "Feature", always "Feature Root"
  3. Never modify "Done" issues - They represent completed work
  4. Check Linear teams first - If multiple teams exist, ALWAYS ask the user which team to use before creating issues
  5. Orchestrator does ALL Linear work directly - Do NOT spawn sub-agents for Linear operations. ToolSearch and MCP tools work in plan mode.

Key Principle

All Linear MCP tools work in plan mode. The orchestrator can call ToolSearch, mcp__linear__create_issue, mcp__linear__update_issue, and mcp__linear__get_issue directly. No delegation needed.

Workflow

Phase 1: Plan Mode Entry

When entering plan mode for any task:

  1. Ask the user if this plan should be tracked in Linear
  2. If yes, load Linear tools directly:
    ToolSearch: "+linear create issue"
    
  3. Check for existing parent issue using mcp__linear__get_issue (if issue ID is known) or mcp__linear__search_issues
  4. If no existing issue, create one directly:
    mcp__linear__create_issue(
      title: "[feature title]",
      team: "LaserFocused",
      state: "Todo",
      labels: ["Feature Root"],
      description: "[plan overview]"
    )
    

Phase 2: Plan Development (Sync as You Go)

As you write/edit the plan file, keep Linear in sync by calling MCP tools directly:

Plan File Change Linear Action
New section added mcp__linear__create_issue with parentId
Section modified mcp__linear__update_issue with updated description
Section removed mcp__linear__update_issue to set state "Canceled" (with user confirmation)

Example — creating a sub-issue directly:

mcp__linear__create_issue(
  title: "[Backend] Add student results API endpoint",
  team: "LaserFocused",
  parentId: "<parent-uuid>",
  state: "Todo",
  description: "## Acceptance Criteria\n- [ ] GET endpoint returns student answers\n- [ ] Includes audio URLs\n\n## Depends on\nLAS-XXX (migration)"
)

Phase 3: Plan Finalization

Before calling ExitPlanMode:

  1. Ensure all plan sections have corresponding Linear sub-issues
  2. Parent issue has high-level overview with Mermaid diagram
  3. All sub-issues are in "Todo" status ready for execution
  4. Sub-issue IDs are recorded in the plan file

Linear Issue Structure

Parent Issue (Feature Root)

Parent issues MUST have the "Feature Root" label and follow this structure:

markdown
## IMPORTANT
This feature is tracked in Linear. Before starting work:
- Find your assigned sub-issue
- Mark it "In Progress" before coding
- Mark it "Done" when complete

## Problem
[What problem we're solving]

## Solution Overview
[High-level approach - 2-3 paragraphs max]

## High-Level Flow
```mermaid
flowchart TD
    A[User Action] --> B[System Response]
    B --> C[Result]

MVP Scope

In Scope:

  • [Essential item 1]
  • [Essential item 2]

Out of Scope (Deferred):

  • [Nice-to-have 1]
  • [Nice-to-have 2]

Sub-Issues

[Auto-generated list of child issues]


### Sub-Issues (Tagged by Layer)

Each sub-issue title is prefixed with its layer tag:

| Tag | Meaning |
|-----|---------|
| `[Backend]` | Express API, services, repositories |
| `[Frontend]` | React components, pages, hooks |
| `[Migration]` | Database schema changes |
| `[Both]` | Spans backend and frontend |

Sub-issue description format:
```markdown
## Context
[Brief context linking to parent feature]

## Acceptance Criteria
- [ ] Criterion 1
- [ ] Criterion 2

## Technical Notes
[Implementation hints, patterns to follow]

## Dependencies
Depends on: LAS-XXX (if applicable)

Mermaid Diagrams

Use diagrams to visualize flows and relationships:

Context Diagram Type When to Use
Parent issue flowchart TD Main user/data flow (REQUIRED)
API endpoints sequenceDiagram Service interactions
State machines stateDiagram-v2 Status workflows
Data models erDiagram Entity relationships

For detailed templates, see mermaid-templates.md.

Key Constraints

  • Orchestrator does ALL Linear work — never delegate to sub-agents or linear-manager for issue creation
  • Never modify "Done" issues — They represent completed work
  • Confirm before canceling — Ask user before canceling "In Progress" issues
  • Todo status only — ALL new issues MUST start as "Todo"
  • "Feature Root" label (not "Feature") — Parent issues ALWAYS get the "Feature Root" label
  • linear-manager is for implementation only — It tracks status during Phase 5, not during planning

Quick Reference

Load Linear tools:

ToolSearch: "+linear create issue"

Create parent issue:

mcp__linear__create_issue(
  title: "Feature title",
  team: "LaserFocused",
  state: "Todo",
  labels: ["Feature Root"],
  description: "[plan overview with mermaid diagram]"
)

Create sub-issue:

mcp__linear__create_issue(
  title: "[Backend] Step description",
  team: "LaserFocused",
  parentId: "<parent-uuid>",
  state: "Todo",
  description: "[acceptance criteria + dependencies]"
)

Update issue:

mcp__linear__update_issue(
  issueId: "<uuid>",
  description: "[updated content]"
)

For detailed sync patterns, see sync-patterns.md.

Expand your agent's capabilities with these related and highly-rated skills.

jclfocused/claude-agents

graphite-workflow

Use this skill when working with Graphite (gt) for stacked PRs, using execute-issue-graphite agent, or when the user mentions Graphite, stacking, or gt commands. Ensures proper use of gt commands instead of raw git for stack-aware operations.

2 0
Explore
jclfocused/claude-agents

vertical-slice-planning

Use this skill when discussing feature breakdown, PR structure, implementation ordering, or how to decompose work. Guides thinking about vertical slices (end-to-end functionality) rather than horizontal layers (all of one layer first). Triggers on "how should we break this down?", "what order should we implement?", "how many PRs?", or decomposition discussions.

2 0
Explore
jclfocused/claude-agents

issue-writing

Use this skill when writing, reviewing, or discussing issue descriptions, acceptance criteria, or task breakdowns. Ensures consistent, high-quality issue structure that any developer or AI can pick up and execute. Triggers when drafting issues, defining requirements, or when users ask "how should I write this issue?" or "what should the acceptance criteria be?"

2 0
Explore
jclfocused/claude-agents

mvp-scoping

Use this skill when discussing features, planning work, or when users describe what they want to build. Guides MVP thinking - focusing on "what's the minimum to make this work?" rather than comprehensive solutions. Triggers on phrases like "help me think through this feature", "what should we build first?", "how should we scope this?", or any feature planning discussion.

2 0
Explore
jclfocused/claude-agents

atomic-design-planning

Use this skill when discussing UI components, design systems, frontend implementation, or component architecture. Guides thinking about Atomic Design methodology - atoms, molecules, organisms - and promotes component reuse over creation. Triggers on UI/frontend discussions, "what components do we need?", "should I create a new component?", or design system questions.

2 0
Explore
jclfocused/claude-agents

linear-discipline

Use this skill when discussing code changes, implementation work, feature status, or when starting/completing development tasks. Reminds about Linear issue tracking discipline - always having an issue in progress before writing code, marking work as done, and creating issues for unexpected scope. Triggers when users mention implementing features, writing code, or checking on work status.

2 0
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results