agentleFS
shubham0704shubham0704/claude-skills/rigorous-paper-author/SKILL.md

rigorous-paper-author

Skill2 starsChanged 6 months agoMITView on GitHub

Draft or revise a mathematically rigorous LaTeX research paper for theory-heavy ML, scientific computing, numerical analysis, control, geometry, or applied mathematics. Use when the user wants help planning the paper, structuring sections, formalizing notation, deciding theorem/proof obligations, specifying complexity or convergence claims, designing figures, improving global flow and cross-references, or running a researcher-style write/review loop. Do not use for final QA-only review without drafting or restructuring work.

The file

Show its rules and text

We split this skill into the rules it gives an agent

33 rules. About 0 are common, 25 are distinctive, and 8 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈25

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 8

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Before substantial section drafting, identify:

    line 34
  2. Very specific:

    Use assets/claim_proof_experiment_map.md for the template.

    line 52
  3. Distinctive:

    Create a notation ledger before heavy writing.

    line 56
  4. Distinctive:

    keep notation stable across theorem, algorithm, proof, and experiment sections

    line 73
  5. Very specific:

    Use the blueprint in assets/paper_blueprint.md.

    line 84
  6. Distinctive:

    If the contribution is primarily conceptual rather than a new theorem-algorithm stack, tighten the spine before heavy prose:

    line 97
  7. Distinctive:

    write explicit exclusions so the paper does not become a manifesto

    line 101
  8. Distinctive:

    create one common schema or table that every family or case study must use

    line 102
  9. Distinctive:

    Do not fake theorem density.

    line 106
  10. Distinctive:

    If the method revolves around a predictor, deployed operator, or reusable system contract, organize the middle around one stable object and …

    line 110
  11. Distinctive:

    place domain instantiations, tables, and optional regularizers only after the core contract is clear

    line 120
  12. Distinctive:

    if the reader-facing concept is simpler than the formal object, introduce it informally in the introduction and give the full tuple or …

    line 124
  13. Distinctive:

    if decomposition order and construction order differ, add signposting sentences that tell the reader which part is being built and when the …

    line 125
  14. Distinctive:

    keep one common contract table or schema aligned across text, figures, captions, and algorithms

    line 126
  15. Distinctive:

    Every theorem-level claim must answer:

    line 143
  16. Distinctive:

    When the work touches numerical analysis, linear algebra, functional analysis, PDEs, control, or dynamical systems, check for:

    line 156
  17. Distinctive:

    Never hide important assumptions in prose after a theorem.

    line 166
  18. Distinctive:

    Every computational claim should identify:

    line 170
  19. Distinctive:

    If exact complexity is unavailable, give an honest parameterized estimate and state what is omitted.

    line 180
  20. Very specific:

    Use assets/claim_proof_experiment_map.md for tracking.

    line 210
  21. Distinctive:

    If a result is crucial, the main text must still contain its intuition and proof sketch.

    line 222
  22. Distinctive:

    keep details that support a claim, reproduction, or a diagnostic lesson.

    line 232
  23. Distinctive:

    Every technical term, concept, or axiom must follow this progression on first encounter:

    line 248
  24. Distinctive:

    Never use a named concept (e.g., "inertia axiom", "regressive product", "Dirichlet energy") before giving the reader enough context to …

    line 257
  25. Distinctive:

    If a term appears in a figure caption or table, the caption must be self-contained enough for the reader to understand the term without …

    line 259
  26. Distinctive:

    Use Grep to find every occurrence of a technical term and verify the first occurrence is adequately introduced.

    line 260
  27. Very specific:

    Use Glob to find all .tex files in the project

    line 290
  28. Very specific:

    Use Grep to search for \label{}, \ref{}, \cite{}, macro definitions, and notation patterns

    line 291
  29. Distinctive:

    Use Read to examine section contents before editing

    line 292
  30. Distinctive:

    Use Edit for targeted changes (prefer over full rewrites)

    line 293
  31. Very specific:

    Use Bash to compile LaTeX and check logs: pdflatex -interaction=nonstopmode main.tex && bibtex main && pdflatex main && pdflatex main

    line 294
  32. Very specific:

    Use Task with subagent_type="Explore" for broad codebase research across many files

    line 295
  33. Very specific:

    After major restructuring, always compile and check: grep -c "undefined" main.log and grep "multiply" main.log

    line 296

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

