SkillAgentSearch skills...

ts-paper-figure

Stage 6 of the ts-paper suite. Fill a Traitement du Signal paper's figure placeholders with real diagrams. Claude DESIGNS a concrete, rich figure and GROUNDS it on a real on-topic top/mid-journal MAIN figure (Claude **WebSearches** for it, then `fetch_reference_figures.py` pulls that paper's MAIN fi…

Install / Use

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

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

89/100

Category

Automation

Supported Platforms

Claude Code

Our assessment of ts-paper-figure

ts-paper-figure scores 89/100 on our quality scale, 1397th of 2,780 Automation skills we index.

Its SKILL.md is 31 KB long, split into 7 sections with 2 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
16/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-figure 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-figure compared with similar skills

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

SkillScoreStarsUpdatedFormat
ts-paper-figure (this skill)by Spark-To-Paper-Skills891.1k3mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md

Frequently asked questions

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

name: ts-paper-figure description: > Stage 6 of the ts-paper suite. Fill a Traitement du Signal paper's figure placeholders with real diagrams. Claude DESIGNS a concrete, rich figure and GROUNDS it on a real on-topic top/mid-journal MAIN figure (Claude WebSearches for it, then fetch_reference_figures.py pulls that paper's MAIN figure, passed to the image model as an image-condition — grounding is MANDATORY, no silent skip); the render comes from the official PaperBanana pipeline (ts-figure-svg/scripts/setup_paperbanana.py, its own Retriever→Planner→Stylist→Visualizer→Critic) or, unconfigured, the built-in gen_image.py; Claude then LOOKS at the PNG with its own vision and critiques/refines it over ≥2 ENFORCED rounds. The approved PNG is then redrawn as a native editable SVG by ts-figure-svg — its design language learned, its content re-derived from the paper, audited and repaired over ≥4 measured rounds (never a pixel trace); if that is impossible the ts-figure-optimize DrawAI HYBRID or the approved PNG is kept — never a lossy redraw, PNG always kept. Engine is routed by SECTION: only real measured-data results plots (data-aware mode, results section) use matplotlib; EVERY other figure — architecture/pipeline/concept/math-geometry/schematic — is image-model rendered (so in proposal mode every figure is image-model). In proposal mode quantitative results plots are SKIPPED (no real data — drawing one fabricates results). Use to turn the empty \fbox placeholders into publication-quality figures.

ts-paper-figure — figures: PaperBanana renders it, ts-figure-svg makes it a real figure

PaperBanana makes good academic figures with a team of LLM agents (Retriever → Planner → Stylist → Visualizer → Critic) running a critique-and-refine loop. Two ways to drive it here:

  • Preferred — the official pipeline. python3 ../ts-figure-svg/scripts/setup_paperbanana.py pulls dwzhu-pku/PaperBanana and you call its own skill/run.py (step 3). Upstream code, upstream agents.
  • Fallback — the distilled loop. With no PaperBanana key configured, every step except drawing pixels is LLM reasoning + vision, which Claude does natively: Claude is the Planner/Stylist/Critic and one tiny script (gen_image.py) is the Visualizer.

Either way the PNG is not the deliverable — it is the design target. Step 5b redraws it as a native, editable, audited SVG (ts-figure-svg), because a render's labels are pixels and a paper figure's must not be.

Three things make this a SKILL and not just "Claude drawing a flowchart" — NEVER skip them: (C1) DESIGN a concrete, rich visual blueprint (step 2) instead of an abstract box list; (C2) GROUND every free-form figure in a real on-topic MAIN journal figure (step 2b) — Claude WebSearches for a TOP/MID-venue on-topic paper, fetches its MAIN figure, and passes it as an image-condition (/images/edits) plus convention guidance — mandatory, gate-enforced, no silent skip; (C3) ENFORCE a logged multi-round vision critique (steps 4–5, gated). The default aesthetic is rich & concrete (real imagery, layered tensors, coordinated panels) — never a flat thin-line flowchart. (Without C1–C3 the figures regress to the sparse boxes-and-arrows this redesign fixed.)

