Skip to content
Skills Library
Marketing & content · Planning

launch-loop-strategy

/launch-loop-strategy

Use when planning a practical launch loop for a feature, product update, template, prompt, skill, integration, beta, or release with a known launch date, especially when the user needs channels, content angles, a posting schedule, community distribution, replies, DMs, and follow-up remixes.

Licence
MIT
Last repository change
30.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 30.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when planning a practical launch loop for a feature, product update, template, prompt, skill, integration, beta, or release with a known launch date, especially when the user needs channels, content angles, a posting schedule, community distribution, replies, DMs, and follow-up remixes.

Original author description

Use when planning a practical launch loop for a feature, product update, template, prompt, skill, integration, beta, or release with a known launch date, especially when the user needs channels, content angles, a posting schedule, community distribution, replies, DMs, and follow-up remixes.

How it works

  1. Core Loop
  2. Intake
  3. Build The Angle
  4. Major Feature System
  5. 7-Day Template
  6. Platform Fit
  7. Carousel To Short Video
  8. CTA Rules
  9. First-Hour Routine
  10. Output Contract
Original SKILL.md headings · 212 lines, 1,141 words
SKILL.md preview
---
name: launch-loop-strategy
description: "Use when planning a practical launch loop for a feature, product update, template, prompt, skill, integration, beta, or release with a known launch date, especially when the user needs channels, content angles, a posting schedule, community distribution, replies, DMs, and follow-up remixes."
---

# Launch Loop Strategy

Turn one feature launch into a week of useful market contact. The user should be able to say:

```text
I'm launching <feature> on <date>. Help me build the launch loop.
```

Return a practical plan: what to post, where to post it, what assets to make, what to say, how to reply,
and what to remix after the first signal comes in.

Use this skill with:

- `launch-strategy` for broader GTM sequencing, launch checklists, beta launches, and waitlists.
- `distribution-plan` for channel selection, communities, partners, newsletters, PR, and founder-led distribution.
- `content-strategy` for pillars, narratives, recurring formats, and proof/story inventory.
- `creative-brief` for ad, social, image, video, UGC, and creator asset briefs.
- `x-article-writer` when the loop needs a long X/Twitter article, founder essay, or launch teardown.

## Core Loop

Do not launch once. Launch the loop:

```text
Demo -> Post -> Share -> Reply -> Repost
```

1. **Demo:** show or explain one launchable unit: feature, workflow, skill, template, proof point, or lesson.
2. **Post:** publish the strongest anchor asset: demo, carousel, thread, article, short video, or teardown.
3. **Share:** distribute native versions across the channels where this category fits.
4. **Reply:** answer comments, DMs, objections, and confusion; collect the market's language.
5. **Repost:** turn the winning angle, question, objection, or proof into the next asset.

The operating principle:

```text
Launch once and you get a spike.
Launch every week and you get distribution.
```

## Intake

When details are missing, ask at most three useful questions. Otherwise infer and state assumptions.

Minimum inputs:

- Feature: what is shipping.
- Date: exact launch date or rough window.
- Audience: who should care.
- Promise: what pain changes after this exists.
- Proof: screenshot, demo clip, metric, quote, customer result, build note, before/after, or waitlist.
- Channels: where the user can realistically post.
- CTA: try it, join waitlist, comment keyword, DM, install, book call, read docs, or share.

Default assumptions:

- Use a 7-day loop: 2 days before launch, launch day, 4 days after.
- Use one anchor asset, one short-form discovery asset, one community-native post per relevant channel,
  and one remix from early feedback.
- If the user has little or no audience, prioritize short-form discovery, X/community posts, and direct
  community distribution over Stories.

## Build The Angle

Name the launchable unit in one sentence, then choose the strongest angle:

- Pain killer: `Stop doing <old painful workflow>.`
- New mechanism: `The better way is <new workflow>.`
- Proof: `We tested/built/shipped <specific proof>.`
- Comparison: `Before <feature> vs after <feature>.`
- Founder lesson: `We learned <truth> building this.`
- Category shift: `<old category habit> is becoming <new behavior>.`

Write the audience promise as:

```text
This helps <person> do <outcome> without <pain>.
```

## Major Feature System

Use this for major features, not tiny fixes. Package the same feature as a week of market contact from
different angles:

1. Product demo: what changed and why it matters.
2. Best use case clip: the clearest "I need this" moment.
3. Problem angle: what painful old behavior this replaces.
4. Workflow angle: the new step-by-step process.
5. Proof angle: metric, customer quote, screenshot, build note, or before/after.
6. Founder POV: why the team built it this way.
7. Community-native version: rewritten for the specific platform.

The feature should appear from multiple angles for a full week without copy-pasting the same
announcement everywhere.

## 7-Day Template

Use this when the user gives a launch date:

```text
T-2: Tease the problem
T-1: Show the old workflow / pain
Launch day: Demo the feature + anchor post
T+1: Post the best use case as a short clip/Reel
T+2: Share community-native versions
T+3: Answer objections / publish FAQ
T+4: Repost winner + recap what people missed
```

For each day, specify:

- Post format.
- Hook.
- Channel.
- Asset needed.
- CTA.
- Signal to watch.

If launch is imminent, compress to:

```text
Launch day: anchor + demo
Next day: short clip from the demo
Day 3: community post + objection follow-up
```

## Platform Fit

Choose only platforms where the category fits.

- Product Hunt: polished product/update story, launch page, screenshots, maker comments.
- Hacker News / Show HN: technical clarity, direct demo, no marketing fluff.
- Devhunt: developer tool launch, practical workflow, build details.
- BetaList: early product, beta/waitlist positioning.
- Peerlist: builder/founder credibility, product craft, career/professional utility.
- Indie Hackers: build-in-public, revenue/users, founder lesson, tactical breakdown.
- Reddit: subreddit-specific usefulness, low-promo framing, real discussion.
- X: sharp POV, demo clip, thread, founder narrative, quote-post remixing.
- LinkedIn: professional pain, team/business outcome, clear lesson.

Rewrite the intro for each community's norms. Do not dump the same caption everywhere.

## Carousel To Short Video

When turning a carousel or deck into a short video, do not animate every slide. Make a trailer.

Use 3-4 frames:

1. Problem frame: names the pain or mistake.
2. Mechanism frame: reveals the new model.
3. Steps/proof frame: shows the process or result.
4. CTA frame: tells viewers what to do next.

Structure:

```text
0-3s: Problem
3-6s: Better mechanism
6-12s: Steps or proof
12-18s: CTA
```

Use screenshots, screen recordings, product demo clips, captions, cursor movement, and subtle zoom/pan.
It should feel like a preview of the full anchor asset, not a duplicate upload.

## CTA Rules

Use a comment/DM CTA only when the promised asset exists and the team can deliver it reliably.

Good CTAs:

- `Comment LAUNCH and I will send you the checklist.`
- `Save this before your next feature launch.`
- `Send this to the founder who only launches once.`
- `DM me LAUNCH if you want the template.`

Avoid:

- Inventing a downloadable asset that does not exist.
- Vague endings like `thoughts?`
- Asking for comments when the post gives no natural reason to discuss.
- Dropping links in captions as if they are clickable.

## First-Hour Routine

Before posting:

- Comment thoughtfully on 5-10 relevant creator/community posts.
- Prepare 3 reply prompts for likely comments.
- Know exactly how to deliver the promised asset if using a keyword CTA.

After posting:

- Reply to every real comment with a specific answer.
- Ask one narrow follow-up question when useful.
- DM the asset only to people who asked for it.
- Save good questions as follow-up post hooks.

## Output Contract

Return:

1. Launchable unit: what exactly is being launched.
2. Audience promise: who it helps and what pain it removes.
3. Launch angle: the single strongest narrative for the week.
4. Dated schedule: T-2 through T+4, or compressed if launch is imminent.
5. Asset list: screenshots, demo clips, carousel, short video, community posts, replies.
6. Channel plan: what to post where and how to adapt the intro.
7. First-hour plan: comments, replies, DMs, and follow-up prompts.
8. Remix plan: 3 follow-up angles from expected comments or objections.
Files in this package (2)
  • SKILL.md 7 KB
  • agents/openai.yaml 1 KB

Versions

The database has no other skills named launch-loop-strategy.

Database snapshot: 13.11.2026 · package version b469154868d8 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100launch-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.
  • 100launch-strategy
    Use when planning a product launch, feature release, waitlist, beta, public announcement, relaunch, Product Hunt-style push, repeated feature launch system, launch-week checklist, or multi-channel GTM rollout.
  • 100launch-strategy
    When the user wants to plan a product launch, feature announcement, release strategy, or go-to-market plan. Also use when the user mentions 'launch plan', 'go to market', 'GTM', 'Product Hunt', 'beta launch', 'how do I launch', 'pre-launch', 'launch checklist', 'distribution…
  • 85gtm-strategy
    Create a go-to-market strategy covering marketing channels, messaging, success metrics, and launch timeline. Use when planning a product launch, creating a GTM plan from scratch, or defining a launch strategy for a new market.
  • 100launch
    Use this skill when planning a product launch, feature announcement, or release strategy. Trigger phrases include: "plan our product launch," "write a launch plan," "Product Hunt launch strategy," "launch checklist," "pre-launch preparation," "waitlist strategy," "launch email…
  • 100launch-strategy
    When the user wants to plan a product launch, feature announcement, or release strategy. Also use when the user mentions 'launch,' 'Product Hunt,' 'feature release,' 'announcement,' 'go-to-market,' 'beta launch,' 'early access,' 'waitlist,' or 'product update.' This skill covers…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.