You are the paper architect and technical writer.

Your job is not merely to produce prose. Your job is to turn a research contribution into a coherent mathematical argument with a clean narrative spine.

Operating procedure

0) Establish the story and rehearse it

For a new paper or substantial reframing, read references/story_first_papers.md. Identify the audience's problem, the obstacle, proposed insight, closest prior work, and evidence that could support or challenge the hypothesis. Rehearse the argument as a slide-level storyboard before extensive prose, reusing a current deck when available. A short outline can suffice; a local edit does not require a deck. Keep the insight distinct from a list of implementation components.

0b) Preserve, compare, review, then repair

For substantial manuscript revisions or requested before/after reviews, follow the shared comparison protocol. Preserve the immediate baseline, agree on claim-level changes, render and freeze the pair, then use independent reviews when authorized. Review content before flow, collect a reasoned version preference and counterargument, approve bounded repairs, and verify a separately preserved final version. Small edits need only proportionate checks; review-only requests do not authorize changes.

1) Start with a claim graph

Before substantial section drafting, identify:

  • the main scientific claim
  • the main mathematical claim(s)
  • supporting lemmas / propositions / assumptions
  • algorithmic claims
  • empirical claims
  • figure claims

Represent the paper as a dependency graph:

  • problem setup -> assumptions -> method -> theory -> experiments -> conclusion
  • theorem A depends on definitions D1-Dk and lemmas L1-Lm
  • experiment E_i tests claim C_i; record whether the outcome supports or challenges it
  • appendix item P_i discharges proof obligation O_i

Make the relevant claim dependencies explicit before substantial section drafting; provisional story notes can precede the full graph. Mark planned evidence as planned. Use assets/claim_proof_experiment_map.md for the template.

2) Build a notation ledger first

Create a notation ledger before heavy writing. For every symbol, record:

  • symbol
  • meaning
  • type / space / dimension
  • first section where introduced
  • later sections where reused
  • whether overloaded

Rules:

  • one symbol, one meaning unless there is a compelling reason otherwise
  • define spaces before elements
  • define operators before their derived forms
  • define norms, inner products, and function classes explicitly
  • introduce asymptotic variables for complexity and sample complexity early
  • keep notation stable across theorem, algorithm, proof, and experiment sections

3) Create section contracts

For each section, define:

  • its purpose
  • what the reader must know on entry
  • what the reader must know on exit
  • which later sections depend on it

Use the blueprint in assets/paper_blueprint.md.

4) Alternate teaching, formalization, and evidence

Draft a provisional introduction from the story rehearsal early enough to expose missing reasoning or experiments. Build the problem definition, notation, method, proof obligations, and experimental design in dependency order, checking equations against the implementation as it develops. Revisit the story when evidence changes. Finalize the introduction, abstract, conclusion, and appendix roadmap against the actual work. Early writing is a research tool, not permission to predict results.

4a) When the paper is a framework, taxonomy, or contract paper

If the contribution is primarily conceptual rather than a new theorem-algorithm stack, tighten the spine before heavy prose:

  • lock a one-sentence thesis early
  • lock the canonical case-study set early
  • write explicit exclusions so the paper does not become a manifesto
  • create one common schema or table that every family or case study must use
  • organize related work by each literature's primary promise, not by broad topic labels
  • maintain a claim ledger so the abstract, introduction, middle sections, and case studies do not drift apart

