Skill

Market open source projects authentically and grow contributors

Markets open source projects authentically, covering README/repo optimization, contributor funnel, HN/Reddit launches, and sustainable growth.

Works with githubdiscordslackhacker newsreddit

74
Spark score
out of 100
Updated 4 months ago
Version 1.0.0

Add to Favorites

Why it matters

Help developers and maintainers market open source projects effectively by optimizing GitHub presence, building genuine communities, creating welcoming contributor experiences, and executing strategic launches that drive sustainable growth without being spammy or inauthentic.

Outcomes

What it gets done

01

Optimize GitHub repositories with compelling READMEs, badges, topics, and issue templates that convert visitors into users and contributors

02

Build and nurture open source communities through responsive engagement, contributor recognition, and appropriate platform selection

03

Create welcoming contributor experiences with clear CONTRIBUTING.md files, good first issues, and smooth onboarding processes

04

Execute strategic launches across Hacker News, Reddit, Twitter, and other platforms with proper timing and messaging

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-open-source-marketing | bash

Overview

Open Source Marketing

This skill markets open source projects authentically: README and repo optimization, community and contributor-funnel building, a platform-specific launch playbook (HN, Reddit, Twitter), and sustainable growth tactics tracked by value metrics rather than vanity metrics. Use it for OSS marketing, GitHub growth, launch planning, contributor community building, or sustainable OSS growth. Not for general devrel content strategy or conference speaking - those are separate skills.

What it does

Helps market an open source project without being cringe, working from a growth equation - growth equals real value times discoverability times first-use experience, where any factor at zero means zero growth. It first loads developer-audience context (who'd use the project, where they discover tools, what alternatives exist, how they evaluate OSS) before making recommendations. README optimization treats the README as the landing page: a structured template (one-line description, badges, screenshot/GIF, benefits, a quick start under 5 lines to first value, installation, usage, docs link, contributing, license) scored against a 10-item checklist covering name memorability, differentiation, and copy-paste installation. Repository optimization covers a keyword-rich 100-character description, 5-10 discoverability topics, semantic-versioned releases with changelogs, issue/PR templates, and enabling Discussions. Community building starts with GitHub Discussions, adding Discord past 50 active users, on five principles: respond to issues within 48 hours, publicly celebrate every contributor, share the roadmap transparently, set a clear maintainer-response SLA, and welcome newcomers with "good first issue" labels. It maps and optimizes each step of the contributor funnel (user to star to issue to PR to regular contributor to maintainer) with a specific lever per transition, and defines what makes a genuinely approachable "good first issue" (add TypeScript types, fix a typo, add one test) versus a bad one (refactor the whole codebase, debug an intermittent CI failure). Launch strategy runs a 10-item pre-launch checklist, then a same-day playbook (Hacker News post at 6-8am PT Tuesday-Thursday, a Twitter thread an hour later, a Reddit post two hours in, continuous comment response, end-of-day thanks and metrics) with platform-specific tactics: HN wants a hype-free "Show HN" title and a first comment explaining motivation - never asking for upvotes; Reddit wants 2-3 genuinely relevant subreddits and community-member behavior, not marketing; Twitter wants a problem-solution-demo-link thread with GIF/video; Dev.to/Hashnode wants a personal "why I built this" story. Post-launch follows a month-long cadence from bug-fixing week one through starting a regular release and community-building cadence by month one. Sustainable growth tactics are ranked by effort/impact/timeline (SEO-optimized docs and integration tutorials rated high-impact over 1-6 months; newsletter features low-effort but modest impact), alongside a content-type menu (why-we-built-X, X-vs-Y-vs-Z comparisons, migration guides, integration posts, benchmarks) and burnout mitigations (response SLA expectations, a public roadmap/RFC process to contain feature demands, actively recruiting co-maintainers, scheduled office hours instead of always-on availability, and a moderated code of conduct). Metrics are split into vanity (stars, forks, downloads, follower count) versus value (active issues and PRs, returned contributors, weekly active users, community engagement), tracked via GitHub Insights/Traffic, Star History, npm-stat, and Discord/Slack member counts.

When to use - and when NOT to

Use it when someone wants to market an open source project, grow GitHub stars, launch on Hacker News or Reddit, build a contributor community, or grow sustainably without spammy self-promotion. It's specifically about authentic OSS growth tactics - README/repo optimization, community and contributor mechanics, launch playbooks, sustainable growth - not general developer relations content strategy or conference speaking, which are separate skills.

Inputs and outputs

Input is the project's current README, repo settings, and launch or growth stage. Output is a polished README and repo configuration, a contributor-funnel and community plan, a platform-specific launch playbook and timeline, or a prioritized sustainable-growth tactic list with effort/impact/timeline estimates.

Integrations

Reads .agents/developer-audience-context.md (or runs the developer-audience-context skill first if missing) and hands off to community-building, devrel-content, developer-advocacy, and hacker-news-strategy skills for adjacent work; recommends tools like Octolens for cross-platform mention monitoring, Star History, npm-stat, and Shield.io badges.

Who it's for

Maintainers and developer-marketing teams launching or growing an open source project who want authentic, non-spammy tactics for GitHub optimization, contributor growth, and platform-specific launches rather than generic marketing playbooks.

Source README

Open Source Marketing

When to Use

Use this skill when you need when the user wants to market an open source project authentically. Trigger phrases include "open source marketing," "OSS marketing," "GitHub marketing," "promote my library," "grow stars," "launch open source," "open source growth," or "contributor marketing.".

This skill helps you market open source projects without being cringe. Covers GitHub optimization, community building, contributor experience, launch strategies, and sustainable growth.


Before You Start

Load your audience context first. Read .agents/developer-audience-context.md to understand:

  • Who would use this project (role, tech stack, problem)
  • Where they discover tools (communities, social, search)
  • What alternatives exist (why would they switch?)
  • How they evaluate OSS (stars, activity, docs, community)

If the context file doesn't exist, run the developer-audience-context skill first.


The OSS Marketing Mindset

What Works vs. What Doesn't

Works Doesn't Work
Building in public Spamming "check out my project"
Solving real problems Building solutions seeking problems
Genuine community engagement Transactional follows/unfollows
Great docs and DX "The code is self-documenting"
Celebrating contributors Taking sole credit
Consistent presence Launch and disappear

The Growth Equation

Growth = (Real value) × (Discoverability) × (First-use experience)

If any factor is zero, growth is zero.


GitHub Optimization

README Excellence

Your README is your landing page. Optimize it.

Structure:

### Project Name

[One-line description that explains what it does]

[Badges: build status, version, license, downloads]

[Screenshot or GIF showing it in action]

### Why [Project Name]?

- ✅ [Benefit 1 - specific, not fluffy]
- ✅ [Benefit 2]
- ✅ [Benefit 3]

### Quick Start

\`\`\`bash
npm install project-name
\`\`\`

\`\`\`javascript
// 5 lines that show immediate value
\`\`\`

### Installation

[Detailed installation for all platforms]

### Usage

[Core usage patterns with examples]

### Documentation

[Link to full docs]

### README Checklist

| Element | Why It Matters |
|---------|---------------|
| **Clear name** | Memorable, searchable, spellable |
| **One-liner** | "A [type] for [audience] that [does what]" |
| **Badges** | Social proof, health signals |
| **Visual** | GIF > Screenshot > Nothing |
| **Quick start** | <5 lines to first value |
| **Why this?** | Differentiation from alternatives |
| **Installation** | All platforms, copy-paste |
| **Examples** | Real use cases, not contrived |
| **Docs link** | More detail available |
| **Contributing** | Community welcome |

### Repository Optimization

| Element | Best Practice |
|---------|--------------|
| **Description** | 100 chars max, keyword-rich |
| **Topics** | 5-10 relevant tags for discoverability |
| **Website** | Link to docs or landing page |
| **Releases** | Semantic versioning, changelogs |
| **Issues** | Templates for bugs/features |
| **Discussions** | Enable for community Q&A |
| **Sponsors** | Enable if you want funding |

### Issue & PR Templates

**Bug report template:**

```markdown
---
name: Bug Report
about: Report a bug to help us improve
---

#### Bug Description
[Clear description]

#### Steps to Reproduce
1.
2.
3.

#### Expected Behavior
[What should happen]

#### Actual Behavior
[What actually happens]

#### Environment
- OS:
- Node version:
- Package version:

#### Additional Context
[Screenshots, logs, etc.]

Feature request template:

---
name: Feature Request
about: Suggest an idea for this project
---

#### Problem
[What problem does this solve?]

#### Proposed Solution
[How would you like it to work?]

#### Alternatives Considered
[Other approaches you've thought about]

#### Additional Context
[Examples, mockups, etc.]

Community Building

Community Spaces

Platform Best For Setup Effort
GitHub Discussions Q&A, announcements Low
Discord Real-time chat, community feel Medium
Slack Enterprise communities Medium
Forum (Discourse) Async, searchable discussions High

Start with GitHub Discussions. Add Discord when you have 50+ active users.

Community Principles

Principle Implementation
Be responsive Respond to issues within 48 hours (even if just "looking into it")
Celebrate contributions Thank every contributor publicly
Be transparent Share roadmap, explain decisions
Set expectations Clear SLA for maintainer response
Welcome newcomers "good first issue" labels, mentorship

Contributor Funnel

User → Star → Issue → PR → Regular Contributor → Maintainer

Optimize each transition:

Transition How to Improve
User → Star Great README, visible value
Star → Issue Clear issue templates, welcoming tone
Issue → PR "good first issue" labels, CONTRIBUTING.md
PR → Regular Quick review, encouraging feedback
Regular → Maintainer Trust, shared ownership

Contributor Experience

CONTRIBUTING.md Essentials

#### Quick Start

1. Fork the repo
2. Clone your fork
3. Install dependencies: `npm install`
4. Create a branch: `git checkout -b my-feature`
5. Make your changes
6. Run tests: `npm test`
7. Commit: `git commit -m "Add my feature"`
8. Push: `git push origin my-feature`
9. Open a Pull Request

#### Development Setup

[Detailed setup instructions]

#### Code Style

- We use [Prettier/ESLint config]
- Run `npm run lint` before committing
- [Other conventions]

#### Commit Messages

We follow [Conventional Commits](https://conventionalcommits.org/):
- `feat: add new feature`
- `fix: resolve bug`
- `docs: update readme`
- `chore: update dependencies`

#### Pull Request Process

1. Update docs if needed
2. Add tests for new features
3. Ensure CI passes
4. Get one approval

#### Good First Issues

Look for issues labeled `good first issue` - these are great starting points!

#### Questions?

Open a Discussion or reach out on Discord.

"Good First Issue" Strategy

Create genuinely approachable issues:

Good Not Good
"Add TypeScript types for X function" "Refactor the entire codebase"
"Fix typo in README" "Performance optimization"
"Add test for Y method" "Debug intermittent CI failure"
"Update dependency Z" "Implement feature from RFC"

For each good first issue:

  • Explain context and why it matters
  • Link to relevant code files
  • Describe expected outcome
  • Offer to help in comments

Launch Strategies

Pre-Launch Checklist

Task Done?
README polished
Quick start works
Docs exist
3+ examples/demos
Tests passing
License chosen
CONTRIBUTING.md
Issue templates
Social preview image
5-10 GitHub topics

Launch Day Playbook

Timeline:

Time Action
Day before Final README review, prep all posts
Launch morning HN post (best: 6-8am PT, Tuesday-Thursday)
+1 hour Twitter thread
+2 hours Reddit post to relevant subreddits
Throughout day Respond to all comments/questions
End of day Thank everyone, share metrics

Platform-Specific Tactics

Hacker News:

  • Title: Descriptive, no hype ("Show HN: X - a Y for Z")
  • First comment: Explain motivation, tech decisions
  • Be available to respond for hours
  • Don't ask for upvotes (instant death)

Reddit:

  • Find 2-3 relevant subreddits (not just r/programming)
  • Read the rules first
  • Be a community member, not a marketer
  • Share genuinely useful context

Twitter/X:

  • Thread format: Problem → Solution → Demo → Link
  • Include GIF/video
  • Tag relevant accounts (framework authors, etc.)
  • Share builds-in-public journey

Dev.to / Hashnode:

  • Write a "Why I Built This" article
  • Technical depth, personal story
  • Cross-post from your blog

Post-Launch

Week Focus
Week 1 Respond to all feedback, fix bugs
Week 2 Blog post: "What I learned from launch"
Week 3 Start regular updates, ship new feature
Month 1 Community building, contributor docs
Ongoing Consistent presence, regular releases

Sustainable Growth

Growth Tactics

Tactic Effort Impact Timeline
SEO-optimized docs Medium High 3-6 months
Integration tutorials Medium High 1-2 months
Conference talks High Medium 3-6 months
Comparison content Low Medium 1-2 months
Guest blog posts Medium Medium 1-2 months
Newsletter features Low Low-Medium 2-4 weeks
Twitter presence Medium Medium Ongoing

Content Strategy for OSS

Content Type Purpose
"Why we built X" Launch story, motivation
"X vs Y vs Z" Capture comparison searches
"Migrating from Y to X" Convert competitor users
"X + [Popular Tool]" Capture integration searches
"How We Use X at [Company]" Social proof, real use case
"X Performance Benchmarks" Technical credibility

Avoiding Burnout

Risk Mitigation
Overwhelming issues Set response SLA expectations
Feature demands Public roadmap, RFC process
Solo maintenance Actively recruit co-maintainers
Always-on pressure Scheduled "office hours" vs. 24/7
Negative feedback Code of conduct, moderation

Metrics That Matter

Vanity vs. Value

Vanity Metric Value Metric
Stars Active issues + PRs
Forks Returned contributors
Downloads Weekly active users
Twitter followers Community engagement

What to Track

Metric Where to Find It
Stars over time GitHub Insights, Star History
Clones GitHub Traffic
Referrers GitHub Traffic
npm downloads npm-stat.com
Community size Discord/Slack member count
Contributor count GitHub Insights
Issue response time Manual tracking

Tools

Tool Use Case
Octolens Monitor mentions of your project across GitHub, HN, Reddit, Twitter, and Stack Overflow. Track competitor projects. Find contributors asking questions.
Star History Track star growth over time
npm-stat Download statistics
GitHub Traffic Views, clones, referrers
Shield.io Dynamic badges
All Contributors Recognize all contributors
Probot Automate GitHub workflows

Related Skills

  • developer-audience-context - Know who your users are
  • community-building - Build Discord/Slack community
  • devrel-content - Create supporting content
  • developer-advocacy - Conference talks, podcasts
  • hacker-news-strategy - Launch and engage on HN

Limitations

  • Use this skill only when the task clearly matches its upstream source and local project context.
  • Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.
  • Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.