# Quick Start

> Zero-friction backlog-to-implementation. Takes a backlog item, analyzes codebase, creates plan + sub-issues, and starts work immediately.

- **Type:** Skill
- **Install:** `agentstack add skill-imtaegan-claude-saas-flow-quick-start`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [ImTaegan](https://agentstack.voostack.com/s/imtaegan)
- **Installs:** 0
- **Category:** [Developer Tools](https://agentstack.voostack.com/c/developer-tools)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [ImTaegan](https://github.com/ImTaegan)
- **Source:** https://github.com/ImTaegan/claude-saas-flow/tree/main/skills/quick-start

## Install

```sh
agentstack add skill-imtaegan-claude-saas-flow-quick-start
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# 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:

```markdown
# [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:**
```markdown
[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:

```bash
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](https://github.com/ImTaegan)
- **Source:** [ImTaegan/claude-saas-flow](https://github.com/ImTaegan/claude-saas-flow)
- **License:** MIT

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

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-imtaegan-claude-saas-flow-quick-start
- Seller: https://agentstack.voostack.com/s/imtaegan
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.