jiangxinke/harness-rl/systematic-literature-review
Claude Code and agent skill by jiangxinke/harness-rl
- community
Checking that the SKILL.md file is still in the repository.
Use this skill when the user wants a systematic literature review, survey, or synthesis across multiple academic papers on a topic. Also covers annotated bibliographies and cross-paper comparisons. Searches arXiv and outputs reports in APA, IEEE, or BibTeX format. Not for single-paper tasks — use academic-paper-review for reviewing one paper.
Install
npx vskill@latest install jiangxinke/harness-rl/systematic-literature-reviewSKILL.md
The same SKILL.md was published earlier as bytedance/deer-flow/systematic-literature-review.
Systematic Literature Review Skill
Overview
This skill produces a structured systematic literature review (SLR) across multiple academic papers on a research topic. Given a topic query, it searches arXiv, extracts structured metadata (research question, methodology, key findings, limitations) from each paper in parallel, synthesizes themes across the full set, and emits a final report with consistent citations.
Distinct from `academic-paper-review`: that skill does deep peer review of a single paper. This skill does breadth-first synthesis across many papers. If the user hands you one paper URL and asks "review this paper", route to academic-paper-review instead.
When to Use This Skill
Use this skill when the user wants any of the following:
- A literature survey on a topic ("survey transformer attention variants", "review the literature on diffusion models")
- A synthesis across multiple papers ("what do recent papers say about X", "compare methodologies across papers on Y")
- A systematic review with consistent citation format ("do an SLR on Z in APA format")
- An annotated bibliography on a topic
- An overview of research trends in a field over a time window
Do not use this skill when:
- The user provides exactly one paper and asks to review it (use
academic-paper-review) - The user asks a factual question that does not require synthesizing multiple sources (answer directly)
- The user wants general web research without academic rigor (use standard web search)
Workflow
The workflow has five phases. Follow them in order.
Phase 1: Plan
Before doing any retrieval, confirm the following with the user. If any of these are unclear, ask one clarifying question that covers the missing pieces. Do not ask one question at a time.
- Topic: the research area in plain English (e.g. "transformer attention variants").
- Scope: how many papers (default 20, hard upper bound 50), optional time window (e.g. "last 2 years"), optional arXiv category (e.g.
cs.CL,cs.CV). - Citation format: APA, IEEE, or BibTeX (default APA if the user does not specify and does not seem to be writing for a specific venue).
- Output location: where to save the final report (default
/mnt/user-data/outputs/).
If the user says "50+ papers", politely cap it at 50 and explain that synthesis quality degrades quickly past that — for larger surveys they should split by sub-topic.
Phase 2: Search arXiv
Call the bundled search script. Do not try to scrape arXiv by other means and do not write your own HTTP client — this script handles URL encoding, Atom XML parsing, and id normalization correctly.
IMPORTANT — extract 2-3 core keywords before searching. Do not pass the user's full topic description as the query. Before calling the script, mentally reduce the topic to its 2-3 most essential terms. Drop qualifiers like "in computer vision", "for NLP", "variants", "recent" — those belong in --category or --start-date, not in the query string.
Query phrasing — keep it short. The script wraps multi-word queries in double quotes for phrase matching on arXiv. This means:
"diffusion models"→ searches for the exact phrase → good, returns relevant papers."diffusion models in computer vision"→ searches for that exact 5-word phrase → too specific, likely returns 0 results because few papers contain that exact string.
Use 2-3 core keywords as the query, and use --category to narrow the field instead of stuffing field names into the query. Examples:
| User says | Good query | Bad query | |
|---|---|---|---|
| "diffusion models in computer vision" | "diffusion models" --category cs.CV | "diffusion models in computer vision" | |
| "transformer attention variants" | "transformer attention" | "transformer attention variants in NLP" | |
| "graph neural networks for molecules" | "graph neural networks" --category cs.LG | "graph neural networks for molecular property prediction" |
The script prints a JSON array to stdout. Each paper has: id, title, authors, abstract, published, updated, categories, pdf_url, abs_url.
Sort strategy:
- Always use `relevance` sorting — arXiv's BM25-style scoring ensures results are actually about the user's topic.
submittedDatesorting returns the most recently submitted papers in the category regardless of topic relevance, which produces mostly off-topic results. - When the user asks for "recent" papers or gives a time window, use
--sort-by relevancecombined with `--start-date` to constrain the time range while keeping results on-topic. For example, "recent diffusion model papers" →--sort-by relevance --start-date 2024-01-01, not--sort-by submittedDate. submittedDatesorting is only appropriate when the user explicitly asks for chronological order (e.g. "show me papers in the order they were published"). This is rare.lastUpdatedDateis rarely useful; ignore it unless the user asks.
Run the search exactly once. Do not retry with modified queries if the results seem imperfect — arXiv's relevance ranking is what it is. Retrying with different query phrasings wastes tool calls and risks hitting the recursion limit. If the results are genuinely empty (0 papers), tell the user and suggest they broaden their topic or remove the category filter.
If the script returns fewer papers than requested, that is the real size of the arXiv result set for the query. Do not pad the list — report the actual count to the user and proceed.
If the script fails (network error, non-200 from arXiv), tell the user which error and stop. Do not try to fabricate paper metadata.
Do not save the search results to a file — the JSON stays in your context for Phase 3. The only file saved during the entire workflow is the final report in Phase 5.
Phase 3: Extract metadata in parallel
You MUST delegate extraction to subagents via the `task` tool — do not extract metadata yourself. This is non-negotiable. Specifically, do NOT do any of the following:
- ❌ Write
python -c "papers = [...]"or any Python/bash script to process papers - ❌ Extract metadata inline in your own context by reading abstracts one by one
- ❌ Use any tool other than
taskfor this phase
Instead, you MUST call the task tool to spawn subagents. The reason: extracting 10-50 papers in your own context consumes too many tokens and degrades synthesis quality in Phase 4. Each subagent runs in an isolated context with only its batch of papers, producing cleaner extractions.
Split papers into batches of ~5, then for each batch, call the task tool with subagent_type: "general-purpose". Each subagent receives the paper abstracts as text and returns structured JSON.
Concurrency limit: at most 3 subagents per turn. The DeerFlow runtime enforces MAX_CONCURRENT_SUBAGENTS = 3 and will silently drop any extra dispatches in the same turn — the LLM will not be told this happened, so strictly follow the round strategy below.
Round strategy — use this decision table, do not compute the split yourself:
| Paper count | Batches of ~5 papers | Rounds | Per-round subagent count | |
|---|---|---|---|---|
| 1–5 | 1 batch | 1 round | 1 subagent | |
| 6–10 | 2 batches | 1 round | 2 subagents | |
| 11–15 | 3 batches | 1 round | 3 subagents | |
| 16–20 | 4 batches | 2 rounds | 3 + 1 | |
| 21–25 | 5 batches | 2 rounds | 3 + 2 | |
| 26–30 | 6 batches | 2 rounds | 3 + 3 | |
| 31–35 | 7 batches | 3 rounds | 3 + 3 + 1 | |
| 36–40 | 8 batches | 3 rounds | 3 + 3 + 2 | |
| 41–45 | 9 batches | 3 rounds | 3 + 3 + 3 | |
| 46–50 | 10 batches | 4 rounds | 3 + 3 + 3 + 1 |
Never dispatch more than 3 subagents in the same turn. When a row says "2 rounds (3 + 1)", that means: first turn dispatches 3 subagents in parallel, wait for all 3 to complete, then second turn dispatches 1 subagent. Rounds are strictly sequential at the main-agent level.
If the paper count lands between rows (e.g. 23 papers), round up to the next row's layout but only dispatch as many batches as you actually need — the decision table gives you the shape, not a rigid prescription.
Do the batching at the main-agent level: you already have every paper's abstract from Phase 2, so each subagent receives pure text input. Subagents should not need to access the network or the sandbox — their only job is to read text and return JSON. Do not ask subagents to re-run arxiv_search.py; that would waste tokens and risk rate-limiting.
What each subagent receives, as a structured prompt:
Parsing subagent results: the task tool returns strings with a fixed prefix like Task Succeeded. Result: [...JSON...]. Strip the Task Succeeded. Result: prefix (or Task failed. / Task timed out. prefixes) before trying to parse JSON. If a batch fails or returns unparseable JSON, log it, note which papers were affected, and continue with the remaining batches — do not fail the whole synthesis on one bad batch.
After all rounds complete, flatten the per-batch arrays into a single list of paper metadata objects, preserving order.
Phase 4: Synthesize and format
Now produce the final SLR report. Two things happen here: cross-paper synthesis (thematic analysis) and citation formatting.
Cross-paper synthesis: the report must do more than list papers. At minimum, identify:
- Themes: 3-6 recurring research directions, approaches, or problem framings across the set.
- Convergences: findings that multiple papers agree on.
- Disagreements: where papers reach different conclusions or use incompatible methodologies.
- Gaps: what the collective literature does not yet address (often stated explicitly in the "limitations" fields).
If the paper set is too small or too heterogeneous to support thematic synthesis (e.g. 5 papers on wildly different sub-topics), say so explicitly in the report — do not force themes that are not there.
Citation formatting: the exact format depends on user preference. Read only the template file that matches the user's requested format, not all three:
- templates/apa.md — APA 7th edition. Default for social sciences and most CS journals. Use when the user requests APA or does not specify a format.
- templates/ieee.md — IEEE numeric citations. Use when the user targets an IEEE conference or journal, or explicitly asks for IEEE.
- templates/bibtex.md — BibTeX entries. Use when the user mentions BibTeX, LaTeX, or wants machine-readable references. Important: arXiv papers are cited as
@misc, not@article— the BibTeX template covers this explicitly.
This is the start of the file. Read the full SKILL.md on GitHub.
Security
- Security scanPassed, 100 of 100Pattern checks on the skill's files.
- Model reviewNot runA model review is scheduled for the next rescan.
Quality evaluation
- Task evaluationNot runNo evaluation yet. Run one in Skill Studio.
Source
- SKILL.md in the repositoryCheckingStackPlanner2.0/skills/public/systematic-literature-review/SKILL.md
Popularity
- Repository stars
- 442
- Repository forks
- 53
- 7-day trend score
- 30
Stars and forks are for the whole GitHub repository, not this skill alone. Not refreshed yet.
Works with
Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.
- Claude Code
- Cursor
- GitHub Copilot
- Windsurf
- Codex
- Gemini CLI
- Cline
- Amp
- Roo Code
- Goose
- Continue
- Kilo Code
- Junie
- Trae
- OpenHands
- Qwen Code
- AI Agent
- Tabnine Chat
- Sourcegraph Cody
- Amazon Q
- Firebase Genkit
- Sweep
- Devin
- Phind
- Mentat
- Claude Desktop
- Aider
- GPT Pilot
- Plandex
- bolt.new
- v0
- Replit Agent
- Anse
- TypingMind
- BetterChatGPT
- LibreChat
- Warp AI
- Pieces
- Fig AI
Embed badge
[](https://verified-skill.com/skills/jiangxinke/harness-rl/systematic-literature-review)