Initial commit

2025-11-29 18:48:55 +08:00
commit f28999f19c
127 changed files with 62038 additions and 0 deletions
--- a/skills/technical-launch-planner/references/developer_enablement.md
+++ b/skills/technical-launch-planner/references/developer_enablement.md
@@ -0,0 +1,246 @@
+# Developer Enablement Checklist
+
+Comprehensive checklist for enabling developers to adopt your technical product.
+
+---
+
+## Critical: Documentation
+
+### Getting Started Guide
+- [ ] **Installation instructions** (< 5 minutes)
+- [ ] **Quick start tutorial** (Hello World in < 10 minutes)
+- [ ] **Basic concepts** explained
+- [ ] **First successful API call** walkthrough
+- [ ] **Authentication** setup guide
+- [ ] **Common gotchas** documented
+
+### API Reference
+- [ ] **All endpoints** documented
+- [ ] **Request/response examples** for each endpoint
+- [ ] **Error codes** and meanings
+- [ ] **Rate limits** clearly stated
+- [ ] **Authentication** methods
+- [ ] **Versioning** strategy explained
+- [ ] **Changelog** maintained
+
+### Integration Guides
+- [ ] **Step-by-step** integration tutorials
+- [ ] **Common use cases** covered
+- [ ] **Best practices** documented
+- [ ] **Performance tips**
+- [ ] **Security considerations**
+
+###Migration Guide (if applicable)
+- [ ] **Breaking changes** highlighted
+- [ ] **Migration steps** clear
+- [ ] **Before/after code** examples
+- [ ] **Timeline** for deprecations
+- [ ] **Support** for old version
+
+---
+
+## Critical: Code Assets
+
+### SDKs/Client Libraries
+- [ ] **Python** SDK
+- [ ] **JavaScript/Node** SDK
+- [ ] **Additional languages** as needed
+- [ ] **Well-documented** public APIs
+- [ ] **Type definitions** (TypeScript, etc.)
+- [ ] **Published** to package managers
+- [ ] **Examples** in README
+
+### Sample Applications
+- [ ] **Simple** "Hello World" app
+- [ ] **Realistic** integration example
+- [ ] **Production-ready** template
+- [ ] **README** with setup instructions
+- [ ] **Runnable** locally
+
+### Code Snippets
+- [ ] **Common operations** (CRUD)
+- [ ] **Authentication** examples
+- [ ] **Error handling** patterns
+- [ ] **Copy-paste** ready
+- [ ] **Multiple languages**
+
+---
+
+## Important: Developer Experience
+
+### Interactive Tools
+- [ ] **API explorer** / playground
+- [ ] **Interactive tutorials**
+- [ ] **Sandbox environment** (no credit card)
+- [ ] **Test mode** / mock data
+- [ ] **Debugging tools**
+
+### Developer Portal
+- [ ] **Dashboard** for API keys
+- [ ] **Usage analytics**
+- [ ] **Billing/quota** visibility
+- [ ] **Team management**
+- [ ] **Support access**
+
+### Testing & Debugging
+- [ ] **Test credentials** available
+- [ ] **Webhook testing** tools
+- [ ] **Request logs** accessible
+- [ ] **Error debugging** guides
+- [ ] **Postman collection** (if REST API)
+
+---
+
+## Important: Learning Resources
+
+### Video Content
+- [ ] **Demo video** (3-5 minutes)
+- [ ] **Tutorial series** for key features
+- [ ] **Architecture overview** video
+- [ ] **Best practices** video
+
+### Written Tutorials
+- [ ] **Blog posts** for common use cases
+- [ ] **Integration tutorials**
+- [ ] **Performance optimization** guides
+- [ ] **Security best practices**
+
+### Community Resources
+- [ ] **FAQ** section
+- [ ] **Troubleshooting** guide
+- [ ] **Community forum** / Discord / Slack
+- [ ] **Stack Overflow** tag
+- [ ] **GitHub Discussions** enabled
+
+---
+
+## Important: Technical Specifications
+
+### Architecture Documentation
+- [ ] **System architecture** diagram
+- [ ] **Data flow** diagrams
+- [ ] **Sequence diagrams** for complex flows
+- [ ] **Infrastructure** overview
+- [ ] **Scaling** characteristics
+
+### Performance & Limits
+- [ ] **Rate limits** documented
+- [ ] **Latency expectations** (p50, p95, p99)
+- [ ] **Throughput** capabilities
+- [ ] **Quotas** and limits
+- [ ] **SLA** commitments
+
+### Security Documentation
+- [ ] **Authentication** methods
+- [ ] **Authorization** model
+- [ ] **Data encryption** (at rest, in transit)
+- [ ] **Compliance** certifications
+- [ ] **Security best practices**
+- [ ] **Vulnerability** reporting process
+
+---
+
+## Nice to Have: Advanced Resources
+
+### Reference Architectures
+- [ ] **Common patterns** documented
+- [ ] **Production deployment** examples
+- [ ] **Multi-region** setups
+- [ ] **High availability** configurations
+
+### Integrations
+- [ ] **Third-party** tool integrations
+- [ ] **Framework** specific guides (React, Vue, etc.)
+- [ ] **CI/CD** integration examples
+- [ ] **Monitoring** integration guides
+
+### Developer Tools
+- [ ] **CLI** tool
+- [ ] **Browser extensions**
+- [ ] **IDE plugins** (VS Code, etc.)
+- [ ] **Linters** / code validators
+
+---
+
+## Launch Day Specific
+
+### Pre-Launch
+- [ ] **Beta testers** given early access
+- [ ] **Documentation** live on staging
+- [ ] **SDKs** tagged and ready
+- [ ] **Samples** tested end-to-end
+
+### Launch Day
+- [ ] **Docs** published to production
+- [ ] **SDKs** released to package managers
+- [ ] **Samples** available on GitHub
+- [ ] **Playground** accessible
+- [ ] **Support** channels staffed
+
+### Post-Launch
+- [ ] **Monitor** documentation traffic
+- [ ] **Respond** to questions quickly
+- [ ] **Update** docs based on feedback
+- [ ] **Create** additional resources as needed
+
+---
+
+## Quality Checks
+
+### Documentation Quality
+- [ ] **Tested** by someone unfamiliar with product
+- [ ] **Code samples** all execute successfully
+- [ ] **Links** all work
+- [ ] **Screenshots** up-to-date
+- [ ] **Grammar/spelling** checked
+- [ ] **Search** functionality works
+- [ ] **Mobile** responsive
+
+### Code Quality
+- [ ] **SDKs** have tests
+- [ ] **Sample apps** run without errors
+- [ ] **Dependencies** up-to-date
+- [ ] **Security** vulnerabilities checked
+- [ ] **Licenses** clearly stated
+
+---
+
+## By Audience
+
+### Beginner Developers
+- Clear getting started
+- Simple examples
+- Video tutorials
+- Interactive playground
+- Active community support
+
+### Experienced Developers
+- Comprehensive API reference
+- Advanced use cases
+- Performance documentation
+- Architecture details
+- Migration guides
+
+### Enterprise/Teams
+- Security documentation
+- Compliance information
+- Team management docs
+- SSO integration
+- SLA details
+
+---
+
+## Measurement
+
+Track these metrics post-launch:
+
+- **Documentation traffic**
+- **Time to first API call**
+- **Sandbox activation rate**
+- **SDK download count**
+- **Sample app clones**
+- **Support ticket volume**
+- **Community questions**
+- **Tutorial completion rate**
+
+Use data to improve enablement continuously.
--- a/skills/technical-launch-planner/references/launch_messaging.md
+++ b/skills/technical-launch-planner/references/launch_messaging.md
@@ -0,0 +1,436 @@
+# Technical Launch Messaging
+
+Messaging frameworks and templates for developer-focused product launches.
+
+---
+
+## Messaging Principles for Developers
+
+### DO:
+- ✅ **Be specific** - Use concrete technical details
+- ✅ **Show code** - Developers want to see, not read
+- ✅ **State limitations** - Honest about what it can't do
+- ✅ **Provide metrics** - Performance numbers, benchmarks
+- ✅ **Explain why** - Technical reasoning matters
+- ✅ **Link to docs** - Make it easy to try
+
+### DON'T:
+- ❌ **Use marketing jargon** - "Revolutionary", "game-changing"
+- ❌ **Oversimplify** - Developers can handle complexity
+- ❌ **Hide limitations** - They'll find them anyway
+- ❌ **Make unsubstantiated claims** - Back it up with data
+- ❌ **Skip code examples** - Abstract descriptions fail
+
+---
+
+## Messaging Framework
+
+### Problem Statement
+**Format:** [Current pain point] → [Why existing solutions fail] → [Impact on developers]
+
+**Example:**
+"Debugging distributed systems is painful. Traditional logging tools weren't built for microservices, forcing developers to manually correlate logs across dozens of services. This turns a 5-minute bug into a 5-hour investigation."
+
+---
+
+### Solution Overview
+**Format:** [What it is] → [How it works (technical)] → [Key benefit]
+
+**Example:**
+"Distributed Tracer automatically instruments your services to create a unified view of requests across your entire stack. Using OpenTelemetry standards, it correlates logs, metrics, and traces in real-time, reducing MTTR by 80%."
+
+---
+
+### Key Differentiators
+**Format:** [Feature] → [Technical implementation] → [Why it matters]
+
+**Example:**
+"Zero-config auto-instrumentation. Our SDK uses bytecode injection to automatically trace all HTTP calls, database queries, and external APIs without code changes. Deploy in under 5 minutes instead of days."
+
+---
+
+## Launch Announcement Template
+
+### Blog Post Structure
+
+```markdown
+# Introducing [Product]: [One-line value prop]
+
+## TL;DR
+- [Key point 1 with metric]
+- [Key point 2 with metric]
+- [Get started link]
+
+## The Problem
+
+[Describe the developer pain in detail. Be specific.]
+
+**Example:**
+Every API call in a distributed system touches 5-10 services. When something breaks, you're left grep'ing through gigabytes of logs, trying to piece together what happened. We've all been there.
+
+## The Solution
+
+[High-level overview]
+
+**How it works:**
+
+\`\`\`python
+# Show concrete code example
+import tracer
+
+tracer.init(api_key="your_key")
+
+# That's it. All requests automatically traced.
+\`\`\`
+
+## Key Features
+
+### 1. [Feature Name]
+
+**What it does:** [Technical description]
+
+**Why it matters:** [Developer benefit]
+
+**Example:**
+\`\`\`[language]
+[Code showing the feature]
+\`\`\`
+
+[Repeat for top 3-5 features]
+
+## Performance
+
+[Include benchmarks, metrics]
+
+- Latency: < 1ms overhead (p99)
+- Throughput: 100K traces/second per instance
+- Storage: 90-day retention included
+
+## Get Started in 5 Minutes
+
+\`\`\`bash
+# Installation
+npm install @company/sdk
+
+# Basic setup
+[Minimal code to get value]
+\`\`\`
+
+[Link to full documentation]
+
+## What's Next
+
+[Roadmap tease for 1-2 upcoming features]
+
+## Resources
+
+- [Documentation]
+- [Sample apps]
+- [API reference]
+- [Community Discord]
+```
+
+---
+
+## Email Announcement Template
+
+**Subject Lines (A/B test these):**
+- "[Product] is now GA - [Key benefit]"
+- "Ship faster with [Product]"
+- "[Pain point solved]: Introducing [Product]"
+
+**Body:**
+
+```
+Hi [Name],
+
+We're excited to announce [Product] is now generally available.
+
+What it does:
+[One sentence technical description]
+
+Why it matters to you:
+[Specific benefit for recipient's role/tech stack]
+
+Get started in 5 minutes:
+
+```[language]
+[Minimal code example]
+```
+
+Key features:
+• [Feature 1 - one line]
+• [Feature 2 - one line]
+• [Feature 3 - one line]
+
+Resources:
+→ Documentation: [link]
+→ Sample code: [link]
+→ API reference: [link]
+
+[If Beta]: As a beta user, you already have access. Check your dashboard to enable.
+
+Questions? Hit reply or join us in [Discord/Slack].
+
+Happy building,
+[Name]
+[Title]
+
+P.S. [Call to action or incentive]
+```
+
+---
+
+## Social Media Templates
+
+### Twitter/X (Technical)
+
+**Format 1: Problem → Solution**
+```
+Tired of [pain point]?
+
+[Product] gives you [benefit]:
+• [Feature 1]
+• [Feature 2]
+• [Feature 3]
+
+Get started: [link]
+
+[Include code snippet image or architecture diagram]
+```
+
+**Format 2: Show the Code**
+```
+This is all it takes to [achieve outcome]:
+
+[Code snippet image]
+
+Try it now: [link]
+#developer #[tech stack]
+```
+
+**Format 3: Metrics**
+```
+We just reduced distributed tracing overhead from 5ms to < 1ms.
+
+How? [Link to technical blog post]
+
+Open-sourced the approach: [GitHub link]
+```
+
+### LinkedIn (Business + Technical)
+
+**Format:**
+```
+[Company] is launching [Product] today.
+
+The problem we're solving:
+[2-3 sentences about developer pain]
+
+Our approach:
+[Technical differentiation]
+
+Early results from beta:
+• [Metric/testimonial 1]
+• [Metric/testimonial 2]
+
+If you're working on [use case], check it out: [link]
+
+[Include demo video or architecture diagram]
+```
+
+### Hacker News Post
+
+**Title Format:**
+- "Show HN: [Product] – [One-line description]"
+- "[Product] – [Interesting technical approach]"
+
+**Comment (required):**
+```
+Hey HN! Creator here.
+
+We built [Product] to solve [problem we experienced].
+
+Technical approach:
+[2-3 paragraphs explaining interesting technical decisions]
+
+What's different:
+[Why this approach vs. alternatives]
+
+How to try it:
+[Quick start instructions]
+
+Happy to answer questions!
+```
+
+---
+
+## Positioning Statements
+
+### General Template
+"For [target developers] who [need/pain point], [Product] is a [category] that [key benefit]. Unlike [alternatives], we [unique differentiation]."
+
+### Examples
+
+**API Tool:**
+"For backend developers who need reliable API integrations, FastAPI Connect is an API orchestration platform that auto-retries, caches, and monitors all external calls. Unlike building retry logic yourself, we provide production-grade reliability out of the box."
+
+**Developer Platform:**
+"For platform teams building internal developer platforms, DevHub is a self-service portal that gives developers one-click access to infrastructure. Unlike traditional ticketing systems, we automate provisioning in seconds instead of days."
+
+---
+
+## Value Propositions by Persona
+
+### Backend Developers
+**Focus:** Performance, reliability, ease of integration
+
+"Reduce latency by 40% with one line of code"
+
+### DevOps/SRE
+**Focus:** Reliability, observability, automation
+
+"Cut MTTR from hours to minutes with automated root cause analysis"
+
+### Engineering Leaders
+**Focus:** Productivity, costs, team velocity
+
+"Ship 2x faster by eliminating [bottleneck]"
+
+### Security Teams
+**Focus:** Compliance, security, visibility
+
+"SOC 2 Type II compliant with built-in audit logging"
+
+---
+
+## Messaging by Launch Tier
+
+### Tier 1 (Major Launch)
+- **Bold claims** backed by data
+- **Vision** for the future
+- **Ecosystem** impact
+- **Industry** transformation
+
+**Example:**
+"Redefining how developers build distributed systems"
+
+### Tier 2 (Standard)
+- **Practical benefits**
+- **Specific use cases**
+- **Integration** value
+- **Productivity** gains
+
+**Example:**
+"The fastest way to add real-time features to your app"
+
+### Tier 3 (Minor)
+- **Specific improvement**
+- **Developer benefit**
+- **Clear changelog**
+
+**Example:**
+"Python SDK now 3x faster with async support"
+
+---
+
+## Competitive Positioning
+
+### When to Mention Competitors
+
+**DO mention when:**
+- You have clear technical superiority
+- Migration is a key use case
+- Comparison requested by prospects
+
+**DON'T mention when:**
+- You're the market leader
+- Competitor is much larger
+- Claim isn't defensible
+
+### Competitive Messaging Template
+
+"Unlike [Competitor], [Product] [specific advantage]:
+
+**[Competitor]:**
+- [Limitation 1]
+- [Limitation 2]
+
+**[Product]:**
+- [Advantage 1] - [metric]
+- [Advantage 2] - [metric]
+
+[Code comparison or performance benchmark]"
+
+---
+
+## Technical Credibility Signals
+
+Include these to build trust:
+
+- **Open source** components used
+- **Standards** supported (OpenTelemetry, OAuth, etc.)
+- **Scale** handled (requests/sec, data volume)
+- **Customers** using in production (if allowed)
+- **Team background** (ex-Google, ex-AWS, etc.)
+- **Security** certifications (SOC 2, ISO 27001)
+- **Performance** benchmarks
+- **GitHub** stars (if applicable)
+
+---
+
+## Avoiding Common Mistakes
+
+### Mistake 1: Too Abstract
+**Bad:** "Simplify your workflow"
+**Good:** "Reduce deployment time from 45 minutes to 2 minutes"
+
+### Mistake 2: Jargon Overload
+**Bad:** "Leverage synergistic paradigms"
+**Good:** "Run the same code on AWS, GCP, and Azure"
+
+### Mistake 3: No Proof
+**Bad:** "The fastest API"
+**Good:** "p99 latency < 50ms (see benchmark: [link])"
+
+### Mistake 4: Feature List
+**Bad:** "Includes caching, retries, and monitoring"
+**Good:** "Auto-retry failed requests up to 3x with exponential backoff"
+
+### Mistake 5: Ignoring Migration
+**Bad:** [No mention of existing solutions]
+**Good:** "Migrate from [Competitor] in under 1 hour: [guide]"
+
+---
+
+## Testing Your Messaging
+
+### Internal Test
+- [ ] Can a new engineer explain the value?
+- [ ] Do engineers volunteer to use it?
+- [ ] Does it pass the "so what?" test?
+
+### External Test
+- [ ] Beta feedback positive?
+- [ ] Clear from HN/Reddit comments?
+- [ ] Low support questions about "what is it?"
+
+### Metrics to Watch
+- Email open rate (> 25% good for developer emails)
+- Click-through rate to docs (> 10%)
+- Sign-up conversion (depends on product)
+- Social engagement (shares, comments)
+- Media pickup (for Tier 1)
+
+---
+
+## Summary
+
+**Technical messaging succeeds when:**
+1. Problem is relatable
+2. Solution is clear (with code)
+3. Benefits are concrete
+4. Limitations are honest
+5. Getting started is easy
+
+**Keep developer-first always.**
--- a/skills/technical-launch-planner/references/launch_tiers.md
+++ b/skills/technical-launch-planner/references/launch_tiers.md
@@ -0,0 +1,553 @@
+# Launch Tier Framework
+
+Complete guide to determining and executing different launch tiers for technical products.
+
+---
+
+## Overview
+
+Not all launches are created equal. The launch tier framework helps you allocate the right resources and effort based on the scope and impact of what you're launching.
+
+**Key Principle:** Match investment to impact.
+
+---
+
+## The Three Tiers
+
+| Tier | Type | Investment | Timeline | Example |
+|------|------|------------|----------|---------|
+| **Tier 1** | Major | Full GTM | 12-16 weeks | New product GA, v2.0 |
+| **Tier 2** | Standard | Selective GTM | 6-8 weeks | New feature, integration |
+| **Tier 3** | Minor | Minimal GTM | 2-4 weeks | Update, improvement |
+
+---
+
+## Tier 1: Major Launch
+
+### When to Use
+
+- **New product GA** (General Availability)
+- **Major version release** (v2.0, v3.0)
+- **Platform expansion** (new capabilities)
+- **Game-changing feature** (industry first)
+- **New market entry**
+
+### Characteristics
+
+**Scope:**
+- Impacts all or most users
+- New revenue stream potential
+- Significant competitive differentiation
+- Industry-level interest expected
+- Major technical undertaking
+
+**Timeline:** 12-16 weeks
+
+**Budget:** $50K-$500K+ depending on company size
+
+---
+
+### Deliverables
+
+#### Documentation (Complete Set)
+- [ ] Getting started guide
+- [ ] Complete API reference
+- [ ] Integration guides (3+)
+- [ ] Migration guide
+- [ ] Best practices guide
+- [ ] Troubleshooting guide
+- [ ] Video tutorial series (5+ videos)
+- [ ] Architecture documentation
+
+#### Code Assets
+- [ ] Multiple SDKs (3+ languages)
+- [ ] Sample applications (3+ different use cases)
+- [ ] Starter templates
+- [ ] Code snippet library
+- [ ] Interactive playground/sandbox
+- [ ] CLI tools (if applicable)
+
+#### Marketing Assets
+- [ ] Launch blog post (long-form)
+- [ ] Product page redesign
+- [ ] Demo video (professional)
+- [ ] Case studies (2-3)
+- [ ] Infographic/visual assets
+- [ ] Explainer video
+- [ ] Social media campaign
+- [ ] Email nurture series
+
+#### PR & Communications
+- [ ] Press release
+- [ ] Media kit
+- [ ] Analyst briefings (Gartner, Forrester)
+- [ ] Press tour
+- [ ] Spokesperson training
+- [ ] Crisis communication plan
+
+#### Sales Enablement
+- [ ] Technical battlecard
+- [ ] Competitive analysis
+- [ ] Demo script (detailed)
+- [ ] ROI calculator
+- [ ] Customer presentation deck
+- [ ] Pricing/packaging materials
+- [ ] FAQ (20+ questions)
+
+#### Events
+- [ ] Launch event/webinar
+- [ ] Customer workshops
+- [ ] Conference talks
+- [ ] Community meetups
+
+---
+
+### Launch Channels
+
+**Primary:**
+- Developer documentation (hero banner)
+- Company blog (featured)
+- Email (entire developer base)
+- Social media (coordinated campaign)
+- Product Hunt launch
+- Hacker News announcement
+- Press release distribution
+
+**Secondary:**
+- Tech press outreach (TechCrunch, VentureBeat, etc.)
+- Developer communities (Reddit, Dev.to)
+- YouTube (demo + tutorials)
+- Podcasts (interviews)
+- Webinars
+- Virtual events
+
+**Tertiary:**
+- Conference presentations
+- Industry publications
+- Analyst reports
+- Partner co-marketing
+- Influencer outreach
+
+---
+
+### Team & Resources
+
+**Core Launch Team:**
+- Product Marketing Lead
+- Product Manager
+- Engineering Lead
+- Developer Relations
+- Sales Engineering
+- PR/Communications
+- Content Marketing
+- Design
+- Legal/Compliance
+
+**External Resources:**
+- PR agency
+- Video production
+- Event planning
+- Analyst relations
+
+**Time Commitment:**
+- PMM: 100% for 8+ weeks
+- PM: 50%
+- Eng: 25% (docs, demos)
+- DevRel: 75%
+
+---
+
+### Success Metrics (Tier 1)
+
+**Week 1:**
+- 10K+ API keys / sign-ups
+- 50%+ activation rate
+- 1M+ webpage views
+- 100K+ social impressions
+- 10+ press mentions
+
+**Month 1:**
+- 25K+ active developers
+- 40%+ Day 7 retention
+- 5%+ paid conversion (if applicable)
+- NPS > 40
+
+**Quarter 1:**
+- 50K+ active developers
+- $X ARR (if revenue product)
+- 3+ case studies published
+- Industry recognition (awards, mentions)
+
+---
+
+### Budget Breakdown (Example)
+
+| Item | Cost Range |
+|------|------------|
+| PR Agency | $20K-$50K |
+| Video Production | $10K-$30K |
+| Event/Webinar | $15K-$40K |
+| Paid Promotion | $25K-$100K |
+| Analyst Relations | $10K-$30K |
+| Design Assets | $5K-$15K |
+| Tools/Software | $5K-$10K |
+| **Total** | **$90K-$275K** |
+
+---
+
+## Tier 2: Standard Launch
+
+### When to Use
+
+- **New feature** (significant but not transformative)
+- **Integration** with popular tool
+- **SDK** for new language
+- **Regional expansion**
+- **Beta to GA** transition
+
+### Characteristics
+
+**Scope:**
+- Impacts segment of users (25-75%)
+- Moderate revenue impact
+- Some competitive differentiation
+- Developer community interest
+- Moderate technical complexity
+
+**Timeline:** 6-8 weeks
+
+**Budget:** $10K-$50K
+
+---
+
+### Deliverables
+
+#### Documentation
+- [ ] Feature guide
+- [ ] API reference updates
+- [ ] Code samples (3-5)
+- [ ] Integration tutorial
+- [ ] Migration guide (if applicable)
+- [ ] Video demo (1-2)
+
+#### Code Assets
+- [ ] SDK (if new language)
+- [ ] Sample application (1-2)
+- [ ] Code snippets
+- [ ] Sandbox example
+
+#### Marketing Assets
+- [ ] Launch blog post
+- [ ] Product page update
+- [ ] Demo video
+- [ ] Email template
+- [ ] Social media posts
+- [ ] Changelog entry (detailed)
+
+#### Sales Enablement
+- [ ] Feature overview (1-pager)
+- [ ] Demo talking points
+- [ ] FAQ (10+ questions)
+- [ ] Competitive comparison
+
+---
+
+### Launch Channels
+
+**Primary:**
+- Developer blog
+- Email (targeted segment)
+- Changelog (featured)
+- Social media
+- In-product notification
+
+**Secondary:**
+- Developer newsletter
+- Community forums
+- YouTube demo
+- Partner channels (if applicable)
+
+**Optional:**
+- Dev.to article
+- Reddit post (relevant subreddits)
+- Product Hunt (if major feature)
+
+---
+
+### Team & Resources
+
+**Core Team:**
+- Product Marketing Lead
+- Product Manager
+- Developer Relations
+- Engineering (docs)
+- Content Writer
+
+**Time Commitment:**
+- PMM: 75% for 4 weeks
+- PM: 25%
+- Eng: 10% (docs)
+- DevRel: 40%
+
+---
+
+### Success Metrics (Tier 2)
+
+**Week 1:**
+- 2K+ feature adoptions
+- 1K+ email opens
+- 50K+ blog views
+
+**Month 1:**
+- 5K+ active users
+- 25%+ engagement rate
+- NPS > 30
+
+---
+
+### Budget (Example)
+
+| Item | Cost |
+|------|------|
+| Video Production | $3K-$8K |
+| Design Assets | $2K-$5K |
+| Email Platform | $500 |
+| Paid Promotion (optional) | $5K-$15K |
+| **Total** | **$10.5K-$28.5K** |
+
+---
+
+## Tier 3: Minor Launch
+
+### When to Use
+
+- **Incremental improvements**
+- **Bug fixes** (significant ones)
+- **Performance enhancements**
+- **Small feature** additions
+- **UI/UX updates**
+- **Deprecation** notices
+
+### Characteristics
+
+**Scope:**
+- Impacts small segment (<25%)
+- Minimal revenue impact
+- No competitive angle
+- Low external interest
+- Simple technical change
+
+**Timeline:** 2-4 weeks
+
+**Budget:** $1K-$5K
+
+---
+
+### Deliverables
+
+#### Documentation
+- [ ] Release notes
+- [ ] Documentation updates
+- [ ] Changelog entry
+
+#### Marketing Assets
+- [ ] Short blog post or announcement
+- [ ] Email (optional)
+- [ ] Social media post (single)
+
+---
+
+### Launch Channels
+
+**Primary:**
+- Changelog
+- Release notes
+- Documentation
+
+**Secondary (optional):**
+- Short blog post
+- Email mention
+- Social media (single post)
+- In-product notification
+
+---
+
+### Team & Resources
+
+**Minimal Team:**
+- Product Manager or PMM
+- Engineering (docs)
+
+**Time Commitment:**
+- PM/PMM: 25% for 1 week
+- Eng: 5% (docs)
+
+---
+
+### Success Metrics (Tier 3)
+
+**Week 1:**
+- Documentation viewed
+- Feature adopted by target users
+- No support spikes
+
+**Month 1:**
+- 10-20% of eligible users adopt
+- Positive sentiment
+
+---
+
+### Budget
+
+Typically < $5K, mostly internal time.
+
+---
+
+## Decision Framework
+
+### Scoring System
+
+Use the `assess_launch_tier.sh` script or manually score:
+
+**Score Components:**
+
+1. **Type of Launch** (0-10 points)
+   - New product/GA: 10
+   - Major version: 8
+   - New feature: 5
+   - Improvement: 2
+   - Bug fix: 0
+
+2. **User Impact** (0-10 points)
+   - All users (100%): 10
+   - Most users (50-99%): 7
+   - Segment (25-50%): 5
+   - Small segment (<25%): 2
+   - Beta only: 1
+
+3. **Revenue Impact** (0-10 points)
+   - New revenue stream: 10
+   - Major driver: 7
+   - Moderate: 4
+   - Minor: 2
+   - None: 0
+
+4. **Competitive Differentiation** (0-8 points)
+   - Industry first: 8
+   - Significant: 6
+   - Some: 4
+   - Parity: 1
+   - None: 0
+
+5. **Technical Complexity** (0-7 points)
+   - New platform: 7
+   - Significant: 5
+   - Moderate: 3
+   - Simple: 1
+   - Minor: 0
+
+6. **Documentation Needs** (0-6 points)
+   - Complete new set: 6
+   - Major updates: 5
+   - New guides: 3
+   - Updates: 1
+   - Release notes only: 0
+
+7. **External Interest** (0-7 points)
+   - High (industry news): 7
+   - Moderate (tech press): 5
+   - Some (community): 3
+   - Low (niche): 1
+   - Minimal: 0
+
+**Total Score: 0-58**
+
+**Tier Assignment:**
+- **40-58:** Tier 1 (Major)
+- **20-39:** Tier 2 (Standard)
+- **0-19:** Tier 3 (Minor)
+
+---
+
+## Common Scenarios
+
+### Scenario 1: API GA Launch
+**Type:** New product
+**Users:** All (new audience)
+**Revenue:** New stream
+**Competitive:** Industry first capability
+**Technical:** New platform
+**Docs:** Complete set
+**Interest:** High
+
+**Score:** 52 → **Tier 1**
+
+---
+
+### Scenario 2: New Language SDK
+**Type:** New integration
+**Users:** Segment (e.g., Python devs)
+**Revenue:** Moderate impact
+**Competitive:** Parity
+**Technical:** Moderate
+**Docs:** New guide
+**Interest:** Some
+
+**Score:** 25 → **Tier 2**
+
+---
+
+### Scenario 3: Performance Update
+**Type:** Improvement
+**Users:** All
+**Revenue:** None direct
+**Competitive:** None
+**Technical:** Simple
+**Docs:** Updates
+**Interest:** Low
+
+**Score:** 12 → **Tier 3**
+
+---
+
+## Best Practices
+
+### Right-Sizing
+
+**Over-investing (Tier 3 as Tier 1):**
+- Wastes resources
+- Confuses users ("This isn't major")
+- Diminishes future Tier 1 launches
+
+**Under-investing (Tier 1 as Tier 3):**
+- Misses opportunity
+- Poor adoption
+- Competitive disadvantage
+
+### Flexibility
+
+**Adjust tier based on:**
+- Company stage (early vs. mature)
+- Market position (leader vs. challenger)
+- Resources available
+- Strategic importance
+
+### Communication
+
+**Be explicit with stakeholders:**
+- "This is a Tier 2 launch, so we'll do X but not Y"
+- Set clear expectations upfront
+- Document tier decision and reasoning
+
+---
+
+## Summary
+
+Use launch tiers to:
+1. **Match effort to impact**
+2. **Set stakeholder expectations**
+3. **Allocate resources efficiently**
+4. **Maintain consistency**
+5. **Maximize ROI**
+
+**Remember:** A well-executed Tier 2 launch beats a poorly-executed Tier 1.
--- a/skills/technical-launch-planner/references/metrics_frameworks.md
+++ b/skills/technical-launch-planner/references/metrics_frameworks.md
@@ -0,0 +1,562 @@
+# Developer Product Metrics
+
+Comprehensive guide to measuring success for technical products, developer tools, and APIs.
+
+---
+
+## Why Developer Metrics Are Different
+
+Developer products have unique characteristics:
+- **High technical barriers** to adoption
+- **Longer evaluation** periods
+- **Community-driven** growth
+- **Usage-based** pricing models
+- **Quality over quantity** (one great developer > 100 casual users)
+
+Traditional B2B SaaS metrics don't always apply directly.
+
+---
+
+## The Developer Funnel
+
+```
+Awareness → Interest → Evaluation → Activation → Engagement → Retention → Monetization
+```
+
+Each stage has specific metrics.
+
+---
+
+## 1. Awareness Metrics
+
+### Top-of-Funnel
+
+**Website Traffic:**
+- Documentation page views
+- Landing page visits
+- Blog traffic
+- GitHub repository views
+
+**Search & Discovery:**
+- Organic search rankings (for key terms)
+- GitHub stars
+- Stack Overflow mentions
+- Social media mentions
+
+**Community Presence:**
+- Discord/Slack members
+- Reddit subscribers
+- Newsletter subscribers
+- Conference attendance
+
+**Targets (vary by company):**
+- 50K monthly docs views (early stage)
+- 500K monthly docs views (growth stage)
+- 1K+ GitHub stars (open source component)
+
+---
+
+## 2. Interest Metrics
+
+### Consideration Stage
+
+**Engagement:**
+- Time on documentation
+- Pages per session
+- Video views (tutorials)
+- GitHub README views
+
+**Content Consumption:**
+- Blog post reads
+- Tutorial completion rate
+- Demo video watch time
+- Webinar registrations
+
+**Social Proof:**
+- Case study views
+- Customer testimonials read
+- Comparison page visits
+
+**Targets:**
+- 5+ minute average session duration
+- 4+ pages per session
+- 50%+ video completion rate
+
+---
+
+## 3. Evaluation Metrics
+
+### Trial/Sandbox Stage
+
+**Sign-Up:**
+- Developer sign-ups
+- API key requests
+- Sandbox activations
+- Free tier activations
+
+**Time to Value:**
+- **Time to first API call** (target: < 10 minutes)
+- **Time to "Hello World"** (target: < 15 minutes)
+- **Time to integration** (target: < 1 hour)
+
+**Documentation Engagement:**
+- Getting started guide views
+- Code sample copies
+- SDK downloads
+- Postman collection imports
+
+**Targets:**
+- 1K+ sign-ups per month (early stage)
+- 60% make first API call within 24 hours
+- 10 minutes median time to first call
+
+---
+
+## 4. Activation Metrics
+
+### First Value Realized
+
+**Critical Activation Events:**
+- **First successful API call**
+- **First integration deployed**
+- **First production request**
+- **SDK installed and used**
+- **Sandbox → production migration**
+
+**Activation Rate:**
+```
+Activation Rate = (Users who complete activation event) / (Total sign-ups)
+```
+
+**Depth of Activation:**
+- Features explored
+- Endpoints called
+- SDKs used
+- Integrations enabled
+
+**Targets:**
+- 50-70% activation rate (first API call)
+- 30-40% activation rate (production deployment)
+- 80%+ complete getting started guide
+
+---
+
+## 5. Engagement Metrics
+
+### Active Usage
+
+**Daily/Weekly/Monthly Active Developers (DAD/WAD/MAD):**
+```
+DAD = Unique developers making API calls daily
+WAD = Unique developers active weekly
+MAD = Unique developers active monthly
+```
+
+**Stickiness:**
+```
+Stickiness = DAD / MAD
+```
+- Target: > 20% (good)
+- Target: > 40% (excellent)
+
+**API Usage:**
+- **Total API calls** per day/week/month
+- **API calls per developer**
+- **Endpoints used** per developer
+- **Error rate** (target: < 1%)
+
+**Feature Adoption:**
+- % of developers using key features
+- Time to feature adoption
+- Feature depth (how many features per user)
+
+**Targets:**
+- 40%+ stickiness (DAD/MAD)
+- 1K+ API calls per active developer per month
+- < 1% error rate
+- 3+ features adopted per developer
+
+---
+
+## 6. Retention Metrics
+
+### Developer Retention
+
+**Cohort Retention:**
+```
+Day 1 Retention = Developers active on Day 1 / Total sign-ups
+Day 7 Retention = Developers active on Day 7 / Total sign-ups
+Day 30 Retention = Developers active on Day 30 / Total sign-ups
+```
+
+**Typical Developer Product Retention:**
+- Day 1: 60-70%
+- Day 7: 30-50%
+- Day 30: 20-40%
+- Day 90: 15-30%
+
+**Why Developer Retention Is Lower:**
+- Evaluation period (many are just testing)
+- Project-based usage (finish project, stop using)
+- This is normal and expected
+
+**Churn Rate:**
+```
+Monthly Churn = Developers who stopped using / Active developers at month start
+```
+
+**Resurrection Rate:**
+```
+Resurrection = Churned developers who return / Total churned developers
+```
+
+**Targets:**
+- < 5% monthly churn (paid users)
+- 40%+ Day 7 retention
+- 25%+ Day 30 retention
+
+---
+
+## 7. Monetization Metrics
+
+### Revenue Metrics
+
+**Conversion Metrics:**
+```
+Free → Paid Conversion Rate = Paid users / Total active users
+```
+- Target: 3-10% (varies widely by product)
+
+**Revenue Metrics:**
+- **MRR** (Monthly Recurring Revenue)
+- **ARR** (Annual Recurring Revenue)
+- **ARPU** (Average Revenue Per User)
+- **Net Revenue Retention** (NRR)
+
+**Usage-Based Pricing Metrics:**
+- **Average API calls per paid user**
+- **Tier distribution** (how many in each pricing tier)
+- **Upgrade rate** (free → paid, basic → pro)
+- **Expansion revenue** (existing customers spending more)
+
+**Targets:**
+- 5%+ free-to-paid conversion
+- 110%+ Net Revenue Retention
+- $50-$500 ARPU (varies by product)
+
+---
+
+## Developer-Specific Metrics
+
+### Code Quality Metrics
+
+**SDK Quality:**
+- **Downloads** per month
+- **GitHub stars**
+- **Issues opened** vs. closed
+- **PR acceptance** rate
+- **Time to resolve** issues
+
+**Documentation Quality:**
+- **Search success** rate (did they find what they needed?)
+- **Time on page** (too short = unclear, too long = can't find)
+- **Bounce rate** on docs
+- **Feedback** (thumbs up/down on docs pages)
+
+**Targets:**
+- 90%+ search success rate
+- < 40% bounce rate on docs
+- 80%+ positive feedback on docs
+
+---
+
+### Developer Experience Metrics
+
+**Time-Based:**
+- Time to first API call
+- Time to production
+- Time to integrate
+- Time to debug
+
+**Friction Points:**
+- Authentication failures
+- API errors
+- SDK install issues
+- Documentation gaps
+
+**Support Metrics:**
+- Support tickets per MAD
+- Time to first response
+- Time to resolution
+- Community forum response time
+
+**Targets:**
+- < 5 minutes to first API call
+- < 1 support ticket per 100 MAD
+- < 4 hours first response time
+- 90%+ questions answered by community
+
+---
+
+## Developer Satisfaction
+
+### Net Promoter Score (NPS)
+
+Survey question: "How likely are you to recommend [product] to other developers?"
+
+**Scale:** 0-10
+
+**Calculation:**
+```
+NPS = % Promoters (9-10) - % Detractors (0-6)
+```
+
+**Developer Product Benchmarks:**
+- **Excellent:** NPS > 50
+- **Good:** NPS 30-50
+- **Needs Work:** NPS < 30
+
+### Developer Sentiment
+
+**Qualitative Indicators:**
+- Social media sentiment
+- Community forum tone
+- GitHub issue sentiment
+- Review site ratings (G2, Capterra)
+- Stack Overflow sentiment
+
+**Quantitative Tracking:**
+- Positive vs. negative mentions
+- Sentiment score (automated analysis)
+- Review ratings (1-5 stars)
+
+---
+
+## Launch-Specific Metrics
+
+### Launch Day Metrics
+
+**Day 1:**
+- Sign-ups / API keys
+- First API calls
+- Documentation views
+- Blog post views
+- Social media impressions
+- Email open rate
+- Email click rate
+
+**Targets (Tier 1 launch):**
+- 5K+ sign-ups
+- 50%+ activation rate (first call)
+- 100K+ docs views
+- 50K+ blog views
+
+---
+
+### Week 1 Metrics
+
+- Total sign-ups
+- Day 7 retention rate
+- Active developers
+- API calls made
+- Support tickets
+- Community questions
+- Social mentions
+
+**Targets (Tier 1):**
+- 10K+ total sign-ups
+- 40%+ Day 7 retention
+- 5K+ active developers
+- 1M+ API calls
+- < 50 support tickets
+
+---
+
+### Month 1 Metrics
+
+- Monthly Active Developers (MAD)
+- Free → paid conversion
+- NPS score
+- Documentation coverage (no major gaps)
+- Community health
+- Feature adoption
+
+**Targets (Tier 1):**
+- 25K+ MAD
+- 3-5% paid conversion
+- NPS > 40
+- 80%+ positive doc feedback
+
+---
+
+## Metrics Dashboard Template
+
+### Executive Dashboard
+
+**Adoption:**
+- Total Developers: [X]
+- MAD: [X]
+- Growth Rate: [X%]
+
+**Engagement:**
+- DAD/MAD: [X%]
+- API Calls/Day: [X]
+- Error Rate: [X%]
+
+**Retention:**
+- Day 7: [X%]
+- Day 30: [X%]
+- Churn: [X%]
+
+**Revenue:**
+- MRR: $[X]
+- ARPU: $[X]
+- NRR: [X%]
+
+**Quality:**
+- NPS: [X]
+- Support Tickets/MAD: [X]
+
+---
+
+### Product Team Dashboard
+
+**This Week:**
+- New Developers: [X]
+- Activation Rate: [X%]
+- Features Adopted: [X]
+- Top API Endpoints: [List]
+
+**Trends:**
+- MAD (7-day trend): [Graph]
+- API Calls (7-day): [Graph]
+- Error Rate (7-day): [Graph]
+
+**Health:**
+- Documentation Gaps: [Count]
+- Open Issues: [Count]
+- P0 Bugs: [Count]
+
+---
+
+## Metric Collection
+
+### Where to Track
+
+**Product Analytics:**
+- Amplitude
+- Mixpanel
+- Heap
+- PostHog
+
+**API Analytics:**
+- Moesif
+- API metrics (custom)
+- CloudWatch / Datadog
+
+**Documentation Analytics:**
+- Google Analytics
+- Readme.io analytics
+- GitBook analytics
+
+**Developer Feedback:**
+- Intercom
+- Zendesk
+- Community forum analytics
+- Survey tools (Delighted, SurveyMonkey)
+
+---
+
+## Setting Targets
+
+### Early Stage (0-1 year)
+
+Focus on **activation** and **engagement**:
+- Sign-ups: 1K-10K/month
+- Activation: 50%+
+- MAD: 500-5K
+- Day 7 Retention: 30%+
+
+### Growth Stage (1-3 years)
+
+Focus on **scale** and **retention**:
+- Sign-ups: 10K-50K/month
+- MAD: 10K-100K
+- Day 30 Retention: 25%+
+- Free→Paid: 5%+
+
+### Mature Stage (3+ years)
+
+Focus on **efficiency** and **expansion**:
+- MAD: 100K+
+- NRR: 110%+
+- ARPU: Increasing
+- CAC Payback: < 12 months
+
+---
+
+## Common Pitfalls
+
+### Vanity Metrics
+
+**Avoid:**
+- Total registered users (most are inactive)
+- Total API calls (could be from one user)
+- GitHub stars alone (may not use product)
+
+**Focus on:**
+- Active users (making API calls)
+- Retained users (coming back)
+- Engaged users (using multiple features)
+
+### Wrong Benchmarks
+
+Don't compare developer product metrics to:
+- B2C social apps (much higher DAU/MAU)
+- Enterprise SaaS (lower volume, higher ACV)
+- E-commerce (transactional, not sustained use)
+
+Use developer product benchmarks instead.
+
+---
+
+## Summary: Key Metrics to Track
+
+**Must Track:**
+1. Monthly Active Developers (MAD)
+2. Activation Rate (first API call)
+3. Day 7 & Day 30 Retention
+4. Stickiness (DAD/MAD)
+5. API Error Rate
+6. NPS
+
+**Should Track:**
+7. Free → Paid Conversion
+8. Time to First API Call
+9. Documentation Effectiveness
+10. Support Ticket Volume
+
+**Nice to Have:**
+11. GitHub Stars/Activity
+12. Community Engagement
+13. Social Sentiment
+14. Feature Adoption Depth
+
+Start with the must-track metrics, then expand.
+
+---
+
+## Developer Metric Formulas
+
+Quick reference:
+
+```
+Activation Rate = Activated Users / Sign-ups
+Stickiness = DAD / MAD
+Churn Rate = Users Lost / Total Users
+NRR = (MRR + Expansion - Churn) / Starting MRR
+LTV = ARPU / Churn Rate
+CAC Payback = CAC / (ARPU * Gross Margin)
+```
+
+**Remember:** Metrics should drive action, not just reporting. If a metric doesn't change behavior, don't track it.