repo-to-skill
Skill39 starsChanged 9 months agoMITView on GitHub
Convert a GitHub repository or local codebase into a well-structured Claude Code skill with progressive disclosure. Use this skill whenever the user provides a GitHub URL or local repo path and asks to turn it into a skill, create a skill from a repo, or convert a library/tool/framework into reusable skill documentation. Also trigger when users say things like 'make a skill from this repo', 'turn this codebase into a skill', or 'I want a skill for [library name]'.
3 other projects use a version of this.
Adopted by
Most recently taken up by
- imMamdouhaboammar/repo-to-skilltheir own version, first seen Sep 26, 2026
- louiswang524/repo-to-skilltheir own version, first seen Mar 23, 2026
- shuyhere/repo-to-skilltheir own version, first seen Mar 13, 2026
Other versions3 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 3
- shuyhere/repo-to-skill★ 9same name
- louiswang524/repo-to-skill★ 4same name
- imMamdouhaboammar/repo-to-skill★ 0same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository49 other files it gives its agents.
- act-r-model-builderSkill
- alternative-uses-task-designerSkill
- bayesian-cognitive-model-builderSkill
- brain-connectivity-modelerSkill
- calcium-imaging-analysis-guideSkill
- cognitive-paradigm-designSkill
- cogsci-power-analysisSkill
- cogsci-statisticsSkill
- cogsci-visualizationSkill
- contribute-skillSkill
- contribute-skills-via-prSkill
- creativity-self-efficacy-mediationSkill
- deeplabcutSkill
- divergent-thinking-scoringSkill
- drift-diffusion-modelSkill
- eeg-paradigm-designerSkill
- eeg-preprocessing-pipeline-guideSkill
- erp-analysisSkill
- evidence-accumulation-selectorSkill
- fmri-glm-analysis-guideSkill
- fmri-preprocessing-pipeline-guideSkill
- fmriprepSkill
- fmri-task-design-guideSkill
- infant-looking-time-designerSkill
- lesion-symptom-mapping-guideSkill
- markdown-report-writingSkill
- mne-python-guideSkill
- netneurotools-guideSkill
- neural-decoding-analysisSkill
- neural-population-analysis-guideSkill
- neuroimaging-power-guideSkill
- neuroimaging-sample-size-calculatorSkill
- neuropsych-battery-selectorSkill
- optogenetics-protocol-designerSkill
- paper-to-skillSkill
- parameter-recovery-checkerSkill
- pycortex-guideSkill
- reading-time-analysisSkill
- research-literacySkill
- self-paced-reading-designerSkill
- sentence-stimulus-normingSkill
- share-caseSkill
- share-usageSkill
- signal-detection-analysisSkill
- spikeinterface-skillSkill
- spiking-network-model-builderSkill
- tom-task-selectorSkill
- verify-skillSkill
- visual-search-array-generatorSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
14 rules. 0 are common, 9 are distinctive, and 5 are very specific to this project.
0
Common
Most of the 3 edited versions we read keep these.
9
Distinctive
This author's own choices. Worth a look.
5
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 41
If the user provides just a repo name (e.g., "mne-tools/mne-python"), construct the URL:
- Very specific: line 47
If the user provides a local path (e.g., /srv/repos/my-library), use it directly.
- Distinctive: line 50
Check if the repo is already cloned locally before downloading again.
- Distinctive: line 60
Read these files first (if they exist):
- Very specific: line 73
Read __init__.py (or equivalent entry point) to find all exported modules/classes/functions
- Distinctive: line 76
Read key implementation files for important classes/functions — focus on docstrings and signatures, not internal logic
- Distinctive: line 80
Look for documentation in these common locations:
- Very specific: line 100
Use the Agent tool with subagent_type=Explore for broad exploration, or launch multiple parallel subagents to cover different areas …
- Distinctive: line 141
Keep each file under 300 lines for readability.
- Very specific: line 146
When the repo already has well-written documentation, examples, or reference material, copy them directly into references/ rather than …
- Very specific: line 211
Keep SKILL.md under 500 lines — move details to references
- Distinctive: line 212
Use tables for API listings and parameter comparisons
- Distinctive: line 246
Prefer copying existing high-quality content from the repo:
- Distinctive: line 252
Only rewrite when the original content is poorly organized, outdated, or too verbose.
“Common” is measured: kept by at least 6 in 10 of the 3 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Repo-to-Skill: Convert a Repository into a Claude Code Skill
Purpose
This skill encodes the complete workflow for transforming a GitHub repository (or local codebase) into a well-structured Claude Code skill. It guides you through cloning, exploring, extracting key information, and assembling a skill with proper progressive disclosure — a concise SKILL.md entry point backed by detailed reference files.
When to Use
Activate when the user:
- Provides a GitHub URL and asks to create a skill from it
- Points to a local repository path and wants it converted to a skill
- Says "make a skill from this repo/library/tool"
- Wants to document a codebase as a reusable skill
Workflow Overview
1. Acquire repo → 2. Explore broadly → 3. Collect key info → 4. Design structure → 5. Write SKILL.md + referencesPhase 1: Acquire the Repository
From GitHub URL
# Clone to a working directory
git clone <github-url> /tmp/skill-source-repo
# or clone to a user-specified pathIf the user provides just a repo name (e.g., "mne-tools/mne-python"), construct the URL:
git clone https://github.com/<owner>/<repo>.git /tmp/skill-source-repoFrom Local Path
If the user provides a local path (e.g., /srv/repos/my-library), use it directly. Verify it exists before proceeding.
Already Available
Check if the repo is already cloned locally before downloading again.
Phase 2: Explore the Repository
This is the most important phase. Explore broadly and deeply — the quality of the skill depends on how well you understand the repo. Use parallel subagents when possible to speed up exploration.
2.1 Top-Level Orientation
Read these files first (if they exist):
README.md/README.rst— project overview, installation, quick startCHANGELOG.md/CHANGES.rst/HISTORY.md— recent API changespyproject.toml/setup.py/setup.cfg/package.json— dependencies, versionCONTRIBUTING.md— project conventionsLICENSE— license type
Then list the top-level directory structure to understand the project layout.
2.2 Core Source Code
Identify the main source directory (often src/, lib/, or the package name itself). Then:
- Read
__init__.py(or equivalent entry point) to find all exported modules/classes/functions - List all submodules/subdirectories
- For each major submodule, read its
__init__.pyto get the public API - Read key implementation files for important classes/functions — focus on docstrings and signatures, not internal logic
2.3 Documentation
Look for documentation in these common locations:
docs/ordoc/directoryexamples/directory — working code examples are goldtutorials/directory — step-by-step guides- API reference docs (often generated, but source
.rstor.mdfiles are useful) - Jupyter notebooks (
.ipynb) in any directory
2.4 Examples and Tutorials
These are the most valuable resources for a skill. For each example/tutorial:
- Note what it demonstrates
- Extract the key code patterns
- Identify the recommended parameter values and best practices
2.5 Tests (Optional)
Skim test files to discover edge cases, expected behaviors, and usage patterns that aren't in the docs.
Exploration Strategy
Use the Agent tool with subagent_type=Explore for broad exploration, or launch multiple parallel subagents to cover different areas simultaneously:
Agent 1: Explore top-level structure + README + core __init__.py files
Agent 2: Explore tutorials/ and examples/ directories, read representative files
Agent 3: Explore docs/ for API reference, read key module documentationThe goal is to collect:
- Complete list of public API (classes, functions, constants)
- Recommended usage patterns and pipelines
- Parameter defaults and recommended values
- Common pitfalls and gotchas
- Code examples for each major feature
Phase 3: Design the Skill Structure
Determine Scope
Based on exploration, decide:
- What is the skill's primary purpose? (e.g., "guide users through X analysis pipeline")
- What are the major topic areas? (these become reference files)
- What belongs in the main SKILL.md vs. references?
Progressive Disclosure Architecture
skill-name/
├── SKILL.md (< 500 lines — overview, pipeline, quick reference)
└── references/
├── topic-a.md (detailed API + examples for topic A)
├── topic-b.md (detailed API + examples for topic B)
├── topic-c.md (detailed API + examples for topic C)
└── ...Rules of thumb:
- SKILL.md: Pipeline overview, core concepts, quick-start code, common pitfalls, reference table pointing to detail files
- Each reference file: One major topic, complete API listing, detailed code examples, parameter tables
- Keep each file under 300 lines for readability; split if larger
- Include a "Reference Files" table in SKILL.md so the model knows when to read each file
Reuse Repo Resources Directly
When the repo already has well-written documentation, examples, or reference material, copy them directly into references/ rather than rewriting. This saves effort and preserves accuracy:
# Copy useful docs directly
cp /tmp/skill-source-repo/docs/api_reference.md references/
cp /tmp/skill-source-repo/examples/quickstart.py references/
cp /tmp/skill-source-repo/tutorials/getting_started.md references/Rename files to be descriptive if needed. Add a brief header noting the source.
Phase 4: Write the SKILL.md
Naming Rule
Skill name may only contain lowercase letters, numbers, and hyphens. The name must match the folder name. For example, a skill in folder my-cool-tool/ must have name: "my-cool-tool" in its frontmatter.
Required Structure
---
name: "my-skill-name"
description: "One-line description of what this skill provides"
version: "1.0.0"
authors:
- "Claude (AI-assisted)"
review_status: "ai-generated"
---
# Skill Title
## Purpose
What domain knowledge this skill encodes and why it's useful.
## When to Use This Skill
Trigger conditions — what user phrases/contexts activate this skill.
## Reference Files (Progressive Disclosure)
| Topic | File | When to Read |
|-------|------|--------------|
| Topic A | `references/topic-a.md` | User asks about A |
| Topic B | `references/topic-b.md` | User asks about B |
## Overview / Pipeline
High-level workflow or concept map.
## Quick Start
Minimal working example covering the most common use case.
## Key Concepts
Core data structures, important classes, essential functions.
## Common Pitfalls
Numbered list of mistakes to avoid, with brief explanations.
## [Additional sections as needed]Writing Guidelines
- Lead with the pipeline/workflow — users want to know "what do I do first?"
- Include runnable code examples — not pseudocode
- Cite parameter values with sources when possible
- Keep SKILL.md under 500 lines — move details to references
- Use tables for API listings and parameter comparisons
- The reference table is critical — it tells the model when to load each file
Phase 5: Write Reference Files
For each major topic area, create a reference file:
# Topic Name Reference
## Table of Contents
1. [Section 1](#section-1)
2. [Section 2](#section-2)
...
## Section 1
[Detailed API, parameters, code examples]
## Section 2
[More details]What to Include in References
- Complete function/class signatures with all parameters
- Parameter tables with types, defaults, and descriptions
- Multiple code examples showing different use cases
- Tips for parameter selection
- Links between related functions
Reusing Repo Content
Prefer copying existing high-quality content from the repo:
- Tutorial code → reference examples
- API docstrings → function reference tables
- README sections → overview content
- Example scripts → working code snippets
Only rewrite when the original content is poorly organized, outdated, or too verbose.
Quality Checklist
Before finishing, verify:
- Skill name contains only lowercase letters, numbers, and hyphens, and matches the folder name
- SKILL.md is under 500 lines
- All major features/modules are covered
- Reference table in SKILL.md lists all reference files with "when to read" guidance
- Each reference file has a table of contents
- Code examples are complete and runnable
- Common pitfalls section exists
- Quick start example covers the most common use case
- No reference file exceeds ~300 lines (split if needed)
- Skill directory uses kebab-case naming
Example: Converting a Python Library
For a Python library like pandas:
pandas-guide/
├── SKILL.md # Overview, core objects (DataFrame, Series), quick start
└── references/
├── io.md # read_csv, read_excel, to_parquet, etc.
├── selection-indexing.md # loc, iloc, boolean indexing, query
├── groupby-aggregation.md # groupby, agg, transform, pivot_table
├── merging-joining.md # merge, join, concat
├── time-series.md # DatetimeIndex, resample, rolling
└── visualization.md # plot(), plot.bar(), etc.The SKILL.md would contain the DataFrame/Series overview, a quick-start example, and a reference table pointing to each topic file.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

