SkillAgentSearch skills...

ts-paper-cite

Stage 2 of the ts-paper suite. Build a complete, REAL refs.bib for a Traitement du Signal paper β€” using the user's provided references first and Claude's native WebSearch/WebFetch only for genuine gaps.

Install / Use

npx skills add Spark-To-Paper-Skills/spark-to-paper-skills --skill ts-paper-cite

Installs into whichever agent you are using.

About this skill
πŸ“„

SKILL.md

Installable skill definition

Quality Score

89/100

Supported Platforms

Claude Code

Tags

Our assessment of ts-paper-cite

ts-paper-cite scores 89/100 on our quality scale, 1680th of 4,700 Development & Engineering skills we index (top 36%).

Its SKILL.md is 13 KB long, well organised into 9 sections with 1 code example: a thorough specification that gives an agent plenty to work with.

With 1,126 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
17/20
Description
15/15
Adoption
13/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 3 months ago, so ts-paper-cite is actively maintained.
  • Our last check on 2026-10-31 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit β€” read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk β€” read a skill before letting an agent act on it.

ts-paper-cite compared with similar skills

All 4 of these similar skills score higher than ts-paper-cite; compare them before choosing.

SkillScoreStarsUpdatedFormat
ts-paper-cite (this skill)by Spark-To-Paper-Skills891.1k3mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md
claude-howtoby luongnv8910047.3k2d agoCLAUDE.md
lobehubby lobehub10085.6ktodayMCP Server

Frequently asked questions

How do I install ts-paper-cite?
Run npx skills add Spark-To-Paper-Skills/spark-to-paper-skills --skill ts-paper-cite. The install tabs above show the steps for each supported agent.
Which AI agents does ts-paper-cite work with?
It is written for Claude Code, as a SKILL.md file. Other agents that read the same format can often use it too.
Is ts-paper-cite safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is ts-paper-cite still maintained?
The repository was last updated about 3 months ago, so ts-paper-cite is actively maintained.

name: ts-paper-cite description: > Stage 2 of the ts-paper suite. Build a complete, REAL refs.bib for a Traitement du Signal paper β€” using the user's provided references first and Claude's native WebSearch/WebFetch only for genuine gaps. Every entry must have full metadata (authors, year, venue, vol(issue):pages, DOI); never a title-only stub; reference count is driven by real evidence, not a quota. Use when assembling or fixing the bibliography of a TS paper, or whenever citations must be real and complete.

ts-paper-cite β€” real, complete citations (no fabrication)

Citations support real claims with real evidence. Every entry in refs.bib is a paper that actually exists and that you verified. This stage replaces the original 100+-call retrieve→triage→ slot→bind→postdraft engine (which fabricated title-only stubs to hit hardcoded quotas) with a few Claude reasoning passes + native web search.

