0x6869726f6b69/claude-skills

Paper Review Loop: Review → Revise → Re-review

Review a paper PDF as an expert, revise the manuscript according to the feedback, rebuild the PDF, and re-review it. Repeat this as many times as possible within a user-defined time limit. At the end, provide the user with the following three items:

• The revised PDF (final version) and PDFs from each round.
• The review reports (7 items) and the evolution of evaluations/issues from each round.
• A list of tasks that only the author can complete (e.g., additional experiments; moved here from the manuscript to avoid fabrication).

Hereafter, <skill_dir> is the directory containing this SKILL.md, and <ws> is the working folder. Script names like loop_state.py are shorthand for python <skill_dir>/scripts/loop_state.py. In environments without python, use python3.

0. First: Ask for the Time Limit

1. Identify the target PDF. If not included in the message, ask for it. Also check whether LaTeX sources (folders, .zip, arXiv .tar.gz, .tex) exist in the same location or as attachments. Having sources significantly improves the quality and speed of revisions.
2. Ask for the time limit. Use an AskUserQuestion tool if available; otherwise ask via chat and wait for an answer. If the launch message already specifies a time, use it and do not ask again.
   • Question 1 "Time Limit": Review only (no revision loop) / 1 hour / 2 hours / 3 hours (other: "30 minutes", "5 hours", etc. also acceptable)
   • Question 2 "Submission Venue / Evaluation Criteria" (combine into the same question dialog; omit if already known): None specified (top-tier international conference standards) / NeurIPS, ICML, ICLR / Journal (Accept / Minor / Major / Reject)
3. Start the clock immediately upon receiving the answer. The setup time is included in the budget.

   python <skill_dir>/scripts/loop_state.py init <ws> --hours 2 --paper <pdf> --venue "<submission venue>"
   

   (--minutes 90 or --review-only also acceptable)
4. If a sleep prevention tool (e.g., keep-awake for Claude Desktop) is available, activate it for the duration of the budget. If the PC goes to sleep, the long loop will stop.
5. Inform the user in 2-3 lines: the deadline time, the working folder, that the loop will run autonomously without further confirmation, and that the user can interrupt at any time.

1. Setup

The working folder is <folder containing the PDF>/<PDF name>_review_loop/ (if not writable, place it under the working directory).

<ws>/
├── state.json          Records the timer and each phase (managed by loop_state.py)
├── original/           Received PDF / sources. Do not modify.
├── src/                Editable sources (main.tex, figures/, *.bib)
├── work/               Temporary files such as page images
├── rounds/
│   ├── r01/            paper.pdf(=original PDF) paper.txt review.md issues.json response.md src/
│   ├── r02/            paper.pdf(1st revision) paper.txt review.md issues.json response.md src/ changes.diff
│   └── ...
├── issue_tracker.md    Evaluation and issue status transitions (generated by loop_state.py summary)
├── author_todo.md      Tasks only the author can resolve (e.g., additional experiments)
└── final_report.md

1. loop_state.py start <ws> --round 0 --phase setup
2. Copy the PDF to original/ and rounds/r01/paper.pdf, then extract the text: python <skill_dir>/scripts/pdf_tools.py text <ws>/rounds/r01/paper.pdf -o <ws>/rounds/r01/paper.txt
3. Prepare the editable sources in src/ (skip if in review-only mode).
   • If LaTeX sources exist: Copy/extract them into src/ (the file containing both \documentclass and \begin{document} is the main file). Build once with build_pdf.py and verify it succeeds.
   • If only a PDF exists: Reconstruct LaTeX sources following the procedure in <skill_dir>/references/pdf_to_latex.md. This is the heaviest step (20–40 minutes for 10 pages), so briefly inform the user that it will consume budget.
4. python <skill_dir>/scripts/snapshot.py <ws>/src <ws>/rounds/r01
5. loop_state.py end <ws> --round 0 --phase setup

