paper2code — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited paper2code (Agent Skill) and scored it 83/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 4 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 4 flagged
The text {match} tells the agent to skip the normal "ask the user first" gate. Used adversarially it removes the human-in-the-loop check before destructive or sensitive actions, turning a normally-gated agent into a fire-and-forget executor.
The text {match} tells the agent to skip the normal "ask the user first" gate. Used adversarially it removes the human-in-the-loop check before destructive or sensitive actions, turning a normally-gated agent into a fire-and-forget executor.
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
This Skill executes a 4+2 stage pipeline effectively systematically analyzing research papers and converting them into executable code.
Core Principle: Do not simply read the paper and generate code; generate a structured intermediate representation (YAML) first, then write the code.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ MANDATORY BEHAVIORAL RULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Implement one file at a time
2. Proceed to the next file only after completing the current file, without asking for confirmation
3. Original paper specifications always take precedence over reference code
4. Perform a Self-Check for each Phase before completion
5. Save all intermediate results as YAML files
DO:
✓ Implementing exactly what is stated in the paper
✓ Write simple and direct code
✓ Working code first, elegant code later
✓ Test each component immediately
✓ Move to the next file immediately after implementation is complete
DON'T:
✗ Do not ask "Shall I implement the next file?" between files
✗ Extensive documentation not required for core functionality
✗ Optimization not needed for reproducibility
✗ Excessive abstraction or design patterns
✗ Providing instructions without writing actual code
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━https://arxiv.org/abs/xxxx.xxxxx or https://arxiv.org/pdf/xxxx.xxxxx.pdf/path/to/paper.pdfFor arXiv URL:
# Convert to PDF URL and download
curl -L "https://arxiv.org/pdf/xxxx.xxxxx.pdf" -o paper.pdf
# Convert PDF to text (using pdftotext)
pdftotext -layout paper.pdf paper.txtFor PDF File:
pdftotext -layout "/path/to/paper.pdf" paper.txt[User Input: Paper URL/File]
│
▼
┌─────────────────────────────────────────────┐
│ Step 0: Acquire Paper Text │
│ - arXiv URL → Download PDF │
│ - PDF → Convert to Text │
└─────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ Phase 0: Search Reference Code (Optional) │
│ @[05_reference_search.md] │
│ Output: reference_search.yaml │
└─────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ Phase 1: Algorithm Extraction │
│ @[01_algorithm_extraction.md] │
│ Output: 01_algorithm_extraction.yaml │
└─────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ Phase 2: Concept Analysis │
│ @[02_concept_analysis.md] │
│ Output: 02_concept_analysis.yaml │
└─────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ Phase 3: Implementation Plan │
│ @[03_code_planning.md] │
│ Output: 03_implementation_plan.yaml │
└─────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ Phase 4: Code Implementation │
│ @[04_implementation_guide.md] │
│ Output: Complete Project Directory │
└─────────────────────────────────────────────┘phase1_to_phase2:
algorithms_found: "[Number of found algorithms]"
key_algorithms:
- name: "[Algorithm Name]"
section: "[Paper Section]"
complexity: "[Simple/Medium/Complex]"
hyperparameters_count: "[Number of collected hyperparameters]"
critical_equations: "[List of critical equation numbers]"
missing_info: "[List of missing information]"phase2_to_phase3:
components_count: "[Number of identified components]"
implementation_complexity: "[Low/Medium/High]"
key_dependencies:
- "[Component A] → [Component B]"
experiments_to_reproduce:
- "[Experiment Name]: [Expected Result]"
success_criteria:
- "[Specific Success Criteria]"phase3_to_phase4:
file_order: "[List of files in implementation order]"
current_file: "[Currently implementing file]"
completed_files: "[List of completed files]"
blocking_dependencies: "[Dependencies to resolve]"Using the @05_reference_search.md prompt:
Using the @01_algorithm_extraction.md prompt:
Using the @02_concept_analysis.md prompt:
Using the @03_code_planning.md prompt:
file_structure: Project file structureimplementation_components: Implementation component detailsvalidation_approach: Validation and testing methodsenvironment_setup: Environment and dependenciesimplementation_strategy: Step-by-step implementation strategyFollowing the guide @04_implementation_guide.md:
Refer to the guide @06_memory_management.md:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ BEFORE DECLARING COMPLETE - ALL MUST BE YES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
□ All algorithms in the paper implemented? → YES / NO
□ Correct versions of environment/datasets set? → YES / NO
□ All comparison methods referenced implemented? → YES / NO
□ Working integration to run paper experiments? → YES / NO
□ All metrics, figures, tables reproducible? → YES / NO
□ Basic docs explaining how to reproduce? → YES / NO
□ Code runs without errors? → YES / NO
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ If even one is NO, it is NOT complete!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━User: Implement this paper https://arxiv.org/abs/2301.12345
Claude: I will analyze the paper and convert it to code.
[Phase 0: Reference Code Search (Optional)...]
[Phase 1: Algorithm Extraction...]
[Phase 2: Concept Analysis...]
[Phase 3: Establish Implementation Plan...]
[Phase 4: Code Generation...]User: Implement the algorithms from this paper /home/user/papers/attention.pdfUser: Implement only the algorithm in Section 3 of this paper⚠️ REMEMBER:
1. Read the paper thoroughly: Start implementation after understanding the entire content
2. Save detailed results: Save YAML output of each Phase as a file
3. Incremental implementation: Do not generate all code at once, proceed file by file
4. Include verification: Include simple test code if possible
5. Reference is inspiration: Reference code is for understanding and application, not copying~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.