⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

oss-contribute

chiruu12@chiruu12⭐ 61 stars· last commit 2mo ago· 0 open issues

|

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.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 61 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// 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

SkillRoleWhat it does
/oss-evaluate-repoAnalystAssesses project health, governance, bus factor, community before you invest time. Prevents wasting weeks on abandoned repos

Contribution pipeline

SkillRoleWhat it does
/oss-find-issueScoutFinds unclaimed issues from maintainers, checks if repo accepts outside contributions, matches to your skills
/oss-prep-to-contributeTutorReads all docs, maps the codebase, checks your knowledge gaps, won't let you code until you can explain the architecture
/oss-setup-dev-envMechanicGets 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-contributePair programmerTraces 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-prReviewerPre-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-prTranslatorDecodes terse reviewer comments. Finds codebase examples of what they want. You explain the feedback before fixing
/oss-find-real-issuesAuditorFinds 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

SkillRoleWhat it does
/oss-write-testsTest authorWrite 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-docsDocumentarianContribute documentation improvements. Verifies every claim against source code, tests every example, matches the repo's docs voice

CI and review

SkillRoleWhat it does
/oss-debug-ciDebuggerCI 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-prsReviewerReview other contributors' PRs to learn the codebase and build maintainer trust. Teaches structured diff reading and comment etiquette

Growth

SkillRoleWhat it does
/oss-second-contributionCoachYour first PR merged. Now what? Plans the transition from one-off contributor to regular. Progressive complexity escalation, relationship building, community presence

Research and learning

SkillRoleWhat it does
/oss-explore-repoGuideWalks you through the architecture, domain language, and patterns of a repo. You build a mental model before picking an issue
/oss-learn-stackTeacherWhen 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 rework
  • README.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

// REPO STATS

61 stars
0 open issues
Last commit: 2mo ago