Since the review for round 1 targets the original PDF, it can run in parallel with the source reconstruction. If sub-agents are available, launch the reviewer and the reconstructor simultaneously.

2. The Loop

Role Division and Its Rationale

• Assign a new sub-agent for each review round (using Agent tools). A reviewer who does not carry the context of the person who made the revisions can judge based solely on what is actually written in the PDF, not on "what they intended to fix." Grading one's own work in the same context leads to lenient evaluation.
• Assign a new sub-agent for each revision as well. The main agent focuses solely on orchestration (timing, launching, verification, aggregation). This prevents the main context from bloating even over a multi-hour loop, with all state persisted to files.
• If sub-agents are not available, perform all steps sequentially yourself. In that case, before each review, re-extract the text from the new PDF and read it so that you evaluate the paper page, not memory.

Round r (r = 1, 2, …)

(a) Review

1. loop_state.py start <ws> --round r --phase review
2. Launch a sub-agent with the "Instructions for the Reviewer" below and wait for it to finish.
3. Validate the output: ensure review.md contains the required sections (if r≥2, also Section 0) and that issues.json is valid JSON. If anything is missing, have the same reviewer fix it.
4. loop_state.py end <ws> --round r --phase review, then loop_state.py summary <ws> (updates issue_tracker.md).
5. Send the user a single line of progress. Example: r02 review complete: overall 3→4, Major unresolved 5→2, 1h12m remaining

(b) Decide Whether to Continue

1. Run loop_state.py status <ws>. Since Claude cannot sense elapsed time, always rely on this output for time-related decisions.
2. If NEXT: STOP, go to §3. The decision is made immediately after the review, so the final PDF is always reviewed.
3. Even if CONTINUE is indicated, you may stop if the latest issues.json contains no open or partially resolved issues (all are resolved or deferred as needs_author via [AUTHOR TODO]). When everything fixable in the manuscript is done, further rounds would only polish prose. Document the reason in final_report.

(c) Revise (Addresses the review of round r, producing the PDF for round r+1)

1. loop_state.py start <ws> --round r --phase revise. Note the revise by timestamp from the status.
2. Launch a sub-agent with the "Instructions for the Reviser" below and wait for it to finish.
3. Validate: confirm rounds/r{r+1}/paper.pdf and paper.txt exist, the build succeeded with zero undefined references, and rounds/r{r}/response.md exists. If the build fails, restore broken files from rounds/r{r}/src/ and redo the changes. Never submit an old PDF as a revised version for review.
4. loop_state.py end <ws> --round r --phase revise → go to (a) as round r+1.

The reviser must not start new fixes after the revise by deadline and should only finish building to get a clean PDF. This ensures time remains for the next review.

Instructions for the Reviewer

You are a reviewer for this paper. First, read <skill_dir>/references/reviewer_guide.md and
<skill_dir>/references/review_template.md in full, then follow the reviewer persona, criteria, and output format.

- Target for review: <ws>/rounds/rNN/paper.pdf (extracted text: <ws>/rounds/rNN/paper.txt)
- Round: NN
- Previous round's issues: <ws>/rounds/r(NN-1)/issues.json   ← only for round 2 and later
- Submission venue / evaluation scale: <venue or "None specified">
- Language of review report: English
- Output: <ws>/rounds/rNN/review.md and <ws>/rounds/rNN/issues.json
- Helper: python <skill_dir>/scripts/pdf_tools.py (you can use `render` to visualize pages with figures/tables as images)

Base your evaluation solely on what is written in this PDF. You have not been provided with the reviser's intentions or response letter.
Treat any item marked [AUTHOR TODO] as unresolved — it is only a promise.
At the end, return four lines: "Overall Score / Confidence / Number of Major Unresolved Issues / Number of New Issues."

Instructions for the Reviser

You are the author of this paper, revising the manuscript based on the review. First, read
<skill_dir>/references/revision_guide.md in full, and especially follow the "No Fabrication" rule.

