Workflow·Research

Paper2Code

Converts an arxiv paper into a minimal, citation-anchored Python implementation, flagging all ambiguities and never inventing details not…

You say
Buy it · $29 Read it before you buy $29 Written by PrathamLearnsToCode · unverified publisher
Context cost
49.8k tokensestimated from the bundle, loaded when it triggers
Bundle
31 files · 199.0 kB7 scripts among them — read before you run
Licence
MITpaid listing
Last change
no release on file
Servers it uses
Noneruns standalone

What it does

Converts an arxiv paper into a minimal, citation-anchored Python implementation. Trigger when user runs /paper2code with an arxiv URL or paper ID, says "implement this paper", or pastes an arxiv link asking for implementation. Flags all ambiguities honestly. Never invents implementation details not stated in the paper.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Workflow

Runs a procedure end to end.

arxivreproductionpaperpython
Filed under

Research

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md5.3 kB · 113 lines
--- name: paper2code description: Converts an arxiv paper into a minimal, citation-anchored Python implementation. Trigger when user runs /paper2code with an arxiv URL or paper ID, says "implement this paper", or pastes an arxiv link asking for implementation. Flags all ambiguities honestly. Never invents implementation details not stated in the paper. ---
6# paper2code — Orchestration
7
8You are executing the paper2code skill. This file governs the high-level flow. Each stage dispatches to a detailed reasoning protocol in pipeline/. Do NOT skip stages. Do NOT combine stages. Execute them in order.
9
10## Parse arguments
11
12Extract from the user's input:
13- ARXIV_ID: the arxiv paper ID (e.g., 2106.09685). Strip any URL prefix.
14- MODE: one of minimal (default), full, educational.
15- FRAMEWORK: one of pytorch (default), jax, numpy.
16
17If the user provided a full URL like https://arxiv.org/abs/2106.09685, extract the ID 2106.09685.
18If the user provided a versioned ID like 2106.09685v2, keep the version.
19
20## Set up working directory
21
22Create a temporary working directory: .paper2code_work/{ARXIV_ID}/
23This is where intermediate artifacts go. The final output goes in the current directory under {paper_slug}/.
24
25## Install dependencies
26
27Run via Bash:
28```bash
29pip install pymupdf4llm pdfplumber requests pyyaml
30```
31
32## Execute pipeline
33
34### Stage 1 — Paper Acquisition and Parsing
35Read and follow: pipeline/01_paper_acquisition.md
36
37Run the helper script to fetch and parse the paper:
38```bash
39python skills/paper2code/scripts/fetch_paper.py {ARXIV_ID} .paper2code_work/{ARXIV_ID}/
40```
41Then run structure extraction:
42```bash
43python skills/paper2code/scripts/extract_structure.py .paper2code_work/{ARXIV_ID}/paper_text.md .paper2code_work/{ARXIV_ID}/
44```
45Verify the outputs exist before proceeding. If extraction failed, follow the fallback protocol in pipeline/01_paper_acquisition.md.
46
47The script also searches for official code repositories (in the paper text and on the arxiv page) and saves any found links to paper_metadata.json under the official_code key. Verify these links before relying on them — see Step 8 in pipeline/01_paper_acquisition.md.
48
49### Stage 2 — Contribution Identification
50Read and follow: pipeline/02_contribution_identification.md
51
52Read the parsed paper sections. Identify the single core contribution. Classify the paper type. Write the contribution statement. Save it to .paper2code_work/{ARXIV_ID}/contribution.md.
53
54### Stage 3 — Ambiguity Audit
55Read and follow: pipeline/03_ambiguity_audit.md
56
57Before reading this stage, also read: guardrails/hallucination_prevention.md
58
59Go through every implementation-relevant detail. Classify each as SPECIFIED, PARTIALLY_SPECIFIED, or UNSPECIFIED. Save the audit to .paper2code_work/{ARXIV_ID}/ambiguity_audit.md.
60
61### Stage 4 — Code Generation
62Read and follow: pipeline/04_code_generation.md
63
64Before writing code, read:
65- guardrails/scope_enforcement.md — to determine what's in and out of scope
66- guardrails/badly_written_papers.md — if the paper is vague or inconsistent
67- The relevant knowledge files in knowledge/ for the paper's domain
68- The scaffold templates in scaffolds/ for the expected file structure
69
70Determine the paper_slug from the paper title (lowercase, underscores, no special chars).
71Generate all files under {paper_slug}/ in the current working directory.
72
73### Stage 5 — Walkthrough Notebook
74Read and follow: pipeline/05_walkthrough_notebook.md
75
76Generate the walkthrough notebook that connects paper sections to code with runnable sanity checks. Save to {paper_slug}/notebooks/walkthrough.ipynb.
77
78## Cleanup
79
80Remove the .paper2code_work/ directory after successful completion.
81
82## Final output
83
84Print a summary:
85```
86✓ paper2code complete for: {paper_title}
87 Output directory: {paper_slug}/
88 Files generated: {list of files}
89 Unspecified choices: {count} (see REPRODUCTION_NOTES.md)
90 Mode: {MODE} | Framework: {FRAMEWORK}
91```
92
93## Mode-specific behavior
94
95- **minimal** (default): Core contribution only. Training loop only if contribution involves training. No data pipeline beyond Dataset skeleton.
96- **full**: Core contribution + full training loop + data pipeline + evaluation pipeline. More code, same citation rigor.
97- **educational**: Same as minimal but with extra inline comments explaining ML concepts, expanded walkthrough notebook with theory sections, and a PAPER_GUIDE.md that walks through the paper section by section.
98
99## Guardrails — always active
100
101These apply at ALL stages. Read them if you haven't already:
102- guardrails/hallucination_prevention.md — the most important file in this skill
103- guardrails/scope_enforcement.md — what to implement and what to skip
104- guardrails/badly_written_papers.md — what to do when the paper is unclear
105
106## Knowledge base — consult as needed
107
108Before implementing any of these components, read the corresponding knowledge file:
109- Transformer layers, attention, positional encoding → knowledge/transformer_components.md
110- Optimizers, LR schedules, batch size semantics → knowledge/training_recipes.md
111- Cross-entropy, contrastive loss, diffusion loss, ELBO → knowledge/loss_functions.md
112- Framework-specific pitfalls, notation mismatches → knowledge/paper_to_code_mistakes.md
113
In the file
SKILL.md670 words
Files31
LicenceMIT
Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈90
always loaded
The name and description, so the model knows the skill exists and when to reach for it.
49,660
on trigger
The instruction body and 30 supporting files, read only when the skill fires.
24.9%
of a 200k window
Ten skills this size would take about 249% of the window before you open a file.
050k100k150k200k context window

49.8k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption
Installsnone yet
Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for
Writes filesno
Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

What is in the bundle

31 files, 199.0 kB on disk. Mostly text — the instructions the model reads — with 7 scripts in it that your client would run only if the instructions tell it to.

  • SKILL.md5.3 kB
  • guardrails/badly_written_papers.md9.1 kB
  • guardrails/hallucination_prevention.md8.3 kB
  • guardrails/scope_enforcement.md8.1 kB
  • knowledge/loss_functions.md10.0 kB
  • knowledge/paper_to_code_mistakes.md10.6 kB
  • knowledge/training_recipes.md9.3 kB
  • knowledge/transformer_components.md14.3 kB
  • pipeline/01_paper_acquisition.md7.1 kB
  • pipeline/02_contribution_identification.md8.6 kB
  • pipeline/03_ambiguity_audit.md10.8 kB
  • pipeline/04_code_generation.md11.4 kB
  • pipeline/05_walkthrough_notebook.md7.0 kB
  • scaffolds/config_template.yaml2.7 kB
  • scaffolds/data_template.py3.3 kB
  • scaffolds/evaluate_template.py1.7 kB
  • scaffolds/loss_template.py1.4 kB
  • scaffolds/model_template.py4.2 kB
  • scaffolds/readme_template.md1.8 kB
  • scaffolds/reproduction_notes_template.md3.6 kB
  • scaffolds/train_template.py5.8 kB
  • scripts/extract_structure.py11.2 kB
  • scripts/fetch_paper.py15.8 kB
  • worked/attention_is_all_you_need/README.md2.7 kB
  • worked/attention_is_all_you_need/REPRODUCTION_NOTES.md6.0 kB
  • worked/attention_is_all_you_need/requirements.txt0.1 kB
  • worked/attention_is_all_you_need/review.md5.2 kB
  • worked/ddpm/README.md2.8 kB
  • worked/ddpm/REPRODUCTION_NOTES.md6.2 kB
  • worked/ddpm/requirements.txt0.1 kB
  • worked/ddpm/review.md4.5 kB
What is not in it

A skill installs nothing and depends on nothing: it is a folder your client reads. This one carries 7 scripts beside the text, so the bundle is 31 files you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

$29 once
Paper2Code · MIT · PrathamLearnsToCode
one-time
Price$29 once
LicenceMIT — the author’s, unchanged by this purchase
Paid throughStripe, once, on the card you add at the checkout
Keeps workingfor good — the files are yours once they are on disk
Updatesevery update its author ships, delivered through this account

You can read the whole bundle before paying — the SKILL.md above is the product, not a preview of it. What the money buys is the delivery: the folder packaged and handed to your machine by key, every update its author ships, and our support if it does not do what this listing says. The terms of use are MIT, set by the author and unchanged by buying it here.

Payment runs through Stripe, on a page like this one rather than a redirect. Once there is an account it joins the same mcprush invoice as everything else you run, so there is never a second card to enter.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/
Claude Desktop
ChatGPT
Cursor.cursor/skills/
VS Code.github/skills/
Codex CLI.agents/skills/
Gemini CLI.gemini/skills/
Grok.grok/skills/
Zed.agents/skills/
Windsurf.windsurf/skills/
Agent SDK.claude/skills/
HTTP / API
This release
Versionnot versioned
Publishedno release date on file
Price$29
Referenceprathamlearnstocode/paper2code

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v
  • No earlier releases have been published to the marketplace.
Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

PR
PrathamLearnsToCode

Publishes on mcprush.

0 servers listed1 skill listednot claimed
Profile
Publisher
Servers0