⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
oss-contribute
|
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
OSS-Skills
15 skills that walk you through your first open source contribution, and your tenth. Install in 30 seconds on Claude Code, Codex, Cursor, Cline, Copilot, Windsurf, Zed, Gemini CLI or Kiro. Start with oss-find-issue. The skill handles the research, you handle the thinking.
Built by a GSoC mentor who got tired of watching contributors make the same avoidable mistakes - picking issues nobody maintains, skipping CONTRIBUTING.md, submitting PRs that ignore the repo's conventions, and not being able to explain their own code during review.
These skills encode what I wish every contributor knew before their first submission.
This is NOT a curated list or a collection of resources. These are executable skills you install and run. They search GitHub issues, read contribution docs, trace code paths, check if repos accept outside contributions, and ask you questions at every step. If you want a markdown list, this isn't it.
See it work
An abridged session. The issue numbers are invented, everything else is what the skills actually do.
You: /oss-find-issue
Skill: What languages do you know? Any specific repos, or want me to find one?
You: I know Python. No specific repo - find me a good first issue anywhere.
Skill: [searches repos, checks eligibility, filters by maintainer-filed issues]
Found 3 unclaimed issues matching your skills...
1. fastapi/fastapi #5621 - Fix type hint in dependency injection
2. pallets/click #2734 - CLI argument parsing edge case
3. encode/httpx #3102 - Connection timeout not respected
You: That second one looks interesting - the CLI argument parsing bug.
Skill: Why that one? What do you think the fix involves?
(Hint: look at the scope above - what about it matches your skills?)
You: I've worked with Click before. The description mentions argument groups
which I dealt with in my last project...
Skill: Good. Re-checking nobody took it while we talked... still clear.
Some repos want a maintainer to assign instead. This one lets you
self-claim, so post a one-liner and keep it short:
"I'd like to work on this - looks like it's in the argument group
handling. Happy to take it if nobody else has started."
You: Posted.
Skill: Run /oss-prep-to-contribute next.
You: /oss-prep-to-contribute
Skill: [reads CONTRIBUTING.md, CODE_OF_CONDUCT, maps architecture]
This repo uses pytest, conventional commits, and requires DCO sign-off.
Quick check: do you know what DCO sign-off means?
You: Not really...
Skill: It's a one-line attestation that you have the right to submit this code.
Add it with: git commit -s. Here's the full guide: ...
Now explain the repo's architecture in your own words.
Install - 30 seconds
Requirements: Git, gh CLI (authenticated), and an AI coding tool.
git clone https://github.com/chiruu12/OSS-Skills.git
cd OSS-Skills
./setup
That installs for Claude Code. For anything else, name it:
./setup --target cursor # or cline, copilot, windsurf, zed, gemini, kiro
./setup --target agents # AGENTS.md, read by Codex, Aider, Goose, Amp and ~25 more
./setup --list # every target
Non-Claude targets install into the current directory, so run them from your
project, or pass --dest /path/to/project. For a project-local Claude install,
use ./setup --local.
Or paste this into Claude Code and it handles everything:
Install OSS-Skills: run
git clone https://github.com/chiruu12/OSS-Skills.git && cd OSS-Skills && ./setup
The skills
Slash syntax is Claude Code. On every other tool there is no slash command: ask your agent for the workflow by name, such as "follow the oss-find-issue workflow".
Evaluation
| Skill | Role | What it does |
|---|---|---|
/oss-evaluate-repo | Analyst | Assesses project health, governance, bus factor, community before you invest time. Prevents wasting weeks on abandoned repos |
Contribution pipeline
| Skill | Role | What it does |
|---|---|---|
/oss-find-issue | Scout | Finds unclaimed issues from maintainers, checks if repo accepts outside contributions, matches to your skills |
/oss-prep-to-contribute | Tutor | Reads all docs, maps the codebase, checks your knowledge gaps, won't let you code until you can explain the architecture |
/oss-setup-dev-env | Mechanic | Gets the repo building, testing, and linting on your machine. Reads CI config as source of truth when README is stale. IDE hints for VS Code, JetBrains, Cursor, Windsurf, Neovim |
/oss-contribute | Pair programmer | Traces code paths, finds patterns. You describe the logic, it helps you implement. Won't write code until you explain what it should do |
/oss-submit-pr | Reviewer | Pre-flight checks (tests, lint, rebase). Reviews your diff. You write the PR description, it tells you what to cut. Finds and enforces PR templates |
/oss-post-pr | Translator | Decodes terse reviewer comments. Finds codebase examples of what they want. You explain the feedback before fixing |
/oss-find-real-issues | Auditor | Finds real code problems not in the tracker (missing tests, error handling gaps). Fetches issue templates before filing. You evaluate what's worth filing |
Contribution types
| Skill | Role | What it does |
|---|---|---|
/oss-write-tests | Test author | Write tests for untested code as a standalone contribution. Highest-value, lowest-risk first contribution. Studies repo test conventions and makes you match them exactly |
/oss-write-docs | Documentarian | Contribute documentation improvements. Verifies every claim against source code, tests every example, matches the repo's docs voice |
CI and review
| Skill | Role | What it does |
|---|---|---|
/oss-debug-ci | Debugger | CI failed and the error makes no sense. Reads CI config, fetches logs, classifies failure type, determines if it's your fault or pre-existing |
/oss-review-prs | Reviewer | Review other contributors' PRs to learn the codebase and build maintainer trust. Teaches structured diff reading and comment etiquette |
Growth
| Skill | Role | What it does |
|---|---|---|
/oss-second-contribution | Coach | Your first PR merged. Now what? Plans the transition from one-off contributor to regular. Progressive complexity escalation, relationship building, community presence |
Research and learning
| Skill | Role | What it does |
|---|---|---|
/oss-explore-repo | Guide | Walks you through the architecture, domain language, and patterns of a repo. You build a mental model before picking an issue |
/oss-learn-stack | Teacher | When the repo uses tech you don't know, teaches it from the repo's own code. Every example is from the actual codebase, not generic docs |
Evaluation:
oss-evaluate-repo -> oss-explore-repo -> oss-find-issue
Learning track:
oss-explore-repo -> oss-learn-stack -> oss-find-issue (or oss-find-real-issues)
Contribution track:
oss-find-issue -> oss-prep-to-contribute -> oss-setup-dev-env -> oss-contribute -> oss-submit-pr -> oss-post-pr
| |
(alternatives) oss-write-tests / oss-write-docs |
(CI fails) oss-debug-ci
|
oss-second-contribution
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
skills/oss-contribute/SKILL.md7.8 KBupstream ↗
--- name: oss-contribute description: | Research an issue deeply and present all context to the user. but the user writes the code. The LLM investigates code paths, finds relevant files, explains patterns, and identifies constraints. The user thinks through the approach and implements it. Use when ready to start working on an issue after oss-prep-to-contribute. Not for writing tests or documentation as a standalone contribution. Use oss-write-tests or oss-write-docs for those. --- # Contribute The LLM is your research assistant, not your ghostwriter. This skill digs deep into the issue. traces code, reads history, finds patterns, identifies constraints. then hands everything to you. You think. You decide. You code. ## Purpose The fastest way to NOT learn from open source is to let an AI write the fix. This skill exists to make you a better developer: it gives you the context a senior contributor would have, then makes you do the work a senior contributor would do. The thinking is yours. The code is yours. The learning is yours. ## Prerequisites - Repo forked, cloned, and set up (from `oss-prep-to-contribute`) - Working branch created - Existing tests pass - User has explained their understanding of the codebase and the issue ## Process ### 1. Deep investigation Use Agent with subagent_type=Explore to thoroughly investigate the issue. This is where the LLM does heavy lifting. reading code so the user doesn't have to grep blindly. **Investigate**: - The exact code path the issue describes (trace entry → processing → output) - All files that touch this code path (imports, callers, callees) - Existing tests for this area (what's covered, what's missing) - Git history for the relevant files (why was it written this way? any related past fixes?) - Similar patterns elsewhere in the codebase (how do they handle the same problem?) - Error handling in the code path - Edge cases mentioned in comments or tests ```bash # Trace the code path grep -rn "function_name\|class_name\|relevant_symbol" src/ --include="*.ts" --include="*.py" --include="*.go" --include="*.rs" # Git history for context git log --oneline -15 -- "path/to/relevant/files" git log --all --oneline --grep="keyword_from_issue" # Find who last touched this code and why git blame "path/to/file" -L {start},{end} # Find related tests grep -rn "describe.*relevant\|test.*relevant\|def test_relevant" tests/ test/ __tests__/ spec/ ``` ### 2. Present the research Deliver findings in a structured format. Every claim must have a file:line reference. ``` ## Issue Research: #{number} ### The Problem {What's wrong or missing. in plain language, with code references} ### Relevant Code | File | Lines | What it does | Why it matters | |------|-------|-------------|----------------| | `src/foo.ts` | 42-67 | Handles X | This is where the bug manifests | | `src/bar.ts` | 15-30 | Calls foo | Passes incorrect argument | | `tests/foo.test.ts` | 80-95 | Tests happy path | Missing test for edge case Y | ### How the Code Works {Trace the flow step by step. entry point → processing → output} {Explain WHY it's structured this way. design decisions, patterns used} ### Constraints - {constraint 1, e.g. "this function is called from 3 places, changes must be backwards compatible"} - {constraint 2, e.g. "the test suite mocks this dependency, so your tests should too"} ### Approach Options 1. **{Option A}**: {description}. Trade-off: {pro/con} 2. **{Option B}**: {description}. Trade-off: {pro/con} {Present options, don't pick for the user} ### What Tests Should Cover - {behavior 1 that needs testing} - {behavior 2 that needs testing} - {edge case that's currently untested} ``` ### 3. Thinking gate: user explains the root cause After presenting the research, stop and ask: > "Based on what I've found. look at the code paths and constraints I presented above. Specifically: > 1. What's the root cause? (Hint: look at the relevant code section in the research above. what goes wrong there?) > 2. Which approach do you want to take, and why? (I listed the trade-offs. which ones matter most for this repo?)" **Wait for their answer.** Do NOT proceed until they've articulated their understanding. If their explanation has gaps: - Point out WHAT's wrong: "You mentioned X, but look at `src/foo.ts:45`: it actually does Y" - Don't give the correct answer. give them the reference and let them correct themselves - Ask again once they've revised ### 4. Thinking gate: user describes their plan Once the root cause is understood, ask: > "Walk me through your implementation plan: > 1. What files will you change? > 2. What's the logic change in each file? > 3. What tests will you add or modify? > 4. Are there any edge cases you're handling?" Review their plan: - If something is missing, say WHAT's missing: "You haven't mentioned how this affects `src/bar.ts`: it also calls the function you're changing" - If the approach won't work, explain WHY: "That approach would break the callers at `src/baz.ts:20`: look at how they use the return value" - Don't rewrite their plan. poke holes and let them patch ### 5. User drives the implementation The user implements their plan. The LLM acts as a pair programmer: the user describes the logic, the LLM helps write it. Think senior dev + junior dev. the junior explains what they want to do, the senior helps them get it right. **How it works**: - User describes what a function should do: "I need to add a check here that validates the input is a valid URL before passing it to the handler" - LLM implements what the user specified. filling in syntax, matching repo patterns, handling the mechanical parts - User reviews the result and iterates: "That's close, but it should also handle the case where..." **What the LLM DOES**: - Implement code that the user has described in plain language (the user drives the logic) - Answer specific questions about the codebase ("what does this function expect as input?") - Point to examples of patterns in the repo ("how do other modules handle this?") - Review the user's code when asked. identify issues and suggest fixes - Run tests when asked and explain failures **What the LLM DOES NOT DO**: - Write code unprompted. the user must describe what the code should do first - Make architectural decisions. the user chose the approach in step 4 - Skip ahead. if the user says "just fix it" without describing the logic, redirect: > "Tell me what this code should do. walk me through the logic step by step. Once you've described it, I'll help you write it. What should happen first?" The key: the user must always describe WHAT the code should do before the LLM writes HOW. ### 6. Thinking gate: user explains their changes After implementation, before committing: > "Before we move to submitting. explain what you changed and why. This is what a reviewer will ask you: > 1. What did you modify in each file? (Walk through the diff in your head) > 2. Why this approach over the alternatives we discussed? > 3. How do your tests verify the fix? (What behavior do they check?) > 4. Any edge cases you're unsure about? (Look at the constraints I found earlier)" This catches misunderstandings before they become PR review comments. If the user can articulate all four clearly, they're ready. If not, point them back to the relevant code. ### 7. Verify before handoff ```bash # Run the full test suite # {repo-specific test command} # Run linting # {repo-specific lint command} # Check the diff is clean git diff --stat ``` If tests or lint fail, explain WHAT failed and WHERE. Don't fix it. Point the user to the failing assertion and the relevant code. ## Related Skills - **Previous step**: ← `oss-prep-to-contribute`: set up the environment and build understanding - **Next step**: → `oss-submit-pr`: submit the PR following repo guidelines - **If knowledge gaps surface**: → `oss-learn-stack`: learn unfamiliar tech from the repo's own code - **If significant reworkREADME.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/chiruu12-oss-skills-skills-oss-contribute.md