Use this skill when maintaining open source projects, managing OSS governance, writing changelogs, building community, choosing licenses, handling contributions, or managing releases. Triggers on tasks related to CONTRIBUTING.md, CODE_OF_CONDUCT, release notes, semantic versioning, maintainer workflows, issue triage, PR review policies, licensing decisions, community health, and open source project governance.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Use this skill when maintaining open source projects, managing OSS governance, writing changelogs, building community, choosing licenses, handling contributions, or managing releases. Triggers on tasks related to CONTRIBUTING.md, CODE_OF_CONDUCT, release notes, semantic versioning, maintainer workflows, issue triage, PR review policies, licensing decisions, community health, and open source project governance.
When this skill is activated, always start your first response with the 🧢 emoji.
Open Source Management
Open source management is the discipline of running a healthy, sustainable open source
project. It covers everything beyond writing code - governance structures, contribution
workflows, licensing decisions, community building, release management, and long-term
project health. This skill gives an agent the knowledge to help maintainers set up and
run OSS projects that attract contributors, minimize maintainer burnout, and follow
widely accepted industry standards.
When to use this skill
Trigger this skill when the user:
Wants to set up a new open source project with proper governance files
Needs help writing or improving CONTRIBUTING.md, CODE_OF_CONDUCT.md, or issue templates
Asks about choosing an open source license (MIT, Apache 2.0, GPL, etc.)
Wants to write or automate changelogs and release notes
Needs help with semantic versioning decisions
Asks about managing contributors, reviewing PRs, or triaging issues
Wants to build or grow an open source community
Needs a governance model (BDFL, meritocratic, foundation-backed)
Do NOT trigger this skill for:
Writing application code or fixing bugs (use language-specific or clean-code skills)
Internal/proprietary project management (use operations or product skills instead)
Key principles
Lower the barrier to contribute - Every friction point in the contribution process
costs you potential contributors. Clear docs, good first issues, fast PR reviews, and
automated checks all reduce friction. The easier it is to contribute, the more people will.
Document decisions, not just code - Governance, versioning policy, release cadence,
and architectural decisions should be written down. Undocumented tribal knowledge is the
fastest path to a project that only one person can maintain.
Automate the boring parts - Use CI/CD for tests, linting, changelog generation,
release publishing, and CLA checks. Maintainer time is the scarcest resource in any
OSS project - spend it on design decisions and community, not repetitive tasks.
Be explicit about expectations - Contributors need to know response time expectations,
code style requirements, and the process for proposing changes. Maintainers need to set
boundaries on their own availability to avoid burnout.
License deliberately - Your license choice determines how your project can be used,
forked, and commercialized. Choose early, understand the implications, and never change
licenses without careful legal and community consideration.
Core concepts
Project health files form the foundation of any OSS project. At minimum, a project
needs: README.md (what and why), LICENSE (legal terms), CONTRIBUTING.md (how to help),
and CODE_OF_CONDUCT.md (behavioral expectations). GitHub recognizes these files and
surfaces them in the community profile.
Governance defines who makes decisions and how. The three dominant models are: BDFL
(Benevolent Dictator for Life - one person has final say, e.g. early Python), meritocratic
(commit rights earned through sustained contribution, e.g. Apache projects), and
foundation-backed (a legal entity stewards the project, e.g. Linux Foundation, CNCF).
Most small projects start as BDFL and evolve as they grow.
Semantic versioning (SemVer) communicates change impact through version numbers:
MAJOR.MINOR.PATCH. MAJOR means breaking changes, MINOR means new features (backward
compatible), PATCH means bug fixes. Pre-release versions use suffixes like -alpha.1
or -rc.1. See references/semver-releases.md.
Contributor lifecycle runs from first contact to core maintainer: user -> reporter
-> contributor -> committer -> maintainer. Each stage needs clear documentation on
expectations and privileges. See references/community-building.md.
Common tasks
Set up a new open source project
Create these files in the repository root:
LICENSE - Choose a license (see "Choose a license" task below)
SECURITY.md - How to report vulnerabilities (never via public issues)
.github/ISSUE_TEMPLATE/ - Bug report and feature request templates
.github/PULL_REQUEST_TEMPLATE.md - PR checklist with description, testing, and breaking change sections
Always include a DCO (Developer Certificate of Origin) or CLA (Contributor License
Agreement) requirement for projects that may have IP concerns.
Choose a license
Use this decision framework:
Goal
License
Key trait
Maximum adoption, no restrictions
MIT
Permissive, short, simple
Permissive with patent protection
Apache 2.0
Explicit patent grant
Copyleft - derivatives must stay open
GPL v3
Strong copyleft
Copyleft for libraries, permissive linking
LGPL v3
Weak copyleft
Network use triggers copyleft
AGPL v3
Closes the SaaS loophole
Public domain equivalent
Unlicense / CC0
No restrictions at all
See references/licensing-guide.md for detailed comparison and edge cases.
Write a changelog
Follow the Keep a Changelog format (keepachangelog.com):
# Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [Unreleased]### Added- New feature X for doing Y
### Changed- Updated dependency Z to v2.0
### Fixed- Bug where A caused B (#123)
## [1.2.0] - 2025-03-01### Added- Initial support for feature W
Group changes under: Added, Changed, Deprecated, Removed, Fixed, Security.
Never mix user-facing changes with internal refactors in the same entry.
Triage issues effectively
Apply labels and prioritize using this workflow:
Acknowledge within 48 hours - even a "thanks, we'll look at this" reduces contributor frustration
Label by type (bug, feature, question, documentation) and priority (critical, high, medium, low)
Tag good first issues - look for self-contained tasks with clear scope and mark them good first issue
Close stale issues politely after 90 days of inactivity with a bot (use actions/stale)
Link duplicates rather than just closing them - the reporter's wording may help future searchers
Manage releases
Follow this release checklist:
Decide the version bump using SemVer rules (see references/semver-releases.md)
Update CHANGELOG.md - move Unreleased items under the new version heading
Update version in package.json / pyproject.toml / Cargo.toml / etc.
Create a git tag: git tag -a v1.2.0 -m "Release v1.2.0"
Push tag: git push origin v1.2.0
CI publishes to package registry (npm, PyPI, crates.io, etc.)
Create GitHub Release from the tag with changelog content as body
Announce on community channels (Discord, Twitter, blog)
Automate steps 2-7 with tools like release-please, semantic-release, or
changesets to eliminate human error.
Write a CONTRIBUTING.md
A good CONTRIBUTING.md covers these sections in order:
# Contributing to [Project Name]
Thank you for your interest in contributing!
## Code of Conduct
This project follows the [Contributor Covenant](CODE_OF_CONDUCT.md).
## How to Contribute### Reporting Bugs- Search existing issues first
- Use the bug report template
- Include reproduction steps, expected vs actual behavior, environment details
### Suggesting Features- Open a discussion or feature request issue
- Explain the problem you're solving, not just the solution you want
### Submitting Code1. Fork the repository
2. Create a feature branch from `main`3. Make your changes following our coding standards
4. Write or update tests
5. Run the test suite locally
6. Submit a pull request
## Development Setup
[Steps to clone, install dependencies, run tests]
## Pull Request Process- PRs require at least one maintainer review
- All CI checks must pass
- Squash commits before merging
- Update CHANGELOG.md for user-facing changes
Set up governance for a growing project
When a project outgrows a single maintainer:
Write a GOVERNANCE.md defining decision-making process
Establish a core team with documented roles and responsibilities
Define RFC (Request for Comments) process for significant changes
Set up regular maintainer meetings (bi-weekly or monthly)
Create a MAINTAINERS.md listing active maintainers and their areas of ownership
See references/governance-models.md for templates.
Anti-patterns / common mistakes
Mistake
Why it's wrong
What to do instead
No CONTRIBUTING.md
Contributors don't know the process, leading to low-quality PRs and frustrated maintainers
Write clear contribution guidelines before asking for help
Ignoring PRs for weeks
Contributors leave and never come back; reputation spreads
Set response time expectations, use bots for initial triage
Relicensing without consent
Legal risk; contributors agreed to original license terms
Get explicit consent from all contributors or use a CLA from the start
No changelog
Users can't assess upgrade risk, leading to version pinning and stale dependencies
Maintain a changelog from day one, automate if possible
Granting commit access too freely
Quality drops, security risk increases
Define a clear path to commit rights based on sustained quality contributions
No security disclosure process
Vulnerabilities get reported as public issues
Add SECURITY.md with private reporting instructions (email or GitHub security advisories)
Burnout-driven maintenance
Saying yes to everything, reviewing at all hours, no boundaries
Set explicit availability, share maintainer load, and learn to say no
Gotchas
SemVer MAJOR bump requirement is frequently underestimated - Any breaking change to a public API - including removing a previously exported function, changing a function signature, or changing behavior in a way that breaks existing consumers - requires a MAJOR version bump. Teams routinely ship breaking changes as MINOR bumps ("it's just a small change"), which breaks downstream consumers and erodes trust. When in doubt, bump MAJOR.
Relicensing without CLA consent from all contributors is legally risky - If contributors submitted code under MIT and you want to relicense to Apache 2.0 or AGPL, you need written consent from every contributor who owns copyrightable contributions. Even one holdout blocks the relicense. Use a CLA (Contributor License Agreement) from day one if you anticipate ever changing the license.
actions/stale closes issues contributors are actively working on - A default stale bot configuration that closes issues after 60 days of inactivity will close issues where a contributor is mid-implementation but just hasn't commented. This is a common contributor experience failure. Configure stale bots to apply a label and warn, not close automatically - require human review before closing.
GitHub security advisories are not automatically sent to dependents - Creating a SECURITY.md only helps if reporters use it. For vulnerabilities in published packages, you must create a GitHub Security Advisory and request a CVE to trigger automated alerts in dependent projects. Simply patching and releasing a new version without an advisory leaves most users unaware.
Automated changelog generation requires conventional commits from day one - Tools like release-please or semantic-release depend on conventional commit message prefixes (feat:, fix:, BREAKING CHANGE:). Introducing these tools to a project with non-conventional commit history produces either empty or incorrect changelogs. Establish the commit message convention before the first release, not retroactively.
References
For detailed content on specific topics, read the relevant file from references/:
references/licensing-guide.md - Deep comparison of OSS licenses, compatibility matrix, and dual-licensing strategies
references/community-building.md - Growing contributors, communication channels, events, and sponsorship
references/governance-models.md - BDFL, meritocratic, and foundation governance templates with examples
Only load a references file if the current task requires deep detail on that topic.
Companion check
On first activation of this skill in a conversation: check which companion skills are installed by running ls ~/.claude/skills/ ~/.agent/skills/ ~/.agents/skills/ .claude/skills/ .agent/skills/ .agents/skills/ 2>/dev/null. Compare the results against the recommended_skills field in this file's frontmatter. For any that are missing, mention them once and offer to install:
