create_skill_with_paper
Turn an academic paper + its code repo into a reusable skill so you can quickly adopt and integrate the method in any project, staying faithful to the original implementation.
When to Use
- User provides a paper (PDF path, arXiv link, or title)
- User wants to reuse a paper's method in a new project
- User wants a quick-reference card for a paper's setup, dependencies, and core API
Workflow
Step 1: Gather Inputs
Ask the user for:
| Input |
Required |
Example |
| Paper |
Yes |
arXiv link, PDF path, or title |
| Code repo |
Yes (search if not provided) |
GitHub URL |
| Skill name |
Optional |
Default: snake_case of short paper name |
A code repo is required. If the user doesn't provide one, you must search for it (check the paper, Papers With Code, GitHub). If no official repo exists, tell the user and ask how to proceed.
Step 2: Read the Paper
- If PDF path: read with the Read tool
- If arXiv link: fetch the abstract page, then download/read the PDF
- If title only: web-search for the paper, find arXiv or official link
Extract these key elements:
- Paper identity — title, authors, year, venue, links
- Problem & contribution — what problem does it solve, what's novel
- Method overview — high-level algorithm / architecture (not full math)
- Key components — named modules, losses, architectures worth remembering
- Evaluation highlights — main benchmarks, key results, comparisons
Step 3: Clone & Deep-Read the Code
You MUST clone the repo and read the actual source code. Do not just skim the README.
# Clone into a temp location
git clone <repo_url> /tmp/paper_skill_<method_name>
3a: Understand project structure
Map out the repo — entry points, core modules, config system, data pipeline:
| What to Extract |
Where to Look |
| Dependencies & versions |
requirements.txt, setup.py, pyproject.toml, environment.yml |
| Entry points |
train.py, run.py, main.py, CLI args |
| Config system |
configs/, argparse, hydra, omegaconf |
| Core model code |
models/, networks/, modules/ |
| Data pipeline |
datasets/, data/, dataloader setup |
| Pre-trained weights |
README download links, model zoo |
3b: Read core implementation files
Read the actual source files for the method's core components. For each key module:
- Read the file completely (don't just skim)
- Record the exact class names, function signatures, and constructor arguments
- Trace the forward pass / main algorithm flow through the code
- Note which classes/functions a user would need to import and call
- Identify default hyperparameters and their values in code (not just CLI flags)
3c: Cross-reference paper ↔ code
Build an explicit mapping between paper concepts and code locations:
- Which class implements the model described in Section X?
- Which function implements the loss from Equation Y?
- Where are the key hyperparameters (from Table Z) set in code?
- How does the data preprocessing match what the paper describes?
This mapping becomes the Paper-Code Mapping section in the skill.
3d: Identify integration patterns
Figure out how someone would use this code in their own project (not just run the repo's scripts):
- What are the minimal imports needed?
- How do you instantiate the model, load weights, and run inference?
- What data format does the model expect (tensor shapes, dtypes, normalization)?
- Are there clean API boundaries, or is everything entangled with the training script?
- If the code is entangled, document the minimum extraction needed
3e: Clean up
rm -rf /tmp/paper_skill_<method_name>
Step 4: Name & Organize the Skill
Naming Convention
Use the pattern: paper_<domain>__<method_name> (double underscore separates domain from method).
The paper_ prefix distinguishes paper-derived skills from other skill types (tools, workflows, etc.).
| Domain Prefix |
Area |
Example Skill Names |
paper_3d__ |
3D vision, NeRF, reconstruction |
paper_3d__gaussian_splatting, paper_3d__instant_ngp |
paper_gen__ |
Generative models, diffusion |
paper_gen__stable_diffusion, paper_gen__flow_matching |
paper_det__ |
Object detection |
paper_det__yolov9, paper_det__detr |
paper_seg__ |
Segmentation |
paper_seg__sam, paper_seg__mask2former |
paper_llm__ |
Large language models |
paper_llm__llama3, paper_llm__moe_routing |
paper_vlm__ |
Vision-language models |
paper_vlm__llava, paper_vlm__clip |
paper_rl__ |
Reinforcement learning |
paper_rl__ppo, paper_rl__grpo |
paper_opt__ |
Optimization, training methods |
paper_opt__lora, paper_opt__deepspeed |
paper_data__ |
Data processing, augmentation |
paper_data__webdataset, paper_data__albumentations |
paper_rob__ |
Robotics, embodied AI |
paper_rob__diffusion_policy, paper_rob__act |
paper_accel__ |
Acceleration, inference speedup |
paper_accel__vllm, paper_accel__tensorrt |
paper_misc__ |
Doesn't fit elsewhere |
paper_misc__<name> |
Rules:
- Domain prefix groups related papers — they sort together alphabetically
- Method name should be the widely-known short name (e.g.
sam not segment_anything_model)
- If the paper introduces a named method, use that name; otherwise use a descriptive 2-3 word slug
- If a paper spans multiple domains, pick the primary one
- Ask the user to confirm the name if ambiguous
Adding New Domain Prefixes
If none of the existing prefixes fit, create a new one:
- Keep it to 2-5 lowercase chars
- Add it to this table (edit this skill file) so future skills stay consistent
Step 5: Generate the Skill
Create the skill directory under the user's skills path:
In the repo, paper skills go under skills/papers/. They get installed flat into ~/.claude/skills/.
skills/papers/paper_<domain>__<method_name>/
├── SKILL.md # Core reference
├── examples.md # Reproduction & usage recipes
└── templates/ # Config/script templates if useful
Use the templates below for each file.
What to Include vs. Skip
| Include |
Skip |
| Core method description (1-2 paragraphs) |
Full mathematical derivations |
| Architecture diagram (ASCII or description) |
Every ablation result |
| Installation commands |
Prose explanations of background |
| Key CLI commands & config flags |
Exhaustive API docs (list what matters) |
| Dependency list with versions |
Related work survey |
| Common usage scenarios |
Full training logs |
| Known gotchas / tips |
|
| Links to paper, repo, weights |
|
| Paper-Code Mapping (paper concept → file:class) |
|
| Exact class names, imports, function signatures |
|
| Code Integration Guide (how to use in your project) |
|
| Input/output tensor shapes & data formats |
|
Key Principles
- Code-faithful — use the original code's class names, function signatures, and patterns; never invent wrapper APIs that don't exist in the repo
- Skim-friendly — tables and code blocks over prose
- Reproducible — enough info to set up and run from scratch
- Linkable — always include paper URL, repo URL, weight URLs
- Integration-ready — a reader should be able to import and use the paper's code in their own project by following the skill
- Scenario-driven — organize around "I want to do X" not "Section 3.2 says..."
1---2name: create-skill-with-paper3description: Turn an academic paper into a reusable Claude Code skill for quick reference and reproduction in future projects.4---56# create_skill_with_paper78Turn an academic paper + its code repo into a reusable skill so you can quickly adopt and integrate the method in any project, staying faithful to the original implementation.910## When to Use1112- User provides a paper (PDF path, arXiv link, or title)13- User wants to reuse a paper's method in a new project14- User wants a quick-reference card for a paper's setup, dependencies, and core API1516## Workflow1718### Step 1: Gather Inputs1920Ask the user for:2122| Input | Required | Example |23|-------|----------|---------|24| Paper | Yes | arXiv link, PDF path, or title |25| Code repo | Yes (search if not provided) | GitHub URL |26| Skill name | Optional | Default: `snake_case` of short paper name |2728A code repo is **required**. If the user doesn't provide one, you must search for it (check the paper, Papers With Code, GitHub). If no official repo exists, tell the user and ask how to proceed.2930### Step 2: Read the Paper3132- If PDF path: read with the Read tool33- If arXiv link: fetch the abstract page, then download/read the PDF34- If title only: web-search for the paper, find arXiv or official link3536Extract these key elements:37381. **Paper identity** — title, authors, year, venue, links392. **Problem & contribution** — what problem does it solve, what's novel403. **Method overview** — high-level algorithm / architecture (not full math)414. **Key components** — named modules, losses, architectures worth remembering425. **Evaluation highlights** — main benchmarks, key results, comparisons4344### Step 3: Clone & Deep-Read the Code4546**You MUST clone the repo and read the actual source code.** Do not just skim the README.4748```bash49# Clone into a temp location50git clone <repo_url> /tmp/paper_skill_<method_name>51```5253#### 3a: Understand project structure5455Map out the repo — entry points, core modules, config system, data pipeline:5657| What to Extract | Where to Look |58|----------------|---------------|59| Dependencies & versions | `requirements.txt`, `setup.py`, `pyproject.toml`, `environment.yml` |60| Entry points | `train.py`, `run.py`, `main.py`, CLI args |61| Config system | `configs/`, argparse, hydra, omegaconf |62| Core model code | `models/`, `networks/`, `modules/` |63| Data pipeline | `datasets/`, `data/`, dataloader setup |64| Pre-trained weights | README download links, model zoo |6566#### 3b: Read core implementation files6768Read the actual source files for the method's core components. For each key module:6970- Read the file completely (don't just skim)71- Record the **exact class names, function signatures, and constructor arguments**72- Trace the forward pass / main algorithm flow through the code73- Note which classes/functions a user would need to import and call74- Identify default hyperparameters and their values in code (not just CLI flags)7576#### 3c: Cross-reference paper ↔ code7778Build an explicit mapping between paper concepts and code locations:7980- Which class implements the model described in Section X?81- Which function implements the loss from Equation Y?82- Where are the key hyperparameters (from Table Z) set in code?83- How does the data preprocessing match what the paper describes?8485This mapping becomes the **Paper-Code Mapping** section in the skill.8687#### 3d: Identify integration patterns8889Figure out how someone would **use this code in their own project** (not just run the repo's scripts):9091- What are the minimal imports needed?92- How do you instantiate the model, load weights, and run inference?93- What data format does the model expect (tensor shapes, dtypes, normalization)?94- Are there clean API boundaries, or is everything entangled with the training script?95- If the code is entangled, document the minimum extraction needed9697#### 3e: Clean up9899```bash100rm -rf /tmp/paper_skill_<method_name>101```102103### Step 4: Name & Organize the Skill104105#### Naming Convention106107Use the pattern: `paper_<domain>__<method_name>` (double underscore separates domain from method).108109The `paper_` prefix distinguishes paper-derived skills from other skill types (tools, workflows, etc.).110111| Domain Prefix | Area | Example Skill Names |112|---------------|------|---------------------|113| `paper_3d__` | 3D vision, NeRF, reconstruction | `paper_3d__gaussian_splatting`, `paper_3d__instant_ngp` |114| `paper_gen__` | Generative models, diffusion | `paper_gen__stable_diffusion`, `paper_gen__flow_matching` |115| `paper_det__` | Object detection | `paper_det__yolov9`, `paper_det__detr` |116| `paper_seg__` | Segmentation | `paper_seg__sam`, `paper_seg__mask2former` |117| `paper_llm__` | Large language models | `paper_llm__llama3`, `paper_llm__moe_routing` |118| `paper_vlm__` | Vision-language models | `paper_vlm__llava`, `paper_vlm__clip` |119| `paper_rl__` | Reinforcement learning | `paper_rl__ppo`, `paper_rl__grpo` |120| `paper_opt__` | Optimization, training methods | `paper_opt__lora`, `paper_opt__deepspeed` |121| `paper_data__` | Data processing, augmentation | `paper_data__webdataset`, `paper_data__albumentations` |122| `paper_rob__` | Robotics, embodied AI | `paper_rob__diffusion_policy`, `paper_rob__act` |123| `paper_accel__` | Acceleration, inference speedup | `paper_accel__vllm`, `paper_accel__tensorrt` |124| `paper_misc__` | Doesn't fit elsewhere | `paper_misc__<name>` |125126**Rules:**127- Domain prefix groups related papers — they sort together alphabetically128- Method name should be the widely-known short name (e.g. `sam` not `segment_anything_model`)129- If the paper introduces a named method, use that name; otherwise use a descriptive 2-3 word slug130- If a paper spans multiple domains, pick the primary one131- Ask the user to confirm the name if ambiguous132133#### Adding New Domain Prefixes134135If none of the existing prefixes fit, create a new one:136- Keep it to 2-5 lowercase chars137- Add it to this table (edit this skill file) so future skills stay consistent138139### Step 5: Generate the Skill140141Create the skill directory under the user's skills path:142143In the repo, paper skills go under `skills/papers/`. They get installed flat into `~/.claude/skills/`.144145```146skills/papers/paper_<domain>__<method_name>/147├── SKILL.md # Core reference148├── examples.md # Reproduction & usage recipes149└── templates/ # Config/script templates if useful150```151152Use the templates below for each file.153154## What to Include vs. Skip155156| Include | Skip |157|---------|------|158| Core method description (1-2 paragraphs) | Full mathematical derivations |159| Architecture diagram (ASCII or description) | Every ablation result |160| Installation commands | Prose explanations of background |161| Key CLI commands & config flags | Exhaustive API docs (list what matters) |162| Dependency list with versions | Related work survey |163| Common usage scenarios | Full training logs |164| Known gotchas / tips | |165| Links to paper, repo, weights | |166| **Paper-Code Mapping** (paper concept → file:class) | |167| **Exact class names, imports, function signatures** | |168| **Code Integration Guide** (how to use in your project) | |169| **Input/output tensor shapes & data formats** | |170171## Key Principles1721731. **Code-faithful** — use the original code's class names, function signatures, and patterns; never invent wrapper APIs that don't exist in the repo1742. **Skim-friendly** — tables and code blocks over prose1753. **Reproducible** — enough info to set up and run from scratch1764. **Linkable** — always include paper URL, repo URL, weight URLs1775. **Integration-ready** — a reader should be able to import and use the paper's code in their own project by following the skill1786. **Scenario-driven** — organize around "I want to do X" not "Section 3.2 says..."
WaterHyacinthInNANHU