The only code: scripts/gen_image.py

It does one thing — send a prompt to an external image model, save a PNG. Configure the image model only:

export TS_FIG_MODEL="gpt-image-2"          # ← the image model (default gpt-image-2); from the repo .env
export TS_FIG_API_KEY="<image api key>"
export TS_FIG_BASE_URL="<openai-compatible base>"  # e.g. https://api.openai.com/v1
export TS_FIG_API_STYLE="images"           # or "chat" for nano-banana-style gateways
export TS_FIG_SIZE="1536x1024"             # QUALITY: landscape, mirrors the product's default (not 1024x1024)
export TS_FIG_QUALITY="high"               # gpt-image-* quality knob (the product used "high")

⛔ MODEL POLICY — do NOT pick a model yourself. The image model is whatever TS_FIG_MODEL says (set in the repo-root .env; default gpt-image-2). Never substitute, downgrade, or guess a model (e.g. do NOT fall back to gpt-image-1), and never improvise the key (use TS_FIG_API_KEY, not OPENAI_API_KEY). If TS_FIG_MODEL/TS_FIG_API_KEY/TS_FIG_BASE_URL are unset, gen_image.py returns unset env: … — STOP and ask the user to set them in .env; do not export a model of your own choice. Note: TS_FIG_SIZE/TS_FIG_QUALITY take effect only in images API style (TS_FIG_QUALITY only for gpt-image-* models); in chat style the gateway controls resolution, so verify the render size in the critique loop and re-render if crude. (scaffold in scripts/figure_config.example.sh — copy to figure_config.sh, fill, source it.) Text planning and critique need no config — they are Claude. Quality matters: render at 1536x1024 quality=high (the defaults above), give a detailed prompt, and do a real refine pass — a 1024×1024 low-effort render looks crude.

Two figure engines, routed by SECTION (matplotlib only for results-section data plots)

The engine is decided by which section the figure lives in, NOT by its type — because matplotlib only looks good for real-data plots and renders concept/schematic figures poorly (the "ugly matplotlib figure" complaint this routing fixes):

  • matplotlib — ONLY for a real measured-data results plot in the results/experiments section (../ts-paper-data/scripts/plot_results.py --script, figures4papers house style auto-applied — see ts-paper-data/references/plot-style.md). This is the one place exact-from-values plotting is needed: a results bar/line/heatmap/radar built from real numbers in results.facts.json, so only in data_aware mode. Born vector: the plot script MUST end with finalize(fig, OUT) and MUST NOT call plt.savefig() itself — finalize writes the PNG and a vector figures/<label>.pdf (editable text via svg.fonttype=none). In proposal mode there are no real numbers, so a results plot must NOT exist — if one slipped through, remove the float (never leave a blank \fbox, never fabricate/stub). Removing such a float does NOT violate the no-blanks rule: a results placeholder is illegitimate in proposal mode and should never have been emitted, so never render a substitute.
  • image model — EVERY OTHER figure, in every other section (gen_image.py + GROUND + the vision-critique loop below): architecture / pipeline / framework / flow diagrams, qualitative scenes, icon schematics, AND every concept / math-geometry illustration (a distribution, manifold, trajectory, loss-curve shape, 3D geometry). These used to go to matplotlib and came out ugly — they are now DESIGNED + GROUNDED + image-model-rendered + ≥2-round vision-critiqued. (A concept illustration makes no real-metric claim and is grounding-OPTIONAL — ground it on a clean on-topic concept figure if one exists, else treat it like a qualitative scene.) After the PNG is approved, it is redrawn as a native editable SVG by the sibling ts-figure-svg skill (step 5b — design language learned from the render, content re-derived from the paper, ≥4 audited repair rounds, no key needed). Fall back to ts-figure-optimize's DrawAI HYBRID, then to keeping the PNG.
    • 🔴 HARD RULE — the redraw is DOWNSTREAM of generation, never instead of it. A free-form figure is ALWAYS produced by the image model first (steps 2→2b→3→4: rich DESIGN + GROUND on a top-journal MAIN figure + render + ≥2 critique rounds). You must NEVER hand-author an SVG straight from the text with no render — that yields exactly the flat boxes-and-arrows regression this design removes, a HARD violation. The manifest engine of a free-form figure is always image-model or paperbanana (never svg-native); check_figure_critique FAILS the build otherwise. Step 5b's SVG is a redraw of an approved render, recorded as svg_redraw alongside that engine — a different thing entirely.
    • If the image MODEL itself is unconfigured (gen_image.py returns unset env: TS_FIG_*): this is a CREDENTIAL gap, handled at the orchestrator Preflight — ASK the user whether to generate figures (it needs TS_FIG_API_KEY / TS_FIG_BASE_URL / TS_FIG_MODEL, e.g. gpt-image-2). If they decline → skip the free-form figures (leave their placeholders, note in logs/6_figure.io.md); matplotlib results/concept plots still run (no key). Never substitute a hand-drawn diagram or improvise a key.