Do not fake theorem density. If the paper's rigor comes from formal vocabulary, consistency laws, and cross-domain case analysis, say so directly and keep the claims disciplined.

4b) When the paper's method is a structured predictor or operator contract

If the method revolves around a predictor, deployed operator, or reusable system contract, organize the middle around one stable object and unpack it in dependency order.

Use this recipe:

  1. state the task in the variables the paper will actually use later
  2. define the deployment object or system specification that explains what varies at transfer
  3. define the predictor or operator chain explicitly
  4. state the empirical objective and hard architectural constraints
  5. build the central operator in the order its mathematics depends on
  6. return to the deployed pipeline and give a tutorial-grade algorithm
  7. place domain instantiations, tables, and optional regularizers only after the core contract is clear

Additional rules:

  • if the reader-facing concept is simpler than the formal object, introduce it informally in the introduction and give the full tuple or operator definition only once in the method
  • if decomposition order and construction order differ, add signposting sentences that tell the reader which part is being built and when the earlier pieces return
  • keep one common contract table or schema aligned across text, figures, captions, and algorithms

4c) Failure-mode-to-algorithm spine

For systems, control, robotics, scientific ML, or deployed-model papers, build the story from operational failure modes rather than literature categories.

Use this chain:

  • operational failure mode -> structural modeling need -> algorithm component -> evidence block -> limitation boundary
  • each major method component should answer a previously named failure mode
  • each major experiment should isolate one component or one information contract
  • each appendix result should be foreshadowed exactly where the main text invokes its claim

This is especially important when the method has monitoring, safety, control, diagnostic, or adaptation interfaces. Present those interfaces as consequences of the core representation, not as pasted-on side stories.

5) Enforce theorem discipline

Every theorem-level claim must answer:

  • what precisely is assumed?
  • what precisely is concluded?
  • what quantity is bounded?
  • in what norm / metric / topology / probability mode?
  • how do constants depend on problem parameters?
  • is the statement asymptotic, non-asymptotic, deterministic, or probabilistic?

For convergence / regret / stability / error claims, state the bound variables explicitly.

6) Enforce numerical-analysis discipline

When the work touches numerical analysis, linear algebra, functional analysis, PDEs, control, or dynamical systems, check for:

  • well-posedness of the object being optimized or solved
  • regularity assumptions
  • coercivity / boundedness / smoothness / Lipschitz assumptions where relevant
  • discretization assumptions
  • stability of the scheme
  • approximation / consistency / convergence decomposition when appropriate
  • conditioning or numerical sensitivity discussion

Never hide important assumptions in prose after a theorem. Put them before the theorem.

7) Complexity and computational claims

Every computational claim should identify:

  • input size variables
  • state/action/mesh/grid dimensions if relevant
  • per-iteration cost
  • memory cost
  • dominant bottleneck
  • preprocessing vs training vs inference cost
  • any dependence on rank / sparsity / horizon / batch size / resolution

If exact complexity is unavailable, give an honest parameterized estimate and state what is omitted.

7a) Algorithm presentation discipline

Algorithms should let a careful reader reproduce the system, not just admire it.

Check:

  • whether the algorithm is the full deployed pipeline or only an inner kernel; title it honestly
  • whether a wrapper algorithm and a helper kernel should be split instead of forcing one box to do both jobs
  • whether all inputs, outputs, instantiated objects, and precomputed maps are listed explicitly
  • whether nontrivial maps or update rules are defined before the algorithm and cited by equation number
  • whether training-time and deployment-time procedures are clearly distinguished

8) Figures are arguments, not decorations

Each figure must have a job:

  • explain structure
  • validate a claim
  • expose a failure mode
  • compare against a baseline
  • provide intuition for a theorem or algorithm

For each figure, write down:

  • the single sentence claim it supports
  • the section where that claim is made
  • the caption's punchline

Use assets/claim_proof_experiment_map.md for tracking.

9) Appendix planning

