PluginBench
Skill
Review
Audit score 70

paper-assembly

lingzhi227/agent-research-skills

Orchestrate end-to-end paper pipelines with state management, checkpointing, and phase dependencies.

What is paper-assembly?

Manages the complete research paper workflow from literature review through final PDF compilation. Tracks state across 11 phases (literature, planning, code, experiments, figures, tables, writing, citations, formatting, compilation, review), supports checkpointing for resumption, and enforces quality gates between phases.

  • Scans paper directory and identifies which pipeline phases are complete vs. pending
  • Builds dependency graphs and executes phases in correct order
  • Propagates state and artifacts between downstream phases automatically
  • Saves checkpoints after each phase for resumption capability
  • Validates consistency (cited keys in bibliography, figure references, experimental traceability)
  • Merges sections into final LaTeX and compiles to PDF

How to install paper-assembly

npx skills add https://github.com/lingzhi227/agent-research-skills --skill paper-assembly
Prerequisites
  • Paper project directory structure
  • Python environment with assembly_checker.py available
  • Completion of upstream phases (literature, planning, code) before running downstream phases
Claude Code
Cursor
Windsurf
Cline

How to use paper-assembly

  1. 1.Run assembly_checker.py on your paper directory to assess current state and identify completed vs. pending phases
  2. 2.Review the checkpoint JSON output to understand dependencies and next steps
  3. 3.Execute pipeline phases in dependency order using the referenced skills (literature-search, research-planning, experiment-code, etc.)
  4. 4.After each phase completes, save outputs to the paper directory and verify quality gates pass
  5. 5.Use checkpoint files to resume interrupted workflows at the last completed phase
  6. 6.Merge all sections into main.tex, verify all \includegraphics and \cite references exist, then compile to PDF

Use cases

Good for
  • Assembling a multi-phase research paper where experiments, figures, and writing are developed separately
  • Resuming a paper project mid-pipeline after interruption using checkpoint files
  • Coordinating work across multiple AI agents or human-AI collaboration at phase boundaries
  • Ensuring all paper numbers trace back to actual experiment logs and results
  • Managing complex dependencies between literature review, code, experiments, and writeup
Who it's for
  • Researchers writing papers with experimental components
  • AI agents orchestrating multi-phase research workflows
  • Teams using human-in-the-loop review at phase boundaries
  • Projects requiring reproducibility and artifact traceability

paper-assembly FAQ

Can I skip phases or run them out of order?

No. The skill enforces sequential execution because each phase depends on outputs from previous phases. Skipping breaks the dependency chain.

What happens if I modify an upstream phase after completing downstream work?

You must re-run all downstream phases affected by the change. The checkpoint system helps track which phases need re-execution.

How do I resume a paper after interruption?

Load the checkpoint JSON file from your last completed phase. The assembly_checker.py will identify where you left off and suggest next steps.

Does this skill actually run the experiments or just orchestrate?

It orchestrates and coordinates; actual experiments are run by the experiment-code and experiment-design skills. This skill manages state flow between them.

What quality gates are enforced between phases?

Verification that required outputs exist, consistency checks (e.g., all \cite keys in .bib), and validation that figures/tables match experimental results.

Full instructions (SKILL.md)

Source of truth, from lingzhi227/agent-research-skills.


name: paper-assembly description: Orchestrate the full paper pipeline end-to-end. Manage state propagation between phases (literature → plan → code → experiments → figures → tables → writing → review), support checkpointing and resumption. Use for assembling a complete paper from components. argument-hint: [paper-directory]

Paper Assembly

Orchestrate the entire paper pipeline end-to-end with state management and checkpointing.

Input

  • $0 — Paper project directory or paper plan

References

  • Orchestration patterns and state management: ~/.claude/skills/paper-assembly/references/orchestration-patterns.md

Scripts

Check pipeline completeness

python ~/.claude/skills/paper-assembly/scripts/assembly_checker.py --dir paper/ --output checkpoint.json
python ~/.claude/skills/paper-assembly/scripts/assembly_checker.py --dir paper/ --verbose

Scans paper directory, checks 9 pipeline phases, reports missing artifacts, suggests next steps.

Workflow

Step 1: Assess Current State

  1. Scan the paper directory for existing artifacts
  2. Identify which phases are complete vs pending
  3. Build a dependency graph of remaining work

Step 2: Execute Pipeline Phases

Run phases in dependency order:

PhaseSkillInputOutput
1. Literatureliterature-search, literature-reviewTopicKnowledge base, BibTeX
2. Planningresearch-planningKnowledge basePaper structure, task list
3. Codeexperiment-codePlanTraining/eval pipeline
4. Experimentsexperiment-designCodeResults JSON/CSV
5. Figuresfigure-generationResultsPNG figures
6. Tablestable-generationResultsLaTeX tables
7. Writingpaper-writing-sectionAll abovemain.tex sections
8. Citationscitation-managementDraftreferences.bib
9. Formattinglatex-formattingDraftFormatted LaTeX
10. Compilationpaper-compilationAllPDF
11. Reviewself-reviewPDFReview scores

Step 3: State Propagation

After each phase completes:

  1. Save output artifacts to the paper directory
  2. Propagate results to downstream phases
  3. Update the progress checkpoint file

Step 4: Quality Gates

Before proceeding to the next phase:

  • Verify all required outputs exist
  • Check for consistency (e.g., all cited keys in .bib)
  • Validate figures/tables match experimental results

Step 5: Final Assembly

  1. Merge all sections into main.tex
  2. Verify all \includegraphics files exist
  3. Verify all \cite keys exist in .bib
  4. Compile to PDF
  5. Run self-review for quality check

Orchestration Patterns

Sequential Pipeline (AI-Scientist)

generate_ideas → experiments → writeup → review

Multi-Agent State Broadcasting (AgentLaboratory)

# Propagate results to all downstream agents
set_agent_attr("dataset_code", code)
set_agent_attr("results", results_json)

Copilot Mode (AgentLaboratory)

Human can intervene at any phase boundary for review/correction.

Checkpoint Format

{
  "project": "paper-name",
  "phases_completed": ["literature", "planning", "code"],
  "current_phase": "experiments",
  "artifacts": {
    "literature": "knowledge_base.json",
    "plan": "research_plan.json",
    "code": "experiments/",
    "results": null
  },
  "last_updated": "2024-01-15T10:30:00Z"
}

Rules

  • Never skip phases — each depends on previous outputs
  • Save checkpoints after every phase completion
  • Human review is recommended at phase boundaries
  • All numbers in the paper must trace to actual experiment logs
  • Re-run downstream phases if upstream changes

Related Skills

  • Upstream: all other skills (this is the orchestrator)
  • Downstream: paper-compilation, self-review
  • See also: research-planning