Quick Start

Quick Start — Automated Backlog Implementation

Fastest path from "meeting note" to "working on it". Perfect for vague backlog items where you want Claude to figure out the details.

Project Configuration

Read project configuration from .claude/project.json in the current repository root:

• linear.teamId, linear.teamName, linear.projectId
• github.owner, github.repo, github.defaultBranch
• vercel.*

If .claude/project.json doesn't exist, suggest running /setup-project first.

Instructions for Claude

Expected Usage

/quick-start ABC-19

User provides an issue ID (must be in Backlog state). Claude handles everything else.

Step 1: Fetch and Validate Issue

Use mcp__linear__get_issue with provided ID

IMPORTANT: Read the FULL issue description. The get_issue response includes the complete description field — display and use the entire description, not just the first few lines. The description contains critical context, acceptance criteria, and requirements.

Validation:

• Issue exists
• Issue is in "Backlog" state
• Issue belongs to the correct project (read from .claude/project.json)

If validation fails:

❌ Cannot quick-start ABC-XX

Reason: [Issue doesn't exist / Not in Backlog / Wrong project / Already refined]

Suggestion:
- If not in Backlog: Use /new-feature instead
- If doesn't exist: Check Linear for correct ID
- If already refined: Use /new-feature to start work

If validation passes, display the FULL issue details:

🚀 Quick Starting: [Issue Title]

## Full Description:
[Display the COMPLETE issue description — every line, including
acceptance criteria, notes, links, and any other content. Do NOT
truncate or summarize.]

I'll:
1. Analyze the codebase
2. Create an implementation plan
3. Break into sub-tasks
4. Create the branch
5. Get you started

This will take 2-3 minutes. Sit tight!

Step 2: Codebase Analysis

Use the FULL issue description to drive the codebase analysis. Every detail — acceptance criteria, technical notes, referenced APIs — should inform what you search for.

Use the Task tool with subagent_type="Explore" and thoroughness="medium":

• Include the full issue description in the prompt
• Investigate architecture patterns, file structure, and component relationships
• Identify similar existing features to model after

Specific searches based on issue type:

For integrations (e.g., "Add Stripe integration"):

• Find existing integration setup, API client patterns, environment variable usage

For UI features (e.g., "Add reporting dashboard"):

• Component structure, routing patterns, data fetching hooks

For backend features (e.g., "Add audit logging"):

• Database models, API middleware, error handling patterns

Also check REFERENCES folder (if it exists in the project root):

Look for a REFERENCES/ directory in the project root and read any relevant files.

Step 3: Auto-Estimate Complexity

Based on analysis, automatically determine:

Priority (0-4):

• 1 (Urgent): Security, critical bugs, production issues
• 2 (High): Core features, user-facing improvements
• 3 (Normal): Standard features, nice-to-haves
• 4 (Low): Polish, edge cases, experiments

Size:

• Small: 1-2 hours ( 8 files, multiple APIs, complex logic)

Needs sub-tasks?

• Yes if: Large size, multiple integration points, > 1 day estimate
• No if: Small/Medium, straightforward implementation

Step 4: Create Implementation Plan

Use EnterPlanMode to create the plan.

Plan structure:

# [Feature Name] Implementation Plan

## Analysis Summary
- Current state: [What exists now]
- Similar features: [References to existing code]
- Integration points: [Where this connects]
- Estimated complexity: [Size + reasoning]

## Problem
[Clear statement of what we're solving]

## Solution Overview
[High-level approach based on codebase analysis]

## Sub-tasks Breakdown
1. [Sub-task 1] — [Brief description]
2. [Sub-task 2] — [Brief description]
... (5-8 sub-tasks max)

## Files to Create/Modify
- `path/to/file.ts` — [What changes]
- `path/to/component.tsx` — [What changes]

## Implementation Steps
[Detailed steps for each sub-task]

## Testing Strategy
[How to verify each piece works]

## Risks and Considerations
[Any gotchas or edge cases]

Step 5: Create All Sub-Issues in Parallel

After plan approval, create all sub-issues:

For each sub-task from plan:

Use mcp__linear__create_issue (in parallel when possible):
- team: [from .claude/project.json linear.teamName]
- project: [from .claude/project.json linear.projectId]
- title: [sub-task title]
- description: [detailed description from plan]
- parentId: [parent issue ID]
- labels: [auto-assigned based on type]
- state: "Todo"
- priority: [inherit from parent or adjust based on criticality]

Label assignment logic:

• "Feature" for new functionality
• "Bug" if fixing something
• "Improvement" if enhancing existing
• "Chore" for setup/config tasks
• Add "Size: Small/Medium/Large" to each

Typical sub-task structure:

1. Setup/Configuration (if needed)
2. Backend/API work
3. Database changes (if needed)
4. Frontend components
5. Integration/glue code
6. Testing
7. Documentation

Step 6: Update Parent Issue

Use mcp__linear__update_issue:
- id: [parent-id]
- description: [updated with plan summary + sub-tasks list]
- labels: ["Feature", priority label, size label]
- priority: [auto-estimated]
- state: "Todo"

Enhanced description format:

[Original description]

---

## Implementation Plan
[Brief summary of approach]

## Sub-tasks (X total)
- [ ] ABC-XX: [Sub-task 1]
- [ ] ABC-XX: [Sub-task 2]
...

**Estimated effort**: [Size]
**Key files**: `file1.ts`, `file2.tsx`

Step 7: Start Work Immediately

Create the branch:

git checkout -b feature/[ISSUE-ID]-[slugified-title]

Update parent to "In Progress":

Use mcp__linear__update_issue:
- id: [parent-id]
- state: "In Progress"
- assignee: "me"

Step 8: Display Summary and Next Steps

✅ Quick Start Complete!

## [Issue Title] (ABC-XX)

**Status**: In Progress
**Branch**: feature/ABC-XX-issue-title
**Estimated effort**: Large (2-3 days)

## Sub-tasks Created (8):
- [ ] ABC-21: Set up Stripe SDK configuration
- [ ] ABC-22: Create payment API endpoints
- [ ] ABC-23: Build payment UI components
- [ ] ABC-24: Add webhook handler
- [ ] ABC-25: Create payment history page
- [ ] ABC-26: Add error handling
- [ ] ABC-27: Write integration tests
- [ ] ABC-28: Update documentation

**View in Linear**: [Linear URL]

## Key Insights from Analysis:
- Similar pattern: [existing integration found]
- Reuse: [middleware/component identified]
- New files: [new directories needed]

## Suggested Starting Point:
**ABC-21: [first sub-task title]**

Ready to start? I can help with the first sub-task!

Optimizations and Smart Features

Pattern Recognition

Learn from existing code patterns. If adding Stripe, look at how other integrations were done. If adding a dashboard, look at existing pages.

Smart Sub-task Ordering

1. Setup (environment, packages)
2. Backend/API (foundation)
3. Database (if needed)
4. Frontend (uses backend)
5. Integration (connects pieces)
6. Testing (validates everything)
7. Docs (captures learnings)

Risk Detection

Flag potential issues:

• "⚠️ Breaking change" — if modifying existing APIs
• "⚠️ Migration needed" — if database changes
• "⚠️ Security sensitive" — if auth/payments/data
• "⚠️ Performance impact" — if large queries/operations

Parallel Execution

Create sub-issues in parallel (batch API calls) for speed.

Error Handling

Issue not found:

❌ Issue ABC-XX not found in Linear

Check the ID and try again.
Run `/feature-from-backlog` to see available backlog items.

Issue not in Backlog:

ℹ️  ABC-XX is already refined (status: Todo)

Use `/new-feature ABC-XX` to start work on it instead!

Sub-issue creation fails:

⚠️  Some sub-issues failed to create

Created: X of Y
Failed: [list]

You can create these manually in Linear, or I can retry.

Comparison with Other Skills

| Skill | Speed | Automation | User Input | Best For | |-------|-------|------------|------------|----------| | /quick-start | ⚡️ Fastest | 🤖 Full | ✋ Minimal | Meeting notes → work | | /feature-from-backlog | 🚶 Moderate | 🤝 Guided | 💬 Questions | Clarifying vague ideas | | /new-feature | 🏃 Fast | ⚙️ Semi-auto | 📋 Selections | Starting refined issues |

Best Practices

1. Use for vague backlog items — "Add Stripe" works great
2. Review the plan — Always check before implementation starts
3. Trust the analysis — Claude has context on your codebase
4. Adjust as needed — Sub-tasks can be modified in Linear

Integration with Other Skills

• After completion: Use /create-pr for pull request
• Check progress: Use /project-status
• If needs refinement: Use /feature-from-backlog instead

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: ImTaegan
• Source: ImTaegan/claude-saas-flow
• License: MIT

Install and usage instructions live in the source repository linked above.