SkillAgentSearch skills...

ts-paper

Generate a complete, publication-format journal/conference paper (LaTeX → compiled PDF) from whatever the user drops — a one-line idea, a proposal, or a proposal WITH real results.

Install / Use

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

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

93/100

Category

Automation

Supported Platforms

Claude Code

Our assessment of ts-paper

ts-paper scores 93/100 on our quality scale, 697th of 2,790 Automation skills we index (top 25%).

Its SKILL.md is 29 KB long, well organised into 20 sections with 5 code examples: 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
20/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 is actively maintained.
  • Our last check on 2026-10-26 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 compared with similar skills

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

SkillScoreStarsUpdatedFormat
ts-paper (this skill)by Spark-To-Paper-Skills931.1k3mo agoSKILL.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md

Frequently asked questions

How do I install ts-paper?
Run npx skills add Spark-To-Paper-Skills/spark-to-paper-skills --skill ts-paper. The install tabs above show the steps for each supported agent.
Which AI agents does ts-paper 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 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 still maintained?
The repository was last updated about 3 months ago, so ts-paper is actively maintained.

name: ts-paper description: > Generate a complete, publication-format journal/conference paper (LaTeX → compiled PDF) from whatever the user drops — a one-line idea, a proposal, or a proposal WITH real results. It ROUTES the input (idea→idea2story; proposal→proposal mode; results-present→data-aware mode), then runs plan→cite→write→refine→review→figure→latex using Claude's native abilities (reasoning, WebSearch, vision, file I/O, running Python) instead of a heavyweight per-call pipeline. Template-agnostic (ts_iieta + neurips bundled). Use for "write the paper", "proposal to paper", "turn this idea/report into a paper". Integrity is absolute: in proposal mode never fabricate numbers; in data-aware mode every number must trace to the user's real data.

ts-paper — Traitement du Signal paper generator (orchestrator)

