Agent skill

Study

by alaliqing in alaliqing/claude-paper

A skill your agent uses when the user wants to read, study, analyze, or deeply understand a research paper (PDF).

MITAuto-check: notesResearch & Science

Install Study

skills CLI
$ npx skills add alaliqing/claude-paper --skill study -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install alaliqing/claude-paper study --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/alaliqing/claude-paper.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugin/skills/study .claude/skills/study && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
study
GitHub stars
344
Token cost
~2.5k tokens
SKILL.md length
926 words
Files
5 (incl. scripts)
Skills in repo
3
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when the user wants to read, study, analyze, or deeply understand a research paper (PDF).

  • Works in 11 steps: Check Dependencies (First Run Only) → Download and Parse PDF → Assess Paper Before Generating Materials → …
  • The user wants to read
  • SKILL.md covers Step 1a: Check input type and…, Step 1b: Parse PDF, Required Files and Conditional Files, plus 6 more sections
  • Runs JavaScript and Python scripts from its folder; calls python3, node and npm; reaches arxiv.org and github.com

What it does

Study is an agent skill from alaliqing/claude-paper. Use this skill when the user wants to read, study, analyze, or deeply understand a research paper (PDF).

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including scripts (for example `scripts/extract-images.py`, `scripts/parse-pdf-core.js` and `scripts/parse-pdf.js`).

It sits in Research & Science, covering PDF. It works with DeepSeek, npm and Vue.js. The repository describes itself as: 📖 Cross-agent research paper toolkit for Claude Code, Codex, OpenCode, and DeepSeek Harness—quick summaries, deep study materials, code demos, and a local web viewer. The licence is MIT.

When your agent uses it

  • The user wants to read
  • Deeply understand a research paper (PDF)

Example prompts

  • “/study”

Requirements

  • Python 3
  • Node.js
  • Pre-approved tools (allowed-tools): Bash, Write, Edit, Read

Workflow steps

11 steps, taken from the step headings in SKILL.md.

  1. Check Dependencies (First Run Only)
  2. Download and Parse PDF
  3. Assess Paper Before Generating Materials
  4. 5: Generate Exactly 2 Semantic Tags (Mandatory)
  5. Generate Core Study Materials
  6. Code Demonstrations (Mandatory)
  7. Generate Interactive HTML Explorer
  8. Extract Images
  9. Update Index
  10. Relaunch Web UI
  11. Interactive Deep Learning Loop

What it can do on your machine

Read from SKILL.md and the folder at commit 0af55d0. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Bash
    • Write
    • Edit
    • Read

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 4 files in scripts/ (JavaScript and Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python3
    • node
    • npm
    • pip3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • arxiv.org
    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Study loads about 2.5k tokens when it runs. Until then it costs about 28 tokens; SKILL.md has 926 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~28
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Bash, Write, Edit, Read

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from alaliqing/claude-paper at commit 0af55d0, republished under its MIT licence (© alaliqing). 926 words, ~2,474 tokens.

Download SKILL.mdSave it as .claude/skills/study/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
study
description
Use this skill when the user wants to read, study, analyze, or deeply understand a research paper (PDF).
allowed-tools
Bash, Write, Edit, Read
disable-model-invocation
false

Paper Study Workflow

Invoke this skill with a paper PDF path.

Language Detection: Detect the user's language from their input and generate ALL materials in that language.

  • Example: User says "我们学习一下这篇论文吧" → Generate materials in Chinese
  • Example: User says "Let's study this paper" → Generate materials in English

Core Philosophy

Primary Objective: Facilitate deep conceptual understanding and research-level thinking.

Secondary Objective: Create a structured, reusable paper knowledge system.

This workflow is not just for summarizing — it builds a learning environment around the paper.


Step 0: Check Dependencies (First Run Only)

bash
if [ ! -f "${CLAUDE_PLUGIN_ROOT}/.installed" ]; then
  echo "First run - installing dependencies..."
  cd "${CLAUDE_PLUGIN_ROOT}"
  npm install || exit 1

  # Install Python dependencies for image extraction
  python3 -m pip install pymupdf --user 2>/dev/null || pip3 install pymupdf --user 2>/dev/null || echo "Warning: Failed to install pymupdf"

  touch "${CLAUDE_PLUGIN_ROOT}/.installed"
  echo "Dependencies installed!"
fi

Recommended:

  • Node >= 18
  • Python 3 with pip (for image extraction)

Step 1: Download and Parse PDF

Supports multiple input formats:

  • Local path: ~/Downloads/paper.pdf
  • Direct PDF URL: https://arxiv.org/pdf/1706.03762.pdf
  • arXiv URL: https://arxiv.org/abs/1706.03762

Step 1a: Check input type and download if URL

bash
USER_INPUT="<user-input>"

# Check if input is a URL (starts with http:// or https://)
if [[ "$USER_INPUT" =~ ^https?:// ]]; then
  # Download PDF from URL
  INPUT_PATH=$(node ${CLAUDE_PLUGIN_ROOT}/skills/study/scripts/download-pdf.cjs "$USER_INPUT")
else
  # Use local path directly
  INPUT_PATH="$USER_INPUT"
fi

For URLs, the download script will:

  • Download PDFs to /tmp/claude-paper-downloads/
  • Convert arXiv /abs/ URLs to PDF URLs automatically
  • Validate that URLs point to PDF files
  • Return the local file path for processing

For local paths, use the path directly without downloading.

Step 1b: Parse PDF

Extract structured information:

bash
PARSE_OUTPUT_DIR=$(mktemp -d)
node ${CLAUDE_PLUGIN_ROOT}/skills/study/scripts/parse-pdf.js \
  "$INPUT_PATH" \
  --output-dir "$PARSE_OUTPUT_DIR"

The command prints a small, strict JSON summary to stdout and writes:

  • meta.json — title, authors, abstract, links, page count, and a context-safe content preview
  • paper.txt — complete extracted text without the 50k preview limit

Use paper.txt as the source for generating materials. Search it and read relevant sections as needed; do not treat meta.json.content as the complete paper when contentTruncated is true.

After choosing {paper-slug}, create the paper directory and copy both parser artifacts plus the original PDF:

bash
mkdir -p ~/claude-papers/papers/{paper-slug}
cp "<metaPath-from-parser-output>" ~/claude-papers/papers/{paper-slug}/meta.json
cp "<fullTextPath-from-parser-output>" ~/claude-papers/papers/{paper-slug}/paper.txt
cp "$INPUT_PATH" ~/claude-papers/papers/{paper-slug}/paper.pdf

Generate exactly 2 tags in Step 2.5 and add them to the saved meta.json.

Fallback: If structured parsing fails, extract raw text and continue with degraded structure.


Step 2: Assess Paper Before Generating Materials

Before generating any files, evaluate:

  1. Difficulty Level

    • Beginner
    • Intermediate
    • Advanced
    • Highly Theoretical
  2. Paper Nature

    • Theoretical
    • Architecture-based
    • Empirical-heavy
    • System design
    • Survey
  3. Methodological Complexity

    • Simple pipeline
    • Multi-stage training
    • Novel architecture
    • Heavy mathematical derivation

This assessment determines:

  • Whether to create method.md
  • Whether to create .ipynb
  • Explanation depth
  • Code demo complexity

Step 2.5: Generate Exactly 2 Semantic Tags (Mandatory)

Before generating files, infer exactly 2 tags from semantic understanding of the paper.

Rules:

  • Generate exactly 2 tags, no more and no less
  • Tags must be distinct
  • Each tag should be short (1-3 words)
  • Avoid generic tags: paper, research, ai, ml
  • Prefer one tag for problem/domain and one for method/core idea

Examples:

  • machine translation, self-attention
  • 3d detection, bev transformer
  • protein folding, structure prediction

Persist these 2 tags in both locations:

  • ~/claude-papers/papers/{paper-slug}/meta.json as tags
  • ~/claude-papers/index.json entry as tags

Step 3: Generate Core Study Materials

Create folder:

~/claude-papers/papers/{paper-slug}/

Required Files

README.md
  • What the paper is about (one paragraph)
  • Difficulty level
  • How to navigate materials
  • Key takeaways
  • Estimated study time
  • Folder structure overview

summary.md
  • Background context
  • Problem statement
  • Main contributions
  • Key results
  • Quantitative metrics

insights.md (Most Important)
  • Core idea explained plainly
  • Why this works
  • What conceptual shift it introduces
  • Trade-offs
  • Limitations
  • Comparison to prior work
  • Practical implications

qa.md

15 questions:

  • 5 basic
  • 5 intermediate
  • 5 advanced

Use this format:

markdown
### Question

<details>
<summary>Answer</summary>

Detailed explanation.

</details>

---

Conditional Files

Include:

  • Component breakdown
  • Algorithm flow
  • Architecture diagram (ASCII if needed)
  • Step-by-step explanation
  • Pseudocode (balanced with explanation)
  • Implementation pitfalls
  • Hyperparameter sensitivity
  • Reproduction risks

  • What type of problem is this?
  • What prior knowledge is assumed?
  • How it fits into the broader research map
  • How to mentally categorize this work

Show full SKILL.md (368 more words)Show less
reflection.md (Optional auto-generated)
  • If I were to extend this paper
  • What open problems remain
  • What assumptions are fragile
  • Where it might fail in practice

Step 4: Code Demonstrations (Mandatory)

At least one runnable demo must be created.

All code demos must be placed in:

~/claude-papers/papers/{paper-slug}/code/

Create the code directory first:

bash
mkdir -p ~/claude-papers/papers/{paper-slug}/code

Guidelines:

  • Self-contained
  • Runnable independently
  • Educational comments (explain why)
  • Focus on core contribution
  • Prefer clarity over completeness

Possible types:

  • Simplified conceptual implementation
  • Visualization script
  • Minimal architecture demo
  • Interactive notebook (.ipynb)

Name descriptively:

  • model_demo.py
  • vectorized_planning_demo.py
  • contrastive_loss_visualization.ipynb

Avoid generic names.


Step 5: Generate Interactive HTML Explorer

Create a single self-contained HTML file for interactively exploring the paper's core concepts.

Output path:

~/claude-papers/papers/{paper-slug}/index.html

Requirements

  • Single HTML file, all CSS/JS inline, zero external dependencies
  • Uses real data from the paper (actual metrics, hyperparameters, comparisons) — never invent numbers
  • Must work in a sandboxed iframe (no external fetches, no localStorage)

Guidelines

Choose the interaction pattern that best fits the paper — architecture diagrams, parameter explorers, result dashboards, formula breakdowns, comparison matrices, etc. Let the paper's content dictate the format rather than forcing a fixed layout, focusing on the core ideas of the paper.

Every interactive control (slider, toggle, dropdown) should visibly change the visualization. Include brief explanatory text alongside interactive elements to teach concepts.


Step 6: Extract Images

bash
mkdir -p ~/claude-papers/papers/{paper-slug}/images

python3 ${CLAUDE_PLUGIN_ROOT}/skills/study/scripts/extract-images.py \
  paper.pdf \
  ~/claude-papers/papers/{paper-slug}/images

Rename key images descriptively:

  • architecture.png
  • training_pipeline.png
  • results_table.png

Step 7: Update Index

CRITICAL: Read existing index.json first, then append the new paper. Never overwrite the entire file.

If index.json does not exist, create:

json
{"papers": []}

Append new entry to the papers array:

json
{
  "id": "paper-slug",
  "title": "Paper Title",
  "slug": "paper-slug",
  "authors": ["Author 1", "Author 2"],
  "abstract": "Paper abstract...",
  "year": 2024,
  "date": "2024-01-01",
  "tags": ["tag-1", "tag-2"],
  "githubLinks": ["https://github.com/..."],
  "codeLinks": ["https://..."]
}

IMPORTANT: The index.json file must be located at:

~/claude-papers/index.json

Step 8: Relaunch Web UI

Invoke:

/claude-paper:webui

Step 9: Interactive Deep Learning Loop

After all files are generated:

Present to User:

  1. Ask:

    • What part is still unclear?
    • Do you want deeper mathematical breakdown?
    • Do you want implementation-level analysis?
    • Do you want comparison with another paper?
  2. Allow user to:

    • Ask deeper questions
    • Summarize their understanding
    • Propose new ideas

If user asks deeper questions:

Generate a new file inside the same folder:

Examples:

  • deep-dive-contrastive-loss.md
  • math-derivation-breakdown.md
  • comparison-with-transformers.md
  • extension-ideas.md

If user provides their own summary:

  1. Refine it.
  2. Improve structure.
  3. Save as:
  • user-summary-v1.md

If iterated:

  • user-summary-v2.md

If user wants structured consolidation:

Create:

  • consolidated-notes.md
  • study-session-1.md
  • exam-review.md

This makes the paper folder a growing knowledge node.


© alaliqing, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 4 other files (scripts) in plugin/skills/study of alaliqing/claude-paper.

  • SKILL.md
  • scripts/download-pdf.cjs
  • scripts/extract-images.py
  • scripts/parse-pdf-core.js
  • scripts/parse-pdf.js

Open the folder on GitHubat commit 0af55d0

Compare with similar skills

Study next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Study compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Study this skillalaliqing/claude-paper344—~2.5kAutomated safety check: NotesMIT
Slidev CLI Skilldskilld-dev/vue-ecosystem-skills181—~1.1kAutomated safety check: PassMIT
Documentszhongkaifu/TensorSharp553—~4.2kAutomated safety check: PassBSD-3-Clause
Datasheetsbiosshot/easyeda-copilot165—~1.2kAutomated safety check: PassMIT
Paper ReadingEdwardxlai/easyread826—~567Automated safety check: PassMIT
Ref Downloaderltczding-gif/ref-downloader139—~5.9kAutomated safety check: PassMIT

Similar skills

  • Slidev CLI Skilld

    skilld-dev/vue-ecosystem-skills

    Build, present, and ship Slidev decks with @slidev/cli. An agent skill from skilld-dev/vue-ecosystem-skills.

    181 GitHub stars~1.1k tokensUpdated 15 days ago
    Documents & OfficeAuto-check passed
  • Documents

    zhongkaifu/TensorSharp

    Read and write real documents on the device - PDF, XLSX, DOCX, PPTX and CSV.

    553 GitHub stars~4.2k tokensUpdated today
    Documents & OfficeAuto-check passed
  • Datasheets

    biosshot/easyeda-copilot

    Download component datasheet PDFs, locate useful pages, and read verified pinouts, electrical limits, thermal data and application notes using the agent's PDF tools.

    165 GitHub stars~1.2k tokensUpdated yesterday
    Documents & OfficeAuto-check passed
  • Paper Reading

    Edwardxlai/easyread

    论文共读:用 EasyRead(E:\CursorProject\easyread)这个本地工具读论文。用户给一篇 PDF 或 arXiv 编号时,导入文献库、翻译成中文(后台引擎或对话里的 agent 亲自译);之后边读边讨论,agent 读用户在页面上的笔记和提问,把回答、解释、原文核对提示追加到对应段落旁。用于…

    826 GitHub stars~567 tokensUpdated today
    Research & ScienceAuto-check passed
  • Ref Downloader

    ltczding-gif/ref-downloader

    A skill your agent uses when the user asks to batch-download academic PDFs with ref-downloader — either ALL references of one paper (Mode A: DOI or PDF input), OR a custom batch of papers (Mode B…

    139 GitHub stars~5.9k tokensUpdated 4 mo ago
    Research & ScienceAuto-check passed
  • Markdown Paged Guide

    BigStrongSun/ccswitchmulti

    Render Markdown manuals into polished per-page PNG images and PDF deliverables.

    122 GitHub stars~589 tokensUpdated 2 days ago
    Documents & OfficeAuto-check passed

More from alaliqing/claude-paper

  • Summary

    alaliqing/claude-paper

    Use this for a quick summary of a research paper's core ideas and key points.

    344 GitHub stars~2k tokensUpdated 1 mo ago
    Auto-check: notes
  • Webui

    alaliqing/claude-paper

    Start the Claude Paper web viewer to browse and study papers

    344 GitHub stars~906 tokensUpdated 1 mo ago
    Auto-check: notes

Questions about Study

What does Study do?

A skill your agent uses when the user wants to read, study, analyze, or deeply understand a research paper (PDF). Study is an agent skill from alaliqing/claude-paper. Use this skill when the user wants to read, study, analyze, or deeply understand a research paper (PDF).

When should I use Study?

Study fits situations like: the user wants to read; deeply understand a research paper (PDF).

How do I install Study in Claude Code?

Run `npx skills add alaliqing/claude-paper --skill study -a claude-code`. Or copy the skill folder (plugin/skills/study in alaliqing/claude-paper) into .claude/skills/study in your project. Claude Code loads it when a task matches its description.

How do I install Study in Codex?

Run `npx skills add alaliqing/claude-paper --skill study -a codex`. Or copy the skill folder (plugin/skills/study in alaliqing/claude-paper) into .agents/skills/study in your project. Codex loads it when a task matches its description.

Can I use Study in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add alaliqing/claude-paper --skill study -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/study, .gemini/skills/study, .github/skills/study and .opencode/skills/study in your project.

What does Study need to run?

Going by SKILL.md and its folder, Study needs JavaScript and Python for the scripts in its folder and the command-line tools its instructions call (python3, node, npm and pip3). Our summary lists: Python 3; Node.js. Its frontmatter pre-approves these tools: Bash, Write, Edit, Read.

Does Study access the network?

SKILL.md names 2 domains. In commands or code: arxiv.org and github.com; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.

Is Study safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Study use?

Study is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Study use?

About 2.5k tokens (SKILL.md is roughly 9.9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Study?

Skills that share tags, products or a category with Study: Slidev CLI Skilld (skilld-dev/vue-ecosystem-skills, 181 stars), Documents (zhongkaifu/TensorSharp, 553 stars), Datasheets (biosshot/easyeda-copilot, 165 stars) and Paper Reading (Edwardxlai/easyread, 826 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Study?

alaliqing (a GitHub user) maintains it in alaliqing/claude-paper, which has 344 GitHub stars. The repository holds 3 skills in this directory. The repository was last updated on August 14, 2026.

Source: alaliqing/claude-paper on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.