launch-strategy

Use when you're preparing to launch a product or feature publicly — builds a structured checklist covering positioning, distribution, messaging, and success metrics from private beta to GA.

8 stars

Best use case

launch-strategy is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Use when you're preparing to launch a product or feature publicly — builds a structured checklist covering positioning, distribution, messaging, and success metrics from private beta to GA.

Teams using launch-strategy should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/launch-strategy/SKILL.md --create-dirs "https://raw.githubusercontent.com/drvoss/everything-copilot-cli/main/skills/product/launch-strategy/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/launch-strategy/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How launch-strategy Compares

Feature / Agentlaunch-strategyStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Use when you're preparing to launch a product or feature publicly — builds a structured checklist covering positioning, distribution, messaging, and success metrics from private beta to GA.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Launch Strategy

A product launch isn't a single event — it's a coordinated campaign with phases.
This skill structures your launch from private beta through public announcement,
ensuring nothing falls through the cracks.

## Launch Tiers

| Tier | Audience | Goal |
|------|----------|------|
| **Alpha** | Internal team only | Find critical bugs |
| **Private Beta** | Invited users | Validate product-market fit signal |
| **Public Beta** | Self-serve signup | Gather scale feedback, build pipeline |
| **GA Launch** | Everyone | Revenue growth, press, distribution |

## Pre-Launch Checklist

### Product Readiness

```text
> Evaluate our launch readiness against these criteria:
> - Core use case works end-to-end without errors
> - Onboarding is < 5 minutes to first value
> - Key user flows have error handling (not just happy path)
> - Performance is acceptable under expected load
> - Mobile/responsive works if applicable
```

### Positioning and Messaging

```text
> Help me write the positioning for [product/feature]:
>
> 1. One-liner: "[Product] is the [category] for [target customer] who [key need]"
> 2. Elevator pitch (3 sentences): What it does, who it's for, why now
> 3. Key benefits (3 bullets): Outcomes, not features
> 4. Differentiation: How are we different from [Competitor A] and [Competitor B]?
> 5. Proof point: What evidence do we have this matters to users?
```

### Distribution Channels

```text
> For [product type], help me identify the best launch channels:
>
> Our target users: [describe ICP]
> Budget: [free / paid / both]
> Existing audience: [email list size, Twitter followers, etc.]
>
> Prioritize channels by: reach, conversion likelihood, time-to-impact
```

Common channels to evaluate:

- Product Hunt (best for developer tools, B2C, SaaS)
- Hacker News: Show HN (best for technical audiences)
- Twitter/X product announcement thread
- LinkedIn article (B2B)
- Email to waitlist / existing users
- Partner newsletters / podcasts
- Direct outreach to key accounts

### Success Metrics

```text
> Define success metrics for our [tier] launch:
>
> Primary: [the one number that matters most]
> Secondary: [3-5 supporting metrics]
> Guardrails: [metrics we're watching to catch regressions]
>
> Time horizon: [1 day / 1 week / 30 days post-launch]
```

## Launch Plan Template

```text
> Create a launch plan document for [product/feature]:
>
> Launch date: [date]
> Launch tier: [alpha/beta/GA]
> Target audience: [ICP]
>
> Include:
> - T-7 days: What needs to be done one week before
> - T-1 day: Final prep checklist
> - Launch day: Hour-by-hour sequence
> - T+7 days: Post-launch review criteria
```

## SQL Launch Tracker