You produce a publication-format paper (in whatever template the user picks) from a dropped input by first routing it (Stage 0) and then orchestrating seven focused sub-skills (the figure stage delegates its editable-vector output to ts-figure-svg — PaperBanana renders, then the figure is redrawn as a native audited SVG; falling back to ts-figure-optimize's DrawAI HYBRID, then to keeping the approved PNG as-is, never a lossy redraw — a 7-stage chain, not 8 stages).

Priority: QUALITY FIRST, cost second

The goal is a paper that reads like a real, well-written TS journal article with real, complete, correctly-matched citations. Never trade quality for cost. Do every quality step — verify each citation, self-review the draft, run the linters, right-size and polish, fix every compile error. Cost is kept reasonable as a by-product of Claude doing more per turn (one holistic pass instead of hundreds of micro-calls) — not by skipping reviews, shortening sections, or accepting a weaker draft. If a quality step needs another pass, take it.

The full suite (idea → figured paper) — where this orchestrator sits

This skill is the story2paper == proposal2paper spine. Two NEW upstream blocks are optional:

[corpus.jsonl] ─▶ ts-kg-build  (NEW, optional) ─▶ kg/         build a research-pattern KG (best-effort)
[raw idea]     ─▶ ts-idea2story (NEW)           ─▶ story_proposal.md + retrieved_papers.json
                                                  (uses kg/ if present; searches the web)
[story_proposal.md  OR  a user's own proposal] ─▶ ts-paper (THIS) ─▶ plan→cite→write→refine→review→figure→latex ─▶ main.pdf
                                                                       ( review = adversarial hardening, runs by default; user may opt out for a quick draft )
                                                                       ( figure ends every figure as an editable VECTOR PDF — matplotlib born-vector; image-model raster → ts-figure-optimize reconstruction )
  • If the user hands you a raw idea, run ts-idea2story first → it writes story_proposal.md (feed it here as the proposal) and retrieved_papers.json (the cite stage reuses it, so its search is much lighter — verify-the-seed + fill-the-gaps instead of a cold sweep).
  • If the user hands you a proposal, start here directly (skip the upstream blocks).
  • ts-kg-build only matters if you want KG-grounded recall in idea2story; it needs a user-supplied embedding endpoint and is honestly best-effort (TS already ships a built KG).

Inputs

  • A proposal (markdown/text): problem, gap, proposed method/solution, evaluation plan, claimed contributions.
  • Optional references the user already has (BibTeX, DOIs, or a references.json with title/authors/year/venue/doi).
  • An optional template name (default ts_iieta). The suite is template-agnostic — see below.
  • Optional retrieved_papers.json (the citation seed produced by ts-idea2story, if the upstream idea→story stage ran) — the cite stage reuses it.
  • Integrity (mode-dependent, overrides everything). In proposal mode there is no real data: never invent results/metrics/percentages; result tables stay blank (--); prose is forward-looking ("we evaluate… we expect…"). In data-aware mode (the router found real results) the opposite holds: report the real numbers in past tense, and every number must trace to the user's data (machine-checked by the number-audit) — still never invent or round a number that wasn't measured.

Working directory & handoff (files on disk = the contract between stages)

Create one working dir (default ./ts_paper_run/, or a user-named one) holding:

proposal.md                 # input
references.{json,bib}        # input (optional)
blueprint.json              # ← stage 1 (plan)
refs.bib                    # ← stage 2 (cite): complete, real BibTeX only
template.json               # ← the active template spec (copied in by the plan stage)
sections/<id>.tex           # ← stage 3 (write): LaTeX body per section (+ abstract.tex)
figures/<label>.pdf         # ← stage 6 (figure): EMBEDDED editable vector (matplotlib born-vector;
                            #   image-model raster → ts-figure-optimize); .png (kept original) + source alongside
main.tex, main.pdf          # ← stage 7 (assemble): compiled paper
<template assets>           # the template's .sty/.cls + masthead assets (copied by assemble)

Template-agnostic (NOT locked to one venue)

The suite writes to whatever template the user picks; paper content quality is invariant. A template is a directory templates/<name>/ (under this skill) holding template.json (the parametric spec: ordered section list + per-section recipes, word bands, citation style + floor, title/keyword rules, caption positions, heading case, masthead) + its LaTeX .sty/.cls + main.tex.tmpl. 🔴 A template's .sty/.cls must be either USER-PROVIDED or the venue's OFFICIAL files fetched verbatim — NEVER hand-authored or approximated; if neither is available, STOP and ask the user (see ts-paper-latex's HARD RULE). Two unofficial approximations ship for demo only ("official": false): ts_iieta (Traitement du Signal, two-column numeric — the default) and neurips (single-column, author-year) — replace with official/user files before any real submission. To use a template, pass template=<name>; the plan stage validates it (template_lint.py) and copies it into the workdir, and every downstream script reads template.json from the workdir — no script hardcodes TS. A user adds a new venue by dropping a templates/<name>/ dir; no code changes. Word bands, shape contracts (item/subsection/table counts), citation style/floor, and the preamble all come from the spec. What stays invariant across templates = the content-quality + integrity logic (no fabricated results, claims-map gating, no stubs, terminology consistency, Method-First order, LaTeX safety, the figure integrity rule).

Version check (silent, non-blocking)

Run python ts-paper/scripts/check_update.py once at the start. If it prints an update notice, show it to the user and continue — never block the pipeline for a version check.

Preflight — environment & keys (DO THIS FIRST, before Stage 0)

Before routing, run ONE environment + credential check and resolve gaps by this policy: credentials / user-data → ASK the user (and explain exactly what to configure); environment / runtime → SELF-CONFIGURE (only ask if you genuinely cannot). First source ./input/env.sh (or the repo .env) if present — keys live in key.txt.

  1. Embedding + KG (for ts-idea2story KG-recall & novelty). Probe TS_EMBED_* (a Qwen3-Embedding-8B endpoint) and whether a KG exists (kg/). If EITHER is missing → ASK the user: "Run the KG-grounded recall / novelty part? It needs an embedding API — Qwen3-Embedding-8B (TS_EMBED_API_KEY / TS_EMBED_BASE_URL / TS_EMBED_MODEL) — plus a research-pattern KG (build it with ts-kg-build)." If they decline (or the input skips idea2story) → degrade gracefully to web-search-only story (idea2story supports this; label it web/lexical-only). Never fabricate a key.
  2. Image-gen key (for ts-paper-figure). Probe the official PaperBanana first — python3 skills/ts-figure-svg/scripts/setup_paperbanana.py --check-only (it wants OPENROUTER_API_KEY, or GOOGLE_API_KEY); if that is not ready, probe gen_image.py / TS_FIG_* (a quick test render). If neither is available (unset env: … or a failing render) → ASK the user: "Generate figures? It needs an image-model key — TS_FIG_API_KEY / TS_FIG_BASE_URL / TS_FIG_MODEL (e.g. gpt-image-2)." If they decline → skip image-model figure drawing (every non-results figure; in proposal mode that is ALL figures — only results-section matplotlib data plots need no key); note the skipped placeholders in logs/0_route.io.md. Never improvise a key.
  3. Environment / runtime → SELF-CONFIGURE (do NOT ask first; you have the ability).
    • Native SVG redraw (ts-figure-svg, the default path from an approved render): nothing to provision — audit_svg.py is stdlib-only. Pull the official PaperBanana with python3 skills/ts-figure-svg/scripts/setup_paperbanana.py. An SVG→PDF backend is needed at the end (rsvg-convert / inkscape / a headless browser / cairosvg) — install one yourself if none is present.
    • DrawAI vectorizer (the FALLBACK, only when the native redraw cannot converge): if the ts-figure-optimize runtime is not ready (drawai doctor ≠ ok / models absent) → provision it yourself per ts-figure-optimize's setup — ModelScope source = NO HF token, GPU: install uv, run drawai setup local --source modelscope --device gpu, then apply the documented fixes (see that skill). Only if provisioning is genuinely impossible (no GPU / no network after trying) → tell the user, and keep the approved high-res PNG as-is (no conversion — never a redraw or flat fallback).
    • python deps (numpy / matplotlib / python-pptx / cairosvg) and LaTeX (latexmk / TinyTeX): if missing → install them yourself. Record the preflight outcome (what's available, what the user opted out of, what you auto-provisioned) in logs/0_route.io.md.

Stage 0 — route the dropped input (a Claude reasoning step, not a sub-skill)

The user drops one input and usually does not declare a pipeline or a mode. Before anything else, read the input (and any sidecar files) and classify it yourself — a plain Claude judgement over the content, with no fixed schema to match. Pick the entry stage and set results_mode in the workdir's template.json — the one switch the whole downstream suite reads. Set/re-assert it after the plan stage copies the template in (the cp resets it to the bundled proposal default), or as the plan stage's first action — so the router's choice survives the copy.

| class | what was dropped | route / entry | results_mode | |---|---|---|---| | (a) bare/short IDEA | a one-line message or a thin note, no method/eval structure | run ts-idea2story first → then plan | proposal | | (b) structured PROPOSAL | problem / method / eval / contributions, no measured results | plan (proposal) | proposal | | (c) PROPOSAL/REPORT + REAL RESULTS | measured numbers/tables in the text, or an attached data file (CSV/JSON/any form) | plan → ts-paper-data (DATA-AWARE) | data_aware | | (d) existing story.json | an 8-field story from a prior idea2story run | plan (skip idea2story) | proposal (a story.json from idea2story is forward-looking — no results); if the user also dropped real results alongside it, that is class (c)/data_aware by step 1 |

How to judge (shape-agnostic — there is NO fixed results schema):

  1. Is there real measured data? Any attached data file (CSV/JSON/a pasted table), or measured result numbers in the prose ("achieved 0.62 HOTA", "outperforms by 3.2 points", a filled results table — as opposed to hy

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars1.1k
CategoryAutomation
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