skills/product-announcement-craft/SKILL.md
The art and science of announcing a product you built -- narrative arc, format selection (Show HN vs blog vs tweet thread vs video demo), building anticipation, launch day coordination, follow-up engagement, handling feedback, and iterating the message. Activate on 'announce', 'product launch', 'launch announcement', 'how to announce', 'launch blog post', 'Show HN post', 'launch email', 'announcement strategy', 'launch narrative', 'launch copy'. NOT for channel-specific posting tactics (use tech-launch-channels) or monetization (use indie-monetization-strategist).
npx skillsauth add curiositech/windags-skills product-announcement-craftInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
How to announce a thing you built so that people care. The announcement is not the product -- it is a separate creative work that requires its own strategy, structure, and iteration.
Use for:
Do NOT use for:
Every great product announcement follows the same arc, whether it is a tweet, a blog post, or a 5-minute video. The medium changes; the arc does not.
1. THE HOOK → Stop the scroll. Create curiosity or recognition.
2. THE PROBLEM → "You know that feeling when..." -- make them nod.
3. THE STRUGGLE → What you tried, what failed, why existing solutions fall short.
4. THE INSIGHT → The key realization that led to your approach.
5. THE SOLUTION → What you built. Show it. Demo it. Make it concrete.
6. THE PROOF → Numbers, screenshots, testimonials, benchmarks, code.
7. THE INVITATION → How they can try it right now. Make it frictionless.
It mirrors the Jobs to be Done framework: people don't buy products, they hire solutions for problems they already have. Your announcement succeeds when the reader thinks "I have that exact problem" before they see your solution.
Choose your PRIMARY format based on what you have to show:
| What You Have | Best Primary Format | Why | |---------------|---------------------|-----| | Beautiful UI, visual product | Video demo (60-90 sec) | Seeing is believing for visual tools | | CLI tool, dev infrastructure | Show HN post + blog | Developers want to read how it works | | Major upgrade to existing product | Changelog + email | Existing users care most | | Complex system, many features | Blog post (1500-2500 words) | Needs space to explain the architecture | | Quick hack, weekend project | Tweet thread (5-7 tweets) | Lightweight matches lightweight | | Enterprise/B2B product | Blog post + LinkedIn article | Professional audience, needs depth |
Title: Show HN: [Name] - [What it does in one line]
First comment:
Hi HN, I'm [name]. I've been working on [product] for [time].
The problem: [1-2 sentences about a specific pain point]
What it does: [2-3 sentences, technically specific]
How it works: [Brief architecture -- what's under the hood]
What makes this different from [obvious competitor]: [honest comparison]
Try it: [link]
Code: [repo link, if applicable]
I'd love your feedback, especially on [specific question].
Structure (1500-2500 words):
# [Name]: [Benefit-oriented subtitle]
[Opening hook -- a story, a surprising stat, or a relatable frustration]
## The Problem
[2-3 paragraphs. Be specific. Use examples. Make the reader nod.]
## What We Tried
[Optional but powerful. Shows intellectual honesty.]
## Introducing [Name]
[What it is, what it does, who it's for. Include a hero screenshot or GIF.]
## How It Works
[Technical deep-dive. Architecture diagram. Code examples. This is where
developers decide if you're serious.]
## Show Me
[Demo walkthrough. Annotated screenshots. GIF or embedded video. Before/after.]
## What's Next
[Roadmap transparency. What you're building next. How to get involved.]
## Try It
[Clear CTA. Link. Installation command. Getting started in 30 seconds.]
Tweet 1 (Hook):
I just shipped [thing] and it [surprising result or benefit].
Here's the 2-minute version of what it does and why I built it:
Tweet 2 (Problem):
The problem: [relatable pain in 1-2 sentences]
[Screenshot of the ugly status quo or a code snippet of the painful way]
Tweet 3 (Solution):
So I built [name].
[Screenshot or GIF of your product solving the problem]
Tweet 4 (How):
How it works:
- [Bullet 1 -- technical but accessible]
- [Bullet 2]
- [Bullet 3]
Tweet 5 (Demo):
[30-60 second demo video or GIF. This is the most important tweet.]
Tweet 6 (Proof):
Early results:
- [Metric 1]
- [Metric 2]
- [Quote from early user]
Tweet 7 (CTA):
Try it: [link]
Star it: [repo link]
Follow for updates on [topic].
Subject: [Name] is live -- [one benefit in 5 words]
Hey [name],
Remember when I mentioned I was building [thing]? It's live.
[One paragraph: what it does and why you'd care]
[Screenshot or GIF -- visual proof]
Here's what you can do with it:
- [Use case 1]
- [Use case 2]
- [Use case 3]
Try it now: [link]
I built this because [personal reason]. If you have 2 minutes,
I'd genuinely appreciate you trying it and telling me what breaks.
[Your name]
P.S. If you share it on [Twitter/HN/etc], that would mean the world.
Here's a ready-to-tweet: [pre-written tweet with link]
The launch does not start on launch day. It starts 2-6 weeks before.
Launch day will bring criticism. This is GOOD. How you handle it determines whether critics become advocates.
1. ACKNOWLEDGE → "That's a fair point" or "I see where you're coming from"
2. AGREE → Find the grain of truth (there always is one)
3. EXPLAIN → Your reasoning, without being defensive
4. INVITE → "Would you be open to trying X? I'd love your take after that"
| Criticism | Bad Response | Good Response | |-----------|-------------|---------------| | "This already exists" | "No it doesn't!" | "You're right that X and Y exist. Here's what's different: [specific technical difference]. Happy to discuss the tradeoffs." | | "Why would I use this?" | "Because it's better!" | "Fair question. If you're doing [workflow], this saves you [specific time/effort]. If not, it might not be for you -- and that's fine." | | "This looks like a weekend project" | "It took 6 months!" | "The simplicity is intentional. Under the hood: [technical depth]. The hard part was making it feel this simple." | | "No tests/docs/etc" | Ignore it | "You're right, docs need work. I prioritized [thing] first. PRs welcome, and I'm working on docs this week." |
Do not respond to harsh criticism immediately. Draft your response, wait 1 hour, then re-read it. Remove any defensiveness. Post the revised version.
Your first announcement rarely gets the messaging right. Watch for signals and adapt.
| Signal | What It Means | Fix | |--------|---------------|-----| | "Cool, but what does it DO?" | Too abstract, not concrete enough | Add a demo GIF, show specific use cases | | "How is this different from X?" | Differentiation unclear | Add a comparison table, be explicit about tradeoffs | | "Who is this for?" | Audience not defined | Lead with a persona: "If you're a developer who..." | | High traffic, low signups | Landing page doesn't match announcement | Align landing page messaging with what resonated | | Low traffic, high conversion | Message is right, distribution is wrong | Use tech-launch-channels to expand reach |
Instead of one big announcement, ship one thing per day for a week. Each day's announcement is smaller and easier to write. The cumulative effect is massive. Supabase has done 15+ launch weeks and it is their primary growth engine.
Benefits:
What they did: Ship one major feature per day for 5 days, each with its own blog post, demo, and social campaign. Coordinated countdown, daily reveals, community engagement. Why it worked: Sustained attention over 5 days instead of a 1-day spike. Each feature attracted a different audience segment. Lesson: Frequency beats magnitude. Five good announcements beat one great one.
What they did: Positioned a project management tool as a design and craft story. Focused on speed, keyboard shortcuts, and developer experience rather than features. Why it worked: Differentiated from Jira/Asana by speaking to developer values (speed, craft, taste) rather than competing on features. Lesson: Announce what makes you DIFFERENT, not what makes you complete.
What they did: Didn't say "IDE with AI features." Said "the AI code editor." Owned a category instead of being a feature of an existing category. Why it worked: Category creation is more memorable than feature comparison. Lesson: Name the category you want to own. "AI agent orchestrator" > "workflow tool with AI."
Mistake: "We're building the future of X" with no demo, no link, no way to try it. Fix: Never announce without something people can use TODAY. Vision is marketing. Product is announcement.
Mistake: "New in v2.0: feature A, feature B, feature C, feature D..." Fix: Lead with ONE story about ONE user solving ONE problem. Features are supporting evidence, not the headline.
Mistake: Announcing before the product works reliably for a first-time user. Fix: Have 5 non-team-members complete the onboarding flow before you announce. If they can't, you're not ready.
Mistake: Copy-pasting the same text to HN, Reddit, Twitter, and LinkedIn. Fix: Each platform has different norms. Write for each audience separately (see tech-launch-channels).
Mistake: Launching, celebrating, and going silent. Fix: Launch day is day 1. Plan content for day 7, day 30, and day 90. The follow-up posts often outperform the launch.
Mistake: Not responding to criticism, or responding defensively. Fix: Every critic is a potential advocate. Acknowledge, agree, explain, invite.
Mistake: Three paragraphs of context before the reader sees what the product looks like. Fix: Show the product in the first 10 seconds (video) or first scroll (blog post). Hook with the result, then explain.
tools
Building resilient distributed systems with circuit breakers, retries with full-jitter exponential backoff, retry budgets (per-request 3-attempt + per-client 10% ratio per Google SRE), deadline propagation, and the cascading-failure math (4 layers × 3 retries = 64x amplification). Grounded in Resilience4j, Microsoft Cloud Patterns, AWS Architecture Blog (Marc Brooker), and Google SRE Book.
testing
Designing HTTP cache headers that work correctly across browsers, CDNs, and shared proxies — `Cache-Control` directives per RFC 9111, `stale-while-revalidate` and `stale-if-error` per RFC 5861, the Vary header for varying responses, and surrogate keys for tag-based purging. Grounded in IETF RFCs and Cloudflare/Fastly docs.
development
Use when designing or fixing a Content Security Policy on a real site, choosing between nonce-based and hash-based CSP, adding strict-dynamic, debugging "Refused to execute inline script" errors, deploying CSP in report-only mode first, configuring report-to / report-uri, or auditing an existing policy for unsafe-inline / unsafe-eval / wildcards. Triggers: "CSP blocks legitimate inline script", strict-dynamic, nonce-{RANDOM}, sha256-{HASH}, object-src none, base-uri none, frame-ancestors, Trusted Types, X-Content-Security-Policy obsolete, report-only vs enforced. NOT for general HTTP security headers (HSTS, COOP/COEP), Trusted Types deep dive, CORS configuration, or building a WAF.
tools
Choosing and operating an HTTP API versioning strategy that doesn't break clients — Stripe's date-based pinned versions, the Deprecation/Sunset header pair (RFC 9745 + RFC 8594), URI vs header vs media-type approaches, and the version-transformer pattern. Grounded in Stripe's published architecture and IETF RFCs.