```sql
CREATE TABLE launch_tasks (
    id TEXT PRIMARY KEY,
    phase TEXT,          -- pre_launch | launch_day | post_launch
    category TEXT,       -- product | marketing | comms | eng | success
    title TEXT NOT NULL,
    owner TEXT,
    due_date TEXT,
    status TEXT DEFAULT 'pending',
    notes TEXT
);

INSERT INTO launch_tasks VALUES
  ('lp1', 'pre_launch', 'product', 'Complete end-to-end smoke test', 'eng', 'T-2', 'pending', ''),
  ('lp2', 'pre_launch', 'marketing', 'Write Product Hunt description', 'marketing', 'T-3', 'pending', ''),
  ('lp3', 'pre_launch', 'comms', 'Prepare launch email to waitlist', 'marketing', 'T-2', 'pending', ''),
  ('lp4', 'launch_day', 'marketing', 'Post on Product Hunt at 12:01 AM PST', 'marketing', 'T0', 'pending', ''),
  ('lp5', 'launch_day', 'comms', 'Send waitlist email at 9 AM', 'marketing', 'T0', 'pending', ''),
  ('lp6', 'post_launch', 'success', 'Review activation metrics at T+24h', 'product', 'T+1', 'pending', '');

-- Track progress
SELECT phase, category, title, status
FROM launch_tasks
ORDER BY phase, category;
```

## Post-Launch Review

```text
> We launched [X] on [date]. Here are our results:
> [metrics]
>
> Generate a post-launch analysis:
> 1. What did we expect vs. what happened?
> 2. What distribution channel drove the most value?
> 3. What user feedback patterns emerged in the first 48 hours?
> 4. What would we do differently?
> 5. What's the next milestone (path to [next tier / revenue goal])?
```

## Tips

- **Nail the narrative before writing copy**: Positioning first, then messaging, then distribution
- **Sequence channels**: Don't blast everything simultaneously — stagger for sustained momentum
- **Have a war room**: Assign someone to monitor metrics and respond to users on launch day
- **Pre-write your responses**: Draft answers to the 10 most likely questions before launch
- **Soft-launch first**: A private beta with 50 users is worth more than a public launch with bugs
- **Build the list before you need it**: Start collecting emails/signups weeks before launch

Related Skills

multi-model-strategy

8
from drvoss/everything-copilot-cli

Use when choosing which AI model to use for a task — pick the right model family and tier based on cost, speed, context needs, and reasoning depth

content-strategy

8
from drvoss/everything-copilot-cli

Use when you need a content plan to grow organic traffic for a product or new area — produces keyword research, topic clusters, and a content calendar targeting your category.

verification-before-completion

8
from drvoss/everything-copilot-cli

Use before claiming any task is done — run the exact command that proves the fix works, read the output, and only then report success.

using-git-worktrees

8
from drvoss/everything-copilot-cli

Use when you need multiple branches checked out at once — create isolated working directories for parallel development without cloning the repository repeatedly

triage

8
from drvoss/everything-copilot-cli

Use when a single issue needs structured triage — classify it, reproduce if needed, request missing information, and leave a durable brief or close-out note in the tracker.

to-issues

8
from drvoss/everything-copilot-cli

Use when a plan, spec, or PRD must become an actionable backlog — break it into thin dependency-aware issues that each deliver a verifiable vertical slice

sprint-workflow

8
from drvoss/everything-copilot-cli

Use when starting a new feature, refactor, or multi-step dev task — runs the full sprint cycle (Think → Plan → Build → Review → Test → Ship → Monitor) using Copilot CLI's plan/autopilot modes.

sprint-retro

8
from drvoss/everything-copilot-cli

Use at the end of a sprint to run a data-driven retrospective — analyzes session history and git metrics to surface what shipped, what slowed you down, and concrete improvements.

security-audit

8
from drvoss/everything-copilot-cli

Use when a codebase needs a formal security audit beyond a quick scan — applies OWASP Top 10 and STRIDE threat modeling from a CSO perspective to surface systemic vulnerabilities.

release

8
from drvoss/everything-copilot-cli

Use when a sprint or feature is complete and ready to ship — tags the version, generates GitHub Release notes, runs rollout or smoke verification, and publishes to npm/PyPI/Docker registries.

prompt-optimizer

8
from drvoss/everything-copilot-cli

Use when a rough prompt, vague idea, or task description needs to become a finished copy-pasteable prompt for a chat-based LLM - rewrite it into one ready-to-send prompt with no blanks, no placeholders, and a clear output shape.

outside-voice

8
from drvoss/everything-copilot-cli

Use when you need an independent second opinion before, during, or after implementation — run challenge, consult, or review mode in a direct builder-to-builder voice