Ticket Planning Workflow Skill

Transform Linear tickets into actionable implementation plans through systematic investigation and collaborative planning.

Purpose

Transform uncertainty into clarity by:

• •Gathering complete ticket context from Linear
• •Exploring relevant codebase sections
• •Identifying patterns and conventions
• •Asking targeted clarifying questions
• •Creating detailed, actionable implementation plans

Planning Methodology

Phase 1: Ticket Intelligence Gathering

Fetch and Parse Ticket

# Get complete ticket information
mcp__linear__get_issue --id "$ticket_id"

Extract Structured Information

Parse from ticket:

• •Type: Feature/Bug/Chore (from labels)
• •Priority: Urgency level
• •Acceptance Criteria: From description checkboxes
• •Related Context: Parent tickets, dependencies, blockers
• •Discussion Points: Key decisions from comments

Identify Unclear Items

Flag for clarification:

• •Ambiguous requirements
• •Missing acceptance criteria
• •Architectural decisions needed
• •Scope boundaries unclear

Phase 2: Deep Codebase Exploration

Step 1: Broad Search

# Find existing related code
rg "keyword" --type ts --files-with-matches

# Find similar implementations
rg "pattern-keyword" --type ts -A 5

Step 2: Understand Architecture

For each relevant file:

• •Document current implementation
• •Note patterns used
• •Identify extension points
• •Check for project-specific requirements

Step 3: Find Patterns to Follow

Extract from codebase:

• •Error handling: Common patterns
• •Entity pattern: Data structures
• •Route pattern: API organization
• •Service pattern: Business logic organization

Step 4: Check Project Guidelines

# Review CLAUDE.md for requirements
cat CLAUDE.md | grep -A 10 "relevant-section"

Phase 3: Collaborative Clarification

Question Framework

Present 2-4 questions at a time with:

• •Context: What you found in codebase
• •Options: Concrete choices (A/B/C)
• •Recommendation: Your suggested approach
• •Trade-offs: Pros/cons of each

Format:

### Question: [Topic]

**Context**: [What codebase exploration revealed]

**Options**:
A) **[Option Name]** - [Description]
   - Pros: [Benefits]
   - Cons: [Drawbacks]

B) **[Option Name]** - [Description]
   - Pros: [Benefits]
   - Cons: [Drawbacks]

**Recommendation**: Option [X] because [reasoning]

**Your choice?** (A/B)

Phase 4: Implementation Plan Generation

High-Level Overview

# Implementation Plan: {ticket-id} - {title}

## Overview
[1-2 sentence summary]

## Approach
[3-5 bullet points on technical approach]

## Decisions
[List of decisions made during clarification]

## Complexity
[Simple/Moderate/Complex with justification]

Implementation Steps

For each step:

### Step N: [Title] (Est. complexity)
**What**: [Brief description]
**File(s)**: [Paths]

**Key points**:
- [Critical implementation detail]
- [Pattern to follow]

**Dependencies**: Step [X]
**Testing**: [How to verify]

Testing Strategy

Define:

• •Unit tests: Coverage goals, test categories
• •Integration tests: Key scenarios
• •Manual testing: Verification checklist

Risk Assessment

Success Criteria

Checklist covering:

• • Functional requirements
• • Technical requirements
• • Testing requirements
• • Documentation requirements

Phase 5: Git Strategy

## Git Strategy

**Branch**: {type}/{ticket-id}-{sanitized-title}
**Base**: main or staging

**Commits** (logical units):
1. `feat({ticket}): [description]`
2. `test({ticket}): [description]`
3. `docs({ticket}): [description]`

Integration

Used by agents:

• •linear-ticket-planner - Autonomous ticket planning
• •linear-ticket-creator - Ticket creation with exploration

Quality Checklist

Before completing plan:

• • Ticket requirements fully understood
• • Codebase exploration thorough
• • All clarifying questions asked
• • Implementation steps are actionable
• • Testing strategy is comprehensive
• • Risks identified and mitigated
• • Success criteria clear and measurable
• • Git strategy defined