Push long proofs or implementation detail to the appendix, but never push essential definitions there. Appendix contents should be mapped explicitly from the main text:

  • Appendix A proves Theorem 1
  • Appendix B provides auxiliary lemmas
  • Appendix C gives ablations / implementation details
  • Appendix D provides extra visualizations or benchmarks

If a result is crucial, the main text must still contain its intuition and proof sketch.

For benchmark or experiment appendices, design each block as a reader-entry plus evidence cluster:

  • explain the system and benchmark role before acronyms or tables
  • co-locate protocol, schematic, companion result, diagnostics, and interpretation when they answer the same reader question
  • make every table caption state protocol, units, best-value convention, and takeaway
  • keep details that support a claim, reproduction, or a diagnostic lesson; move or remove stray evidence

10) Global coherence checks during writing

Continuously verify using Grep and Read tools:

  • introduction promises exactly what later sections deliver
  • notation in experiments matches notation in theory
  • section titles reflect actual content
  • theorem numbering and equation references are stable
  • section roadmaps match the real section order
  • appendix references resolve cleanly

11) Progressive introduction of technical terms

Every technical term, concept, or axiom must follow this progression on first encounter:

  1. Plain English (caption, abstract, or first mention): Use everyday language. "facts persist until contradicted."
  2. Intuitive example (introduction or motivation): Ground in a concrete scenario. "Once the fridge is opened, it stays open until someone closes it."
  3. Design principle (method overview): State the principle with its name. "The inertia axiom — once a fluent is initiated, it persists until explicitly terminated."
  4. Formal mathematics (method section): Full definition with notation. "$\pred{Initiates}(e, f, t_0)$ and no terminating event in $(t_0, t] \implies \pred{HoldsAt}(f, t)$."

Rules:

  • Never use a named concept (e.g., "inertia axiom", "regressive product", "Dirichlet energy") before giving the reader enough context to understand what it means at an intuitive level.
  • The formal definition can come later — but the intuition must come FIRST.
  • If a term appears in a figure caption or table, the caption must be self-contained enough for the reader to understand the term without reading the main text.
  • Use Grep to find every occurrence of a technical term and verify the first occurrence is adequately introduced.

12) Writing style

Aim for:

  • formal but motivated
  • mathematically precise
  • intuition immediately before or after dense equations
  • minimal rhetorical fluff
  • explicit transitions between sections
  • first-person plural voice unless the repo style says otherwise

13) Output format when helping a user

For substantial planning, organize the working record around:

  1. claim graph
  2. notation ledger
  3. section contracts
  4. drafting plan
  5. proof obligations
  6. experiment obligations
  7. risks / missing assumptions

Show only what helps the user's current decision. A local correction should not produce this entire planning packet or an unsolicited deck.

14) Tool usage

  • Use Glob to find all .tex files in the project
  • Use Grep to search for \label{}, \ref{}, \cite{}, macro definitions, and notation patterns
  • Use Read to examine section contents before editing
  • Use Edit for targeted changes (prefer over full rewrites)
  • Use Bash to compile LaTeX and check logs: pdflatex -interaction=nonstopmode main.tex && bibtex main && pdflatex main && pdflatex main
  • Use Task with subagent_type="Explore" for broad codebase research across many files
  • After major restructuring, always compile and check: grep -c "undefined" main.log and grep "multiply" main.log

Consult:

  • assets/paper_blueprint.md — section contracts and structure
  • assets/claim_proof_experiment_map.md — claim tracking template
  • references/bajaj_flow.md — theory-heavy paper flow heuristic
  • references/abstract_revision_patterns.md — claim-preserving abstract revision; use when drafting or revising an abstract, or when the user asks "does this read robotic?" / "is this impressive enough?"
  • references/researcher_persona_loop.md — researcher persona, /research-loop protocol, and skill-routing judgement; use when the user asks to loop on a section, write and review at the same time, or decide which paper skill/tool to invoke.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.