Ticket Planning Workflow

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