paper2skill-application-transfer

When to Use

Apply this skill when you encounter arXiv papers that:

• Take an established ML method (transformer, reinforcement learning, diffusion, etc.) and apply it to a new domain
• Address real-world deployment challenges or domain-specific constraints
• Cross disciplinary boundaries (e.g., vision model applied to robotics, NLP technique applied to biology)
• Describe adaptation or modification of existing techniques to fit problem requirements
• Include lessons learned from deploying research to production

Examples: AlphaFold applying attention to protein structure, quadrupedal locomotion adapting RL to embodied agents, BLIP adapting vision-language models to multimodal tasks.

When NOT to Use

Do not use this skill for:

• Pure methodological papers (novel architectures or algorithms without domain application)
• Purely exploratory papers (analyzing what works without solving a specific domain problem)
• Survey or review papers
• Papers that only benchmark existing methods
• Papers without clear domain-specific adaptation or constraints

---

Extraction Template

Step 1: Identify the Domain Problem

Extract what real-world or domain-specific problem the paper solves and why it matters.

**Domain Problem:** What specific problem is being solved? Why is it important?
**Domain Context:** What makes this problem different from standard benchmarks?
**Existing Approaches:** What was the baseline approach before this work?

Step 2: Analyze the Gap

Identify what existing methods lack and why naive application fails.

**The Gap:** What specific limitations did existing methods have for this domain?
**Why It Matters:** How does this gap translate to real-world failure modes?
**Domain Constraints:** What domain-specific constraints forced adaptation?
- Hardware/computational limits
- Data availability or annotation cost
- Real-time requirements
- Physical/safety constraints

Step 3: Extract the Source Method

Document the foundational technique being adapted.

**Source Technique:** What is the core ML method (architecture, loss, training procedure)?
**Original Context:** Where did this method originate and what was it designed for?
**Key Properties:** What properties make it suitable for adaptation to this domain?

Step 4: Extract Adaptation Decisions

Map the specific modifications made to fit the domain.

**Key Adaptations:**
1. [Specific change]: Why this change was necessary
2. [Specific change]: Why this change was necessary
3. [Specific change]: Why this change was necessary

**Why These Work:** How do these adaptations address the domain gap?

Step 5: Create the Adaptation Recipe

Synthesize a reusable template for similar transfers.

**Recipe for Domain Transfer:**
1. Identify source technique that has property X, Y, Z
2. Analyze your domain problem for constraint A, B, C
3. Map constraints to required modifications:
   - For constraint A, modify [component]
   - For constraint B, modify [component]
4. Validate with domain-specific metrics
5. Deploy with [deployment considerations]

Step 6: Extract Deployment Lessons

Document practical insights for real-world use.

**Deployment Considerations:**
- Data pipeline: [how to prepare domain data]
- Integration points: [where the method fits in larger systems]
- Failure modes: [what goes wrong and how to detect it]
- Scaling considerations: [production deployment constraints]
- Monitoring: [metrics that indicate healthy operation]

---

Output Skill Format

Generate a new SKILL.md with:

Frontmatter:

---
name: [kebab-case-domain-method]
title: [Domain Transfer: Adapting {Method} to {Domain}]
version: 0.0.2
engine: skillxiv-v0.0.2-claude-opus-4.6
license: MIT
url: [verified arxiv link to source paper]
keywords: [domain, method, constraint1, constraint2, outcome]
description: Apply {Method} to {Domain} by bridging the gap between {original context} and {domain requirements}. Focuses on {key adaptation}, enabling {outcome} when solving {problem class}.
---

Content structure:

1. Domain Problem (1 paragraph): What is being solved and why
2. The Gap (1 paragraph): Why existing methods don't work
3. Source Technique (1 paragraph): The foundational method
4. Adaptation Recipe (5-8 bullet points): Step-by-step how to port the method
5. Deployment Guide (3-4 bullet points): Production considerations
6. When to Use (1-2 sentences): Domain applicability
7. When NOT to Use (1-2 sentences): Boundary conditions

Length: 150-250 lines including code examples (if applicable)

---

Processing Instructions

1. Obtain the paper: Fetch HTML from arxiv.org/html/{arxiv_id}, fallback to PDF
2. Identify domain: Extract the problem domain from abstract and introduction
3. Find the source method: Locate which existing technique is being adapted
4. Map adaptations: For each modification, determine what domain constraint required it
5. Synthesize recipe: Generalize the adaptation pattern to teach domain transfer
6. Validate: Confirm the paper contains real domain-specific adaptation (not just application)
7. Generate skill: Write output skill following the format above

---

Quality Checks

• Paper clearly identifies a source technique and domain target
• Gap analysis explains why naive application would fail
• Specific adaptations are traceable to domain constraints
• Recipe is general enough to apply to similar domains
• Deployment section addresses production realities
• Output skill description is under 1024 characters
• Keywords (5-10) reflect both domain and method
• Engine tag matches skillxiv-v0.0.2-claude-opus-4.6