This unifies the suite's two figure-craft sources — figures4papers (matplotlib) for results-section data plots, PaperBanana (image model) for everything else. NET: in data_aware mode only the results-section data plots are matplotlib; every other figure is image-model. In proposal mode there are no data plots, so EVERY figure is image-model. The figure floor (figures.min) is met by both kinds, and every placeholder ends rendered — no blanks. Both engines then end on an editable VECTOR PDF: every figure ends as figures/<label>.pdf (the embedded vector), with the original figures/<label>.png and its source (.plot.py for matplotlib, .svg for a redrawn figure) kept alongside. matplotlib is born-vector; an image-model raster becomes a native SVG via ts-figure-svg (design language learned, content redrawn from the paper, audited) — falling back to ts-figure-optimize's DrawAI HYBRID, then to keeping the approved PNG. No path may reduce the figure's quality.

Procedure — the distilled Planner→render→Critic→refine→insert loop

Run after review (stage 5), before latex (stage 7). For EACH \begin{figure} placeholder in sections/*.tex that still has an \fbox{\rule…} (no \includegraphics yet):

  1. Classify + route by SECTION (Critic's first job). Read %% FIGURE-SPEC type=…, %% DESC:, the caption, and which section the placeholder is in, then pick the engine:
    • Real-data results plot, in the results/experiments section (data_aware only): write a self-contained matplotlib script figures/<label>.plot.py embedding the real numbers from results.facts.json (grouped_bar for the main comparison, line for a sweep, bar for ablation deltas), run python3 ../ts-paper-data/scripts/plot_results.py --script figures/<label>.plot.py --out figures/<label>.png, then Read the PNG to vision-check (labels legible, no clipped bars, right metric), fix the script if needed, then go to step 6 (Insert). proposal mode → remove the float (no data). This is the ONLY matplotlib path.
    • EVERY other figure — architecture/pipeline/framework/flow schematic, qualitative scene, AND any concept / math-geometry illustration (distribution, manifold, trajectory, loss-curve shape, 3D shape): continue to step 2 (the gen_image.py Planner→render→Critic→refine loop). A concept/math-geometry figure is illustrative (no real-metric claim) and grounding-OPTIONAL, but is still IMAGE-MODEL — never matplotlib (check_figure_critique FAILS a matplotlib figure outside the results section). The image-model path always runs the vision-critique loop. Either way, no placeholder is left blank.
  2. DESIGN the figure, then write the prompt (Planner + Stylist). Adopt the lens of a Lead Visual Designer for a top-tier venue (NeurIPS/CVPR/TGRS). FIRST sketch a concrete VISUAL BLUEPRINT (in your reasoning): for each position in the figure decide WHAT concrete thing appears — real imagery, a data/result panel, a layered-tensor network block, a depicted icon — not just a labelled box — and wire the data flow from the equations (below). THEN write a single, self-contained image-generation prompt that realises that blueprint

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