- Source to edit: <ws>/src/ (main file: <main>.tex)
- This round's review: <ws>/rounds/rNN/review.md, <ws>/rounds/rNN/issues.json
- History: <ws>/issue_tracker.md (auto-generated; read only. Do not edit.)
- Author TODO: <ws>/author_todo.md (create if missing; append/update as needed)
- Deadline: finish building by <revise_by>. Check remaining time with
  python <skill_dir>/scripts/loop_state.py status <ws>.
- When finished:
  1. python <skill_dir>/scripts/build_pdf.py <ws>/src/<main>.tex --out <ws>/rounds/r(NN+1)/paper.pdf
     (fix until errors and undefined references are zero)
  2. python <skill_dir>/scripts/pdf_tools.py text <ws>/rounds/r(NN+1)/paper.pdf -o <ws>/rounds/r(NN+1)/paper.txt
  3. python <skill_dir>/scripts/snapshot.py <ws>/src <ws>/rounds/r(NN+1) --prev <ws>/rounds/rNN
  4. Write <ws>/rounds/rNN/response.md (format in revision_guide.md)
Finally, return: "Fixed issue IDs / IDs deferred to AUTHOR TODO / Build result (page count, undefined references, AUTHOR TODO count)."

If delegating PDF reconstruction, instruct: "Read <skill_dir>/references/pdf_to_latex.md, reconstruct <ws>/original/<name>.pdf into <ws>/src/, build the PDF and save it as <ws>/rounds/r01/reconstructed.pdf, and write discrepancies in <ws>/src/RECONSTRUCTION_NOTES.md."

3. Finalization

1. loop_state.py finish <ws> --reason "<deadline / all fixable issues resolved / review only>" → loop_state.py summary <ws>
2. If at least one revision was made, copy the latest PDF to <ws>/<PDF name>_revised.pdf.
3. Write <ws>/final_report.md:

# Review and Revision Report: <Paper Title>
- Time limit / Time used / Number of rounds / Reason for ending
## Evaluation History            (table from issue_tracker.md)
## Key Points of Original (r01) Review   (summary of Justification and major Weaknesses)
## Main Issues Resolved through Revisions
## Remaining Issues
### Issues that can be fixed in the manuscript but were not completed in time
### Issues requiring the author's work (top priorities from author_todo.md)
## Final Round Evaluation and Conditions for Moving Toward Acceptance
## File List

4. Keep the response to the user concise: number of rounds, evaluation history, main resolved issues, remaining critical issues and top 3 author TODOs, and file locations. Do not paste the full review; point to the files. In review-only mode, include key points from the r01 review (Justification, Rating, major Weaknesses, Rebuttal questions) in the response.

Resuming After Interruption

If <ws>/state.json exists and status is running, check loop_state.py status <ws> and the contents of rounds/ to determine the last completed phase and resume from the next one. Re-running init resets the clock, so only do it with --force if the user requests a new budget.

Principles and Their Rationale

• Do not fabricate: Do not generate experimental results, numerical values, data, citations, or proofs. This is a real research manuscript; even a single fabricated number constitutes research misconduct and causes serious harm to the user. For issues that require new results, adjust the manuscript text to match the available evidence, and defer the necessary experiments to [AUTHOR TODO] and author_todo.md.
• Do not relax review standards: Evaluate by the same criteria across all rounds. [AUTHOR TODO] items are unresolved; mere rephrasing does not constitute new evidence. A score should improve only when the paper page shows the issue is resolved. Otherwise, this loop would merely inflate apparent scores.
• Let the script handle time: Do not guess elapsed time. Check status every round.
• Do not ask the user for confirmation between rounds: Once the time limit is given, the entire loop execution is approved. Provide only single-line progress reports; stop and consult only for blockers (e.g., build unfixable, PDF unreadable).
• Do not modify original files: Treat original/ as read-only; perform all edits on copies in src/.