Procedure β€” broad systematic retrieval, then triage (adopt the original engine's coverage, keep integrity)

A TS journal paper is expected to be well-read: it situates itself in a full literature, not a minimal one. Do NOT stop at "just enough" β€” search broadly and systematically, then keep only the real, well-matched papers. This is the original product's strength (systematic query planning β†’ retrieve many β†’ triage), minus its fabrication.

  1. Reuse the idea2story seed first (if present). If retrieved_papers.json exists in the workdir (written by ts-idea2story, which already searched the literature), ingest it as a verified seed: for each paper run scripts/doi2bib.py <doi> to upgrade it to complete BibTeX (the DOI must resolve, or drop it β€” Crossref is authoritative over the seed's own metadata), and use its abstract+supports_claim to place it into claims_map.json. This is NOT a free pass β€” it removes the cold-start sweep, but you still verify each, place by abstract, and gap-fill below. Then the angles you must still search are the ones the seed does NOT cover.
  2. Plan the search angles (query packs). From the proposal + blueprint (and what the seed already covers), enumerate the angles a thorough reviewer expects covered, and write them to retrieval_plan.md:
    • the core task and its canonical benchmark/problem papers;
    • each method component / technique the paper builds on (every named module, predictor, feature, loss);
    • every dataset and every metric named in the experiment design;
    • every baseline named;
    • the adjacent lineages a reviewer would expect (neighbouring tasks, the families your method departs from);
    • recent surveys / foundational works of the area.
  3. Retrieve broadly. Run a WebSearch/WebFetch per angle (this is many searches, not "a handful" β€” breadth is the point). Collect candidate papers per angle. Prefer authoritative venues; capture the DOI/arXiv id as you go.
  4. Read each candidate's ABSTRACT to triage AND to place it. Fetch the abstract (WebFetch the venue/arXiv/Crossref page, or read the search snippet/TLDR) and use it to decide two things at once β€” this replaces the original engine's abstract β†’ family classification β†’ section routing:
    • triage: same-task / same-technical-lineage (keep) vs cross-domain / loose-overlap (reject). Surfacing many and filtering is better than finding the minimum.
    • placement: which section the paper belongs in and which exact claim it supports β€” record this as the section + claim in claims_map.json. Do NOT slot a paper by its title alone; the abstract is what justifies both "is it relevant" and "where does it go". Log kept/rejected counts per angle in retrieval_plan.md.
  5. Fetch complete metadata for every kept paper via scripts/doi2bib.py <doi> (deterministic, ASCII-folded, no LLM). User-provided references take priority and are preserved exactly.
  6. No real paper supports a claim β†’ don't cite it. Soften/rephrase or drop the claim. A real paper found by broader search is the only way to raise the count β€” never a stub, never an off-topic filler.
  7. Write refs.bib (complete entries only) + claims_map.json, then run the linter (which now enforces a coverage floor).

Every entry must be complete and real

  • Required fields: authors, year, venue (journal/booktitle), volume(issue), page range, and DOI (DOI or stable URL; arXiv id ok for preprints). Title alone is not enough.
  • Use @article/@inproceedings/@book with all fields populated. A bare @misc{key, title={...}} stub is forbidden. If you can only find a title, the paper is not verified β€” do not cite it.
  • Verify existence yourself: build/verify each entry through scripts/doi2bib.py <doi> (which actually resolves the DOI against Crossref) or a real venue/publisher/arXiv/Crossref/DBLP page. citations_lint.py by default only checks structural completeness (the fields are present) β€” it cannot tell a real DOI from an invented one; DOI resolution is enforced only under the opt-in citations_lint.py <workdir> --resolve flag (and by doi2bib.py), not by the default lint. Do not trust a title that only appears in your own generated text.
  • One bibkey per real paper (firstauthorYEARkeyword, ASCII, no leading digit); reuse it everywhere; never duplicate a paper under two keys.
  • Fast path to complete metadata: once you have a DOI, run scripts/doi2bib.py <doi> to fetch a fully-populated BibTeX entry from Crossref deterministically (no hand-transcription). For an arXiv-only preprint, give doi2bib.py the arXiv id instead β€” it takes an arXiv path (arXiv API β†’ eprint/archivePrefix, journal={arXiv preprint}) so the venue field is satisfied without a Crossref DOI.
  • Existence of arXiv-only entries: citations_lint.py --resolve resolves DOIs only; it skips entries that have an eprint (arXiv) and no doi, treating the arXiv id as its own existence signal β€” so a legitimate preprint is never wrongly flagged doi_unresolved.

How many β€” coverage target met with REAL papers (not a fabrication quota), per the TEMPLATE

Coverage is template-driven and enforced on TWO axes by citations_lint.py β€” a global count and a per-section distribution. The global floor alone is NOT sufficient: a paper can clear 40 total cites while whole body sections carry zero and related_work overflows its band. Both axes read template.json's citations block:

  • Global floor (citations.floor; TS ts_iieta = 40, target ~40–50; neurips = 30) β†’ coverage_below_floor if under.
  • Per-section bands (citations.per_section_coverage, e.g. related_work:[20,30], introduction:[8,12]) β†’ an evidence-bearing body section (introduction/related_work/method/ experiments/analysis) with zero cites is a HARD error section_zero_citations; a non-empty section outside its band is a warning section_coverage_out_of_band (rebalance β€” move/merge real cites; never fabricate or delete real support). Citation-free sections in a proposal (abstract, conclusion, future_work) are exempt from the zero-error.

A well-read paper sits at/above the floor and spreads its evidence across every body section. The only way to satisfy both is to search more broadly for real papers and place each in the section whose claim it actually supports β€” never to invent, pad, or dump everything into related_work. Stub/incomplete entries hard-fail separately, so coverage can only be cleared with real, fully-specified papers ("search harder", never "fabricate"). The seed from ts-idea2story (step 0) counts toward this once each entry is verified.

Per-section coverage (real papers; expand the search until each is genuinely covered):

  • related_work β€” the heaviest: map the full lineage of every theme (typically 20–30 distinct works), so a reviewer sees you command the field.
  • introduction β€” solid background + every prior-method attack cited (8–12).
  • method β€” cite every technique/module/predictor/feature/loss you build on or contrast (one per real predecessor).
  • experiments β€” cite every dataset, every metric, and every baseline named.
  • abstract/conclusion β€” none.

To reach 40–50 honestly, widen the angle set (more sub-lineages, more surveys, the foundational works behind each component, neighbouring tasks) rather than padding with off-topic papers. If after a genuinely broad search a niche topic truly has little prior work, fewer is acceptable and honest β€” but for a mainstream TS topic, under 40 almost always means the search was too shallow. Do not bloat with off-topic papers to hit the number; an off-topic cite fails claims_map.json's weak_claim_match anyway.

IIETA in-text style (used by the write stage)

Numeric [n] via natbib: the bundled ts_iieta.sty sets \setcitestyle{numbers,square,comma,sort&compress} with \bibliographystyle{unsrtnat}. The write stage emits \cite{bibkey} (or \cite{k1,k2,k3} for grouped) β€” never hand-typed [1]. No citations in the abstract or in headings.

Honesty (proposal β€” no real results)

Cite only to support claims about prior work / datasets / methods / metrics. Never cite to imply your proposed method has results it doesn't, and never hang a citation on a fabricated "outperforms by X%" sentence.

Emit claims_map.json (enforced claim↔citation matching)

Alongside refs.bib, write claims_map.json mapping every bibkey you will cite to its justification:

{ "chung2016syncnet": {"claim": "lip-sync models detect audio-video offset by contrasting windows",
                       "support_label": "same_line_support", "section": "related_work"} }

support_label ∈ {direct_core, same_line_support, context, baseline, dataset_metric, definition}. If the honest label for a match is off_topic/adjacent/weak, do not cite β€” drop or rephrase the claim. This makes the one-pass claim-matching an auditable artifact instead of a trust-me step.

Post-draft saturation sweep (REQUIRED after write/refine β€” it is now gated)

Citations are inserted in the write stage, so the per-section bands above are only meaningful after the draft exists. Re-running citations_lint.py on the drafted sections/*.tex is mandatory: it now fails on any evidence-bearing section left with zero cites (section_zero_citations) and on any claims_map section that disagrees with where the key is actually cited (claims_map_section_mismatch). Do a positive pass to catch citeable sentences the draft introduced that carry no cite β€” without porting the product's heavyweight ledger/cluster engine (the per-section gate distills its essential purpose deterministically).

  1. Find under-cited sections. Scan each finalized section; flag any factual claim about prior work / datasets / baselines / metrics with no \cite. (Self-method, self-results, and future-work sentences are non-citeable β€” never bolt a prior-work cite onto a results sentence.)
  2. Fill with real papers only, via the same WebSearch + doi2bib.py + claims_map.json discipline; honesty-by-omission if no real paper fits. At most 3–4 new cites per rewritten paragraph; preserve every existing \cite exactly.
  3. Two cheap precision devices (Claude-native, no code): (a) name the nearest wrong neighbor β€” for each citeable claim, name the single most-tempting cross-domain paper family and rule it out; (b) reserve tier β€” keep a "plausibly relevant but secondary" list and pull from it only if a section is genuinely thin, instead of hard-rejecting (reduces over-pruning).
  4. Re-run citations_lint.py (the floor + claim-match gate already exists; no new linter needed).
  5. In data_aware mode, treat results sentences as citeable measurement claims that should cite the dataset/baseline they report on, and nudge the floor up slightly (e.g. +4) β€” real data warran

Truncated for display β€” read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars1.1k
CategoryDevelopment
Updated2mo ago
Forks19

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit β€” see the Safety scan above for what the skill file itself contains.

No cautions
ts-paper-cite β€” Claude Code Skill: Install & Safety Check | SkillAgent