Skip to content
Back to search

AI-research-feedback

A collection of Claude Code skills for academic research review. These tools were developed by Claes Bäckman.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/claesbackman/AI-research-feedback with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/claesbackman/AI-research-feedback'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/claesbackman-ai-research-feedback/badge.svg)](/listings/claesbackman-ai-research-feedback)

HTML

<a href="/listings/claesbackman-ai-research-feedback"><img src="/api/listings/claesbackman-ai-research-feedback/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**Without a terminal (Windows Explorer, macOS Finder).** [Download the repository as a zip](https://github.com/claesbackman/AI-research-feedback/archive/refs/heads/main.zip), unzip it, and copy each folder inside `Skills/` (for example `review-paper`, `review-paper-light`) into `~/.claude/skills/`. That is a hidden folder in your user folder — `C:\Users\you\.claude\skills` on Windows, `/Users/you/.claude/skills` on macOS. Restart VS Code or Claude Code afterwards.

**With a terminal (macOS, Linux, WSL).** One line installs every skill globally:

git clone --depth 1 https://github.com/claesbackman/AI-research-feedback.git /tmp/airf && mkdir -p ~/.claude/skills && cp -R /tmp/airf/Skills/. ~/.claude/skills/ && rm -rf /tmp/airf

Re-run the same line later to update. The per-skill `curl` commands below install one skill at a time.

> **Already installed these as slash commands?** Custom commands and skills have merged in Claude Code, so any existing `~/.claude/commands/<name>.md` file keeps working and still provides `/<name>`. To avoid two definitions of the same command, delete the old `~/.claude/commands/<name>.md` file after installing the skill version.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 338 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # AI tools for research
  2. A collection of [Claude Code](https://claude.ai/code) skills for academic research. Some give you feedback on a paper, a pre-analysis plan, a grant proposal, or the code behind a result. Others help you communicate your results, by turning a paper into a policy brief or a slide deck. A few are utilities that make the rest easier to use. The tools were developed by [Claes Bäckman](https://claesbackman.com). For a broader introduction to using AI in research, including how these skills fit into a workflow, see the [AI workshop](https://claesbackman.com/ai_workshop/index.html) page.
  3. ## Skills in this repo
  4. Each skill lives in its own folder under `Skills/` with a `SKILL.md` file. Some skills also ship templates and helper scripts in the same folder.
  5. **Feedback on your writing.** A family of review skills that read a document and write a structured report with findings you can act on. They cover a full referee-style review of a paper, a quick check of the contribution and identification, a mechanical check of spelling and internal consistency, a review of a pre-analysis plan, and a review of a grant proposal.
  6. - `review-paper`, `review-paper-light`, `review-paper-checks`, `review-pap`, `review-grant`
  7. **Feedback on your code.** Skills that check whether the analysis code does what the paper says it does, or explain a change well enough that a coauthor could defend it.
  8. - `review-paper-code`: Paper–code reproducibility and alignment review.
  9. - `explain-diff`: Explain a code change as an offline HTML page with a quiz.
  10. **Communicating your results.** Skills that turn a finished paper into something for a different audience.
  11. - `paper-version`: Policy brief, one-page, or five-page summary with a standalone HTML page.
  12. - `explorable-deck`: A Quarto reveal.js slide deck built around a running example and live, presenter-driven figures.
  13. - `explorable-beamer`: The same deck in LaTeX beamer, with TikZ stages the presenter steps through, a handout build, and a screenshot-and-log check of every page.
  14. - `paper-website`: A digital edition of the paper as a static website, built from the LaTeX source, with the PDF's own numbering, search, linked references, and optional figures drawn from aggregate data.
  15. **Utilities.**
  16. - `pdf-to-markdown`: Convert a PDF to readable markdown, trimmed at the references.
  17. ## How the skills work
  18. These are [Claude Code skills](https://docs.anthropic.com/en/docs/claude-code). A skill is a folder containing a `SKILL.md` file, installed under `~/.claude/skills/<name>/` and invoked by typing `/<name>` (for example, `/review-paper`) inside Claude Code.
  19. A global install (`~/.claude/skills/`) is available in every project. A project-local install (`.claude/skills/`) applies only to that repository. Skills are picked up the next time you start Claude Code in the target directory.
  20. The review skills, `explain-diff`, and `paper-version` set `disable-model-invocation: true`, so they run only when you explicitly type their `/` command. Claude will never launch a multi-agent review on its own. `pdf-to-markdown`, `explorable-deck`, `explorable-beamer` and `paper-website` are the exceptions: Claude may reach for them on its own when you ask it to read a PDF, to make a presentation, or to put a paper online. The two deck skills still run their multi-agent review only when you ask for it, for example with `/explorable-beamer review`, or `full` to add the creative director.
  21. ## Installation
  22. ### Everything at once
  23. **Without a terminal (Windows Explorer, macOS Finder).** [Download the repository as a zip](https://github.com/claesbackman/AI-research-feedback/archive/refs/heads/main.zip), unzip it, and copy each folder inside `Skills/` (for example `review-paper`, `explorable-deck`) into `~/.claude/skills/`. That is a hidden folder in your user folder, `C:\Users\you\.claude\skills` on Windows and `/Users/you/.claude/skills` on macOS. Restart VS Code or Claude Code afterwards.
  24. **With a terminal (macOS, Linux, WSL).** One line installs every skill globally:
  25. ```bash
  26. git clone --depth 1 https://github.com/claesbackman/AI-research-feedback.git /tmp/airf && mkdir -p ~/.claude/skills && cp -R /tmp/airf/Skills/. ~/.claude/skills/ && rm -rf /tmp/airf
  27. ```
  28. Re-run the same line later to update.
  29. ### One skill at a time
  30. Every skill except `explorable-deck`, `explorable-beamer` and `paper-website` is a single `SKILL.md` file. Replace `<name>` with the skill's folder name:
  31. ```bash
  32. mkdir -p ~/.claude/skills/<name> && curl -o ~/.claude/skills/<name>/SKILL.md \
  33. https://raw.githubusercontent.com/claesbackman/AI-research-feedback/main/Skills/<name>/SKILL.md
  34. ```
  35. For a project-local install, use `.claude/skills/<name>` as the target instead of `~/.claude/skills/<name>`.
  36. `explorable-deck`, `explorable-beamer` and `paper-website` ship a template, reference notes, and helper scripts alongside their `SKILL.md`, so they need the whole folder (replace the name as needed):
  37. ```bash
  38. git clone --depth 1 https://github.com/claesbackman/AI-research-feedback.git /tmp/airf && mkdir -p ~/.claude/skills && cp -R /tmp/airf/Skills/explorable-deck ~/.claude/skills/ && rm -rf /tmp/airf
  39. ```
  40. > **Already installed these as slash commands?** Custom commands and skills have merged in Claude Code, so any existing `~/.claude/commands/<name>.md` file keeps working and still provides `/<name>`. To avoid two definitions of the same command, delete the old `~/.claude/commands/<name>.md` file after installing the skill version.
  41. ## Feedback on your writing: the review skills
  42. The review skills share one design. Each launches several specialised review agents in parallel, each with its own focus such as writing quality, internal consistency, unsupported claims, identification, or fit to a target journal, registry, or funder. The findings are consolidated into a single prioritised report saved under `reviews/` in the project folder, with the date in the filename and `-v2`, `-v3`, and so on appended when a file already exists. Reports live in their own subfolder so they cannot contaminate future runs. The skills read only the document's own source files and ignore old drafts, response letters, and previous review reports.
  43. | Command | What it does | Agents | Report |
  44. |---|---|---|---|
  45. | `/review-paper` | Full referee-style review of a paper, including six diagnostic questions on the contribution and a verification pass that removes wrong and marginal findings | 8 | `PRE_SUBMISSION_REVIEW_[date].md` |
  46. | `/review-paper-light` | Fast check of contribution, identification, and causal overclaiming, for quick iteration | 2 | `QUICK_REVIEW_[date].md` |
  47. | `/review-paper-checks` | Mechanical check of spelling, internal consistency, cross-references, and unsupported claims, with no editorial judgment. Offers to apply the unambiguous fixes to the `.tex` files afterwards | 3 | `PAPER_CHECK_[date].md` |
  48. | `/review-pap` | Pre-analysis plan review covering specification completeness, identification, statistical analysis, and implementation | 6 | `PAP_REVIEW_[date].md` |
  49. | `/review-grant` | Grant proposal panel review covering significance, innovation, design, feasibility, budget logic, and team | 6 | `GRANT_PROPOSAL_REVIEW_[date].md` |
  50. **Usage.** Every review skill takes an optional target and an optional path:
  51. ```text
  52. /review-paper
  53. /review-paper QJE
  54. /review-paper JF path/to/main.tex
  55. /review-pap AEA
  56. /review-grant ERC path/to/proposal.pdf
  57. ```
  58. If no path is given, the skill auto-detects the main file and follows its `\input{}` graph. If no target is given, it applies high general standards without a specific persona.
  59. | Skill | Recognised targets |
  60. |---|---|
  61. | `review-paper` | Top-5 economics: `AER`, `QJE`, `JPE`, `Econometrica`, `REStud`. Finance: `JF`, `JFE`, `RFS`, `JFQA`. Macro: `AEJMacro`, `JME`, `RED` |
  62. | `review-pap` | Registries: `AEA`, `EGAP`, `OSF`, `ClinicalTrials`, `ISRCTN`. Journals: `AER`, `QJE`, `JPE`, `RESTUD`, `AEJ`, `JEEA`. General: `top-journal` (default), `working-paper` |
  63. | `review-grant` | `NSF`, `NIH`, `ERC`, `HorizonEurope`, `major-funder` (default), `foundation` |
  64. Add journals or funders by editing the recognised names list in the skill file. Add project-specific context in your prompt or in a local `CLAUDE.md`.
  65. **Source of the contribution questions.** The six questions `review-paper` asks about a paper's contribution are from Jason Fletcher, ["How to Write a Top-5 Paper: A Case Study"](https://jasonmfletcher.substack.com/p/how-to-write-a-top-5-paper-a-case).
  66. **Which paper review to run.** `review-paper-checks` is for a draft you already believe in, shortly before submission, when you want to find things that are wrong rather than things that are debatable. `review-paper-light` is for a quick read of the argument while the paper is still moving. `review-paper` is the full report once the draft is close to final.
  67. **Requirements.** [Claude Code](https://docs.anthropic.com/en/docs/claude-code) with access to the `general-purpose` subagent. The paper reviews expect a LaTeX paper. The pre-analysis plan and grant reviews accept `.md`, `.txt`, or `.tex`, and will attempt `.pdf` and `.docx` while noting any accessibility limits. Both also inspect supporting files when present, such as power calculations, survey instruments, budgets, timelines, and CVs.
  68. ## Feedback on your code
  69. ### `review-paper-code` — Paper-Code Reproducibility Review
  70. Discovers the main LaTeX paper and the analysis code, checks reproducibility and code quality, maps the paper's main empirical claims to the code, and writes a constructive report with strengths, gaps to verify, and next steps.
  71. | Area | Focus |
  72. |---|---|
  73. | Paper discovery | Main `.tex` file and included sections |
  74. | Code discovery | Stata, R, and Python scripts in common analysis folders |
  75. | Reproducibility | Paths, seeds, outputs, dependencies, run order, documentation |
  76. | Code quality | Structure, commented-out code, opaque transforms, major thresholds |
  77. | Paper-code alignment | Tables, variables, sample restrictions, methods, clustering, fixed effects |
  78. **Usage:**
  79. ```text
  80. /review-paper-code
  81. /review-paper-code path/to/main.tex
  82. /review-paper-code path/to/main.tex path/to/code_dir
  83. /review-paper-code path/to/main.tex path/to/code_dir full
  84. ```
  85. The default depth, `main`, focuses on the main scripts and core outputs. `full` reviews every detected code file in scope. The report is written to `reviews/code_review_report.md`.
  86. **Requirements:** Claude Code with the `general-purpose` subagent, a LaTeX paper, and Stata, R, or Python analysis code.
  87. ### `explain-diff` — Explain a Code Change
  88. Explains a change to your analysis code well enough that someone who did not write it could defend it. It is aimed at the coauthor who needs to understand what an AI assistant or a collaborator just did to the estimation pipeline, and at your future self returning to a project after six months.
  89. The skill reads the diff and the surrounding code from scratch, ignoring any account of the change that already exists in the conversation, then writes a self-contained HTML page you open in a browser.
  90. The idea comes from Geoffrey Litt's [Understanding is the new bottleneck](https://www.geoffreylitt.com/2026/07/02/understanding-is-the-new-bottleneck), which argues that once agents write most of the code, the scarce resource is not verification but the researcher's own grasp of the system. Litt proposes explainer documents and embedded quizzes as a deliberate speed regulator. This skill is that proposal applied to empirical research code, where the thing you must not lose track of is what happened to the sample and the coefficients.
  91. | Section | Content |
  92. |---|---|
  93. | 1 | What the code did before, established by reading the surrounding scripts |
  94. | 2 | What changed and why, in plain language with no code |
  95. | 3 | Consequences for the results: which sample, which coefficients, which tables, and in which direction |
  96. | 4 | Walkthrough of the changed code, grouped by purpose rather than by file |
  97. | 5 | A five-question multiple-choice quiz with explanations for every option |
  98. Section 3 is the point of the skill. It requires verification rather than inference: comparing observation counts and coefficients between runs, checking whether a modified table file differs in its numbers or only in a timestamp, and reading any new output file before quoting a figure from it. When nothing about the results changed, the page has to say so explicitly and show the evidence. At least two quiz questions test empirical consequences rather than syntax.
  99. **Usage:**
  100. ```text
  101. /explain-diff
  102. /explain-diff abc123
  103. /explain-diff main..HEAD
  104. ```
  105. With no argument the skill explains the uncommitted working tree against `HEAD`, including files that are new and therefore invisible to `git diff`. A single ref is compared against the working tree. A range is used as given.
  106. **Output:** One HTML file saved **outside the repository**, in `~/Documents/` unless you name another directory, so it never lands in a commit or in your paper's folder. The skill confirms with `git status` afterwards that nothing in the project changed. Filenames end in a ref tag, for example `2026-08-01-cluster-by-municipality-wt-e956a7e.html`, so the pages stay matchable to commits. The page itself carries the full SHAs, the branch, and the exact comparison. You also get a plain-text summary in the terminal.
  107. **Requirements:** Claude Code and a git repository. No subagents are used. Stata, R, Python, and LaTeX are all optional.
  108. ## Communicating your results
  109. ### `paper-version` — Policy Brief, One-Page, or Five-Page Summary
  110. Turns a LaTeX research paper into a version for a non-specialist audience, checks it against the paper, and produces a standalone HTML page ready for GitHub Pages. Four agents run in sequence: a reader extracts the paper's content and claims verbatim, a writer drafts the requested format, a reviewer compares every number and causal claim in the draft against the extraction, and, after you have read the review and edited the draft, a fourth agent builds the page.
  111. | Argument | Output |
  112. |---|---|
  113. | `brief` | Two-page policy brief with fixed sections: The Question, What We Do, Key Findings, Policy Implications, Caveats (500–600 words) |
  114. | `1page` | One page of flowing prose for a general reader, leading with the main finding (350–400 words) |
  115. | `5page` | Narrative summary with light structure: Background, What We Did, What We Found, Why It Matters, Limitations (1,400–1,600 words) |
  116. The reviewer flags three kinds of problem: wrong or misattributed numbers, causal language stronger than the paper's own, and shifts in emphasis away from what the paper treats as central. The skill pauses after the review so you can edit the draft before the page is built.
  117. **Usage:**
  118. ```text
  119. /paper-version brief
  120. /paper-version 1page
  121. /paper-version 5page
  122. ```
  123. Run it from the paper's project folder. The skill finds the main `.tex` file and follows `\input` and `\include`.
  124. **Output:** An `output/` folder in the project containing `paper_extraction.md`, `[format]_draft.md`, `[format]_review.md`, and `index.html`. PNG or JPG versions of the paper's key figures are embedded when they exist in the project.
  125. **Requirements:** Claude Code with the `general-purpose` subagent, and a LaTeX paper.
  126. ### `explorable-deck` — Slide Deck in the Explorable-Explanation Style
  127. Builds a presentation from a paper, a set of notes, or a codebase as a [Quarto](https://quarto.org) reveal.js deck. The design follows the explorable-explanation tradition of Nicky Case and Bret Victor, adapted to the constraints of a talk: one idea per slide, titles that are assertions and read as the argument in sequence, a concrete running example introduced before any abstraction, and figures drawn at run time as stages the presenter operates while talking. The paper's own figures are converted from PDF and recoloured into the deck's palette. Everything a questioner might want goes into an appendix of uncounted slides linked from the main line, and the printed PDF has to carry the argument on its own. It is the talk-shaped sibling of the [`explorable-explanations`](https://github.com/nityeshaga/claude-home-base/tree/main/plugins/creative/skills/explorable-explanations) skill from the claude-home-base repository, which builds the website version as a non-linear tree of short interactive pages. When an explorable already exists for the topic, the deck reuses its data and chart code so the two never disagree on a number.
  128. The skill first fixes the frame (audience, length, venue) and writes a talk script in `plan.md` before building any slide. If you have not said otherwise it assumes a 20-minute conference talk for a mixed academic room. Every number in a chart lives in one data object that the prose also reads from, so the two cannot disagree. After the deck renders, the skill screenshots every slide, fixes every console error and every slide whose content runs off the frame, and checks the deck against a list of common faults.
  129. **Review.** The multi-agent review is optional. It is the slowest part of a run, and it is most useful once you have seen the deck and settled its content. By default the skill stops after its own checks and tells you that it skipped the review. You can ask for the review when you build the deck, or later on a finished one:
  130. | Level | How to ask | What runs after the checks |
  131. |---|---|---|
  132. | none (default) | `/explorable-deck` | Nothing more |
  133. | `review` | `/explorable-deck review`, or "review the deck" | Four review agents for writing, slides, visuals, and teaching, plus a simulated audience member, all in parallel. The skill then builds a second version from their findings |
  134. | `full` | `/explorable-deck full`, or "full review" | The above, then a creative director who proposes a visual identity for the deck |
  135. Build without review while the content is still moving, and run `review` before a talk that matters.
  136. **Usage:**
  137. ```text
  138. /explorable-deck
  139. /explorable-deck 12-minute seminar talk from paper/main.tex
  140. /explorable-deck review 20-minute talk from paper/main.tex
  141. /explorable-deck review slides/
  142. ```
  143. The last line reviews a deck that already exists in `slides/`.
  144. Claude may also pick this skill on its own when you ask for a presentation, talk, or slides.
  145. **Output:** One folder per deck containing `index.qmd`, the theme, the chart code, converted figures, `plan.md`, and a README that says how to render, check, and present it. Render with `quarto render index.qmd` and open `index.html` in a browser. While presenting, `S` opens the speaker view with notes, `F` goes fullscreen, `O` shows the overview, and `E` switches to the print view for exporting a PDF.
  146. **Requirements:**
  147. - Claude Code with the `general-purpose` subagent for the optional review passes.
  148. - [Quarto](https://quarto.org/docs/get-started/) on your path.
  149. - Python 3 and Google Chrome, for the screenshot check. Optionally `playwright` instead of Chrome.
  150. - `pdftocairo` (part of poppler, `brew install poppler` on macOS) if you want the paper's PDF figures converted into the deck.
  151. - Install the whole `Skills/explorable-deck` folder, not just `SKILL.md`. See [Installation](#one-skill-at-a-time).
  152. ### `explorable-beamer` — The Same Deck in LaTeX Beamer
  153. Builds the same kind of deck as `explorable-deck`, under the same design rules, as a LaTeX beamer PDF. Use it when the talk has to be a PDF or the project already lives in LaTeX. Because a PDF cannot run live figures, the stages are TikZ and pgfplots charts that the presenter steps through with overlays. The paper's own PDF figures go in directly and are recoloured into the deck's palette. Every number a chart draws or a sentence quotes comes from one file, `data/numbers.tex`. When a Quarto deck or a website explorable already exists for the topic, the skill transcribes its numbers instead of retyping them from the paper.
  154. One build produces three PDFs: the talk with each overlay step on its own page, a handout with one page per frame in its finished state for printing or sending, and a notes version with each slide beside its speaker note. While editing, `sh build.sh --fast` builds only the talk, in about a third of the time. The check screenshots every page, reports errors and warnings from the LaTeX log, and names any page whose content reaches the footline, which beamer compiles with only an easily missed log line. A lint then flags label titles, missing speaker notes and source lines, shrunk type, and overlays that would print wrongly in the handout.
  155. Review works as in `explorable-deck`: none by default, `review` for the four review agents and the audience member, and `full` to add the creative director.
  156. **Usage:**
  157. ```text
  158. /explorable-beamer
  159. /explorable-beamer 20-minute conference talk from paper/main.tex
  160. /explorable-beamer review slides/
  161. /explorable-beamer full 45-minute job-market talk from paper/main.tex
  162. ```
  163. Claude may also pick this skill on its own when you ask for a Beamer, LaTeX, or PDF presentation.
  164. **Output:** One folder per deck containing `deck.tex`, the theme, the charts, the data file, the recoloured figures, `plan.md`, and a README that says how to build, check, and present it. `sh build.sh` writes `deck.pdf` to present full screen in any PDF viewer, `deck-handout.pdf` to print or send, and `_build/deck-notes.pdf` for speaker notes on a second screen with `pdfpc --notes=right _build/deck-notes.pdf`.
  165. **Requirements:**
  166. - Claude Code with the `general-purpose` subagent for the optional review passes.
  167. - TeX Live 2019 or later with `lualatex`, `latexmk`, and pgfplots 1.16 or later. The template needs no network access and no font installation.
  168. - Python 3 and poppler (`brew install poppler` on macOS, `apt install poppler-utils` on Linux), for the screenshot check.
  169. - Ghostscript (`brew install ghostscript`) if you want the paper's PDF figures recoloured. Without it they are copied in unchanged.
  170. - Optionally [pdfpc](https://pdfpc.github.io/) to present with speaker notes.
  171. - Install the whole `Skills/explorable-beamer` folder, not just `SKILL.md`. See [Installation](#one-skill-at-a-time).
  172. ### `paper-website` — A Digital Edition of the Paper
  173. Turns a LaTeX paper into a simple static website for an academic audience. Every section becomes a page, and sections, figures, tables and equations keep the numbers they have in the PDF. Footnotes open in place, citations link to the reference list, and hovering over a citation or an exhibit number shows what it points to. The site has full-text search, a light and a dark theme, a "cite this paper" box, and a CSV download under every table.
  174. The skill asks a short list of questions before it builds: whether the site should carry data, which extra pages to include (data and code, questions and answers, errata), how to treat the appendix (including a separate online appendix file), where the site will live, and the colour scheme and typeface. The default scheme shares its palette with the explorable decks, so a paper's site and its slides look like one family. Data comes in three tiers. With no data, figures are the paper's images. With figure data, chosen figures are redrawn from aggregate CSV tables with a table view and a download. The third tier adds a page where readers slice one aggregate table by its dimensions. A guard in the build refuses files that look like microdata.
  175. The build scripts are copied into your project, so you can update the site after every revision with one command and without the skill. The update reports what changed since the last build (pages, renumbered figures and tables), keeps page addresses stable when a section is retitled, leaves a redirect where a page disappears, and can copy the site to its public folder. The site shows the date and git commit of the paper it was built from. Running the installer again upgrades a project to a newer template without touching its settings or hand-written pages.
  176. **Usage:**
  177. ```text
  178. /paper-website
  179. /paper-website Writing/main.tex
  180. /paper-website rebuild after the revision
  181. ```
  182. Claude may also pick this skill on its own when you ask for a website, web version, or online version of a paper.
  183. **Output:** A `website_build/` folder in your project (`site.json`, the Python scripts, the theme, the hand-written pages) and the site itself in a folder such as `Website/`, ready to copy to GitHub Pages or any static host. A checker reports broken links, unresolved references, formulas that do not render, and exhibit numbers that differ from the PDF.
  184. **Requirements:**
  185. - pandoc (`brew install pandoc`), required.
  186. - poppler (`brew install poppler` on macOS, `apt install poppler-utils` on Linux), to convert PDF figures and to compare exhibit numbers with the PDF.
  187. - Python 3.8 or later. No extra packages.
  188. - Chrome or Chromium for the rendered check.
  189. - Install the whole `Skills/paper-website` folder, not just `SKILL.md`. See [Installation](#one-skill-at-a-time).
  190. Sites built with the skill carry a credit line in the footer and the citation of this repository on their data and code page.
  191. **Credit.** The idea of publishing a paper as a website of this kind comes from Paul Novosad and coauthors, who built [nobel-prizes.devdatalab.org](https://nobel-prizes.devdatalab.org/) for their paper. See also Novosad's [post on X](https://x.com/paulnovosad/status/2108204197921620159).
  192. ## Utilities
  193. ### `pdf-to-markdown` — Convert a PDF to Readable Markdown
  194. Converts a PDF to a markdown file saved next to it, with page markers every twenty pages and the text trimmed at the references or appendix so the main text is what enters the context window. Useful before running any of the review skills on a paper you only have as a PDF, and for reading long documents without spending context on the bibliography.
  195. When `pdftotext` (part of poppler) is installed the conversion runs in one shot outside the model and takes seconds regardless of length. Without it the skill falls back to reading the PDF in twenty-page chunks, which works but is slow for long documents. Recommended: `brew install poppler` (macOS) or `apt install poppler-utils` (Linux, WSL).
  196. **Usage:**
  197. ```text
  198. /pdf-to-markdown path/to/paper.pdf
  199. ```
  200. **Output:** `path/to/paper.md`, plus a short report: method used, pages processed, where the text was trimmed, and any unreadable pages.
  201. **Requirements:** Claude Code. No subagents are used. `pdftotext` is optional but recommended.
  202. ## How to cite
  203. If you use these skills in your research, please cite the repository. GitHub's "Cite this repository" button on the repo page exports the reference in APA or BibTeX format from the `CITATION.cff` file. In BibTeX:
  204. ```bibtex
  205. @misc{backman2026aitools,
  206. author = {B{\"a}ckman, Claes},
  207. title = {{AI} tools for research: {Claude Code} skills for feedback on and communication of academic research},
  208. year = {2026},
  209. version = {1.0.0},
  210. howpublished = {\url{https://github.com/claesbackman/AI-research-feedback}}
  211. }
  212. ```
  213. ## License
  214. MIT — free to use, adapt, and share.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.