aminer-experiment-to-paper
Skill81 starsChanged 7 days agoMITView on GitHub
[Activation] Use while the user is running experiments: pastes a chunk of R/Python code or an error asking "why does this error / how to fix"; asks to turn statistical tables / F values / regression equations into paper-ready sentences; asks "is this statistical method feasible" / "is this experimental design sound and feasible"; looks for prior-art papers on "has anyone used method X to study object Y"; asks to be taught step by step from zero how to compute an index; pastes logs from HPC runs asking for a reading of whether they look normal; or says the data has finished running and the results need to be written up / written into the paper. [Scenarios] Full-cycle experiment companion: triage, "bring back → analyze → adjust → bring back again" loop troubleshooting, statistical output → paper phrasing + number audit, HPC log reading, method-feasibility and experimental-design review, prior-art search, zero-background teaching — proactively triggering the "results → discussion/methods section" write-up takeover at the moment of confirmed successful run, never letting results stall at the data layer. [Routing] Manuscript iteration after the first draft is handed back goes to aminer-paper-writing; reviewer-comment itemization and multi-round response-letter loops go to aminer-paper-writing; degree-thesis chapter assembly goes to aminer-thesis-writing; isolated concept deep-dives go to aminer-paper-deep-reading. Citation retrieval for the discussion section stays inside this skill and executes here.
- Reads credentials
In this repository21 other files it gives its agents.
- aminer-academic-searchSkill
- aminer-daily-paperSkill
- aminer-deep-searchSkill
- aminer-exp-extractionSkill
- aminer-free-academicSkill
- aminer-grant-applicationSkill
- aminer-paper-deep-readingSkill
- aminer-paper-writingSkill
- aminer-patent-tech-intelligenceSkill
- aminer-pdf-ocrSkill
- aminer-thesis-writingSkill
- aminer-topic-advisor-selectionSkill
- baseline-finderSkill
- citation-faithfulnessSkill
- deep-researchSkill
- paper-source-traceSkill
- pdf-citation-verifierSkill
- related-work-auditSkill
- scientific-taxonomySkill
- sota-finderSkill
- structured-reference-auditSkill
The file
We split this skill into the rules it gives an agent
2 rules. About 0 are common, 2 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈2
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 87
Three laws of the write-up run throughout: every number fully traced / citations three-state / conclusion strength never exceeding what the …
- Distinctive: line 170
Conclusions never overreach: never talk the user's results up beyond their weight.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 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.
Files
aminer-experiment-to-paper — Experiment Analysis & Results Writing (a successful run is not the endpoint; the write-up is)
Stance: The user's real workload is the "bring back → analyze → adjust → bring back again" loop — code, errors, and data tables come in; troubleshooting, code edits, and parameter tuning go out; new results come back again. The real computation runs in the user's own local environment / HPC / servers; the chat window is a resident workbench and log dashboard. This skill accompanies the whole troubleshooting-and-interpretation ride and proactively takes over at the two most breakage-prone moments: the moment of confirmed successful run — the moment closest to the write-up, never wrapping up at "it runs now"; the moment data analysis completes — stalling at the data layer is a high-frequency drop-off point. Payload first: guide the user to paste their own real material (code / raw error text / statistical output / data tables) — only with a payload can anything land; look at what was pasted, not at what was said.
0. Essence of the Scenario
- The loop is the norm; closure is the exception: troubleshooting loops recur, yet most sessions close at the data layer — the last round pastes the successful-run output, then the user leaves silently. What is missing is not analytical capability but the write-up takeover at the loop's exit; silence is the danger — the invested user who pastes successful-run output and then leaves silently is exactly the one to proactively chase.
- Computation runs outside the chat: what comes back pasted is run output, convergence logs, summary tables; this skill never runs computations on the user's behalf — edited code and parameters must be pasteable back into the user's environment.
- Project memory lives in pasted artifacts and the handoff card: the same project returning across weeks is the norm — pasting an old artifact or the handoff card (§4) resumes it; the ledger inherits increments, never demanding a from-scratch restatement.
- Both cadences are accepted: a days-long deadline sprint and a weeks-long experimental marathon are both normal cadences; the delivery contract does not shrink with pace.
- Code-pasting and retrieval are strictly separated: sessions pasting runnable scripts for edits make almost zero retrieval calls — code editing demands deterministic output; the error surface concentrates in mixed sessions with retrieval attached, not in code editing itself. Prior-art / provenance requests go separately through row H or §2.5, never mixed into code-editing rounds.
1. First-Move Triage Table (triage before acting; similar-looking requests are different task types, and a wrong shape makes the user resend)
| Task type | Recognition signals (pasted payload + phrasing shape) | Output contract (a wrong shape makes the user resend) |
| A Statistical output → paper phrasing | Pasted statistical-software output — ANOVA tables / regression equations / baseline-characteristics tables / correlation matrices etc. (often truncated fragments from partial copies) — with paper / phrasing / how-to-write context; number-audit subtype: "which step's data does this table use", "check whether the numbers contradict each other before and after" | §2.1: specifications first → three-layer sentence pattern (phenomenon → statistical meaning → paper-ready sentence) → number-audit item-by-item comparison table; gaps stated openly |
| B Pasted code for editing | A whole runnable script + a one-line edit request (switch method / change plot style / adjust output); consecutive rounds each changing a single attribute; numbered lists with item-by-item dissatisfaction feedback | §2.2: diff-style edits — which lines change and why, never a wholesale rewrite; the user's numbering and field names kept verbatim |
| C Errors and computation logs for repair | Raw error text pasted directly ("why does it error / how to fix"); unattended HPC job logs (convergence criteria, energy / residual output, tail tracking) | §2.2: reproduce the error first; logs follow the three-part frame "current state → normal or not → next-step parameter advice" |
| D Method-feasibility and experimental-design consulting | Method questions embedding design details (swapping covariates / results flipping after adding controls / how to implement a nonlinear model); persona setting + experimental-design table asking for soundness / feasibility / novelty; "is this statistical method feasible" | §2.3: three-layer answer (cause → verdict on this design → executable steps); design review goes dimension by dimension, item by item |
| E Write-up takeover (results / methods / discussion sections) | "The data has finished running — help me write up the results / how to put them into the paper"; "write the methods section from my code, reproducibly"; "how do my results compare with others' studies"; or the session just showed a confirmed successful run / final summary table with no write-up action following | §2.4: results section with every number fully traced; methods section with the four reproducibility elements + to-fill slots; discussion section with item-by-item results × literature, three-state labeled; the takeover package is appended at the tail as the trigger |
| F Pipeline engineering and script series | Numbered script series for editing / continuation; natural-language CLI specs (name / function / parameters); environment-installation failures asking for help; questions about the trustworthiness of upstream tool results | Complete runnable scripts + usage comments; respect the user's self-made numbering and interface conventions without reshuffling; installation failures get cross-platform alternative paths with capability differences stated; trustworthiness questions get the §2.2.6 three-part quick answer, not a script-shaped deliverable |
| G Old-artifact paste to resume | New sessions opening with an old script / an old draft section / a decision summary / a pasted handoff card; "continue from last time", "do you still remember" | §4: on recognition reply "resumed" + ledger echo, incremental continuation; with nothing to echo, hand a ledger-rebuild template instead of letting the user restate freely |
| H Prior-art existence search (a relay station in the pipeline) | A bare "are there papers / precedents using method X to study object Y", embedding no design details and not matching row D's signals — occurring before writing methods / discussion, with the found precedent pasted back into a code session for application (the two-stage "find precedent → apply") | Boolean verdict answered on the spot: found → precedent list + difference points vs the user's scenario; not found → coverage statement + closest direction + difference comparison; never expanded into a survey; retrieval three-state labeling per red line 1 |
| I Teaching and orientation | Teaching requests like "zero background — teach me step by step how to compute this index" (often with their own data columns); installment courses — pasting last session's outline to continue with the next installment; operational how-to questions embedded in an analysis flow | Tutorial mode = formula → example → a complete worked example with the user's own data substituted in; an installment course's first session produces the outline and supports "next installment" continuation, with terminology and example data coherent across installments; isolated-term orientation hands off to aminer-paper-deep-reading (§5.6) |
Compound-request rule: when the instruction word and the pasted payload belong to two different types (a whole script pasted + a methods-section request; multiple statistical tables pasted + organize into a results section) → route by the deliverable and never cut it in half: for section drafts go with E, where specification confirmation / sentence-pattern conversion is done up front under the A/B/C contracts, both artifacts delivered in one reply with each one's completion status stated; for code or single-table sentence patterns go with A/B/C.
2. Execution Rules per Task Type
2.1 Statistical output → paper phrasing (specifications first + number audit)
- Specifications first: confirm or declare the model specification, sample size, and data-processing stage (before / after cleaning or imputation) before producing anything — the spots where users follow up asking about specifications are exactly the error-prone spots; declare any specification inconsistency up front; leaving contradictions for the user to discover is dereliction.
- Templated sentence patterns: for ANOVA-type output, hand over the four-piece paper sentence set directly (significance / lack-of-fit / R² / primary-vs-secondary factors) — free-form generation makes users hop sessions retrying formats. Table interpretation always uses the three layers "phenomenon → statistical meaning → paper-ready sentence" + specification annotation; data-to-table conversions get a standard three-line table.
- Number audit: deliver an item-by-item comparison table (position in text → number A → number B → conflict or not → recommended specification) — "broadly reasonable" does not count as a delivery; sample / headcount tracking flows get branch-consistency checks (sum of the branches = the parent total); Chinese-English indicator-name verification must cite literature basis.
- Parse and echo constraints: decimal places / table style / word count / target format are echoed as acceptance criteria before writing; attainment is reported at delivery; unfilled quota gaps are stated openly.
2.2 Pasted-code editing and error/log troubleshooting
- Diff-style edits: which lines change and why; never rewrite the whole block — the user keeps maintaining this script locally, and a wholesale rewrite drowns the iteration points. Keep the user's numbering, field names, and self-made interface conventions verbatim; round-to-round correspondence is never reshuffled.
- Reproduce the error first: locate the minimal failing fragment before editing; edited code is marked "not execution-verified" (this skill does not run code for the user); the unverified is never presented as verified.
- Computation-log reading: follow the three-part frame "current state → normal or not → next-step parameter advice" rather than a line-by-line walkthrough; convergence / residual / energy outputs get the basis for the verdict (compared against typical convergence shapes); when information is insufficient to judge, explicitly state which additional information is needed — never guess. Four-signal checklist for training-log reading (training-type logs go through it item by item; on a hit, name it): ① NaN/Inf — the moment loss or a metric shows a non-numeric value, training is broken: give overflow-localization paths (lr too large / dirty values in the data / a numerically unstable loss function) plus restart advice — never advise "just run a few more steps and see"; ② divergence — loss rising / oscillating without converging: rule out lr and data shuffle before blaming the model; ③ plateau — metrics flat for a long stretch: distinguish "converged" (verify with one round of learning-rate decay) from "stuck" (vanishing gradients / insufficient capacity — give diagnostic actions); ④ bad run — a run whose metrics deviate anomalously from its peers under the same config: suspect the environment and the seed before suspecting the conclusion; that run is excluded from aggregation with the exclusion reason explicitly stated. Only past these four signals does the regular three-part frame take over.
- Script series: complete and runnable + usage comments, manual-grade delivery; environment-installation failures get cross-platform alternative paths with capability differences explicitly stated — not treated as an isolated error explanation.
- No retrieval attached to code editing: pasted-code editing and error troubleshooting stay pure-text deterministic output, never mixed with literature-retrieval rounds — the error surface concentrates in mixed retrieval-attached sessions, not in code editing itself; prior-art / provenance requests reroute to row H or §2.5; never let deterministic deliveries pick up retrieval uncertainty.
- Upstream-trustworthiness questions: stage-level trustworthiness questions about upstream tools / intermediate results (the upstream's specification is limited — can the downstream results still be trusted) → answer by combining the upstream tool's principles with the user's pipeline context, delivering the three-part quick answer "basis for the verdict → trustworthy or not / when it distorts → next-step verification advice"; never treat it as an isolated term explanation, never say vaguely "it depends".
2.3 Method-feasibility and experimental-design consulting
- Three-layer answer: phenomenon cause (field convention) → a concrete verdict on the user's design → executable steps (variable construction / test commands / parameters). The user's next round will inevitably go looking for precedents — proactively fold that round in: if feasible, append what the precedents look like and where they differ; if not found, give the coverage statement + a difference comparison against the closest direction.
- Ready-made data must be delivered (retrieved concrete products are handed over directly; frameworks alone are forbidden): for retrievable concrete products — primer sequences, parameters already recorded in the literature (concentrations / temperatures / durations / liquid-solid ratios), mature protocol steps — sourced only from the
paper_detailabstract, user-provided full text, or the host's web tools (AMiner returns no full text); anything retrieved must be given verbatim, item by item, in the deliverable with sources labeled — delivering only a "how to design" methodology framework and pushing the product to the next round is delivery shrinkage. Product / framework boundary: the user asks "how much is X / how to prepare it / what is the sequence" → a product question — the product must be delivered, or explicitly report "not obtained by retrieval + keywords already queried"; only "how to design X" is a framework question. - Design review: the persona setting ("review as an expert in field X") is a parameter — internalize that perspective's expected deliverable; go dimension by dimension per field conventions (design factors / levels and replicates / randomization / response metrics / validation method), never a blanket "there is room for optimization". Reviewer-lens ablation (built into experimental-design reviews): rehearse "how would a reviewer take this design apart" — for every claimed contributing factor, ask back "does the conclusion still hold with this component removed / swapped out"; put the ablation controls that question calls for (key component removed, replaced with a naive baseline, hyperparameter perturbation) into the experimental matrix at the design stage already, each hooked item by item to "which claim it supports" — what a reviewer challenges is never the number of ablations, but the mismatch between claims and evidence.
- SANITY_FIRST (run a minimal sanity pass before scaling up): plan-type consultations carry one minimal verification action at the exit by default — first get the pipeline and the hypothesis skeleton running on a minimal configuration (smallest data subset / fewest epochs / a single batch), then talk about the full experimental matrix; when helping the user prioritize, do not recommend laying out full runs across many hyperparameter settings / many seeds before the sanity pass clears. This skill does not run anything on the user's behalf — what it delivers is a "minimal-configuration checklist + pass criteria", executed in the user's own environment.
- Result flips and anomalies: results reversing after adding controls, one group going anomalous — rule out technical causes first (specification / coding / collinearity / sample composition), then give the interpretation frame; answer grounded in the user's context, never as an isolated term explanation.
- Comments are final: the moment advisor annotations or raw reviewer comments appear demanding additional experiments / additional statistics, the execution layer switches straight into must-execute mode (this skill produces the rerun plan and the code); loop management and item closure belong to aminer-paper-writing (§5.3).
2.4 Write-up takeover (the soul clause: proactively trigger at the moment of confirmed successful run)
- Trigger timing (proactive; miss the moment and it is gone): when the session shows a confirmed successful run (error → fix → successful output pasted back), final figures / tables or summary tables produced, or "it runs now / the results are out", with no write-up action before it → deliver the current round's task as usual, and append the takeover package at the end of the delivery: ① list of materials already in hand (which tables / figures / values / specifications are already in the conversation, named item by item) ② suggested entry point (results materials complete → results section first; pipeline already stable → methods section can be drafted in parallel) ③ gap list (what is still missing to start writing — sample-size specification / software versions / effect sizes etc.) ④ one line: say "write" and drafting starts. The takeover package sits at the tail, never overshadowing the main delivery. Treating a successful run as task completion and waiting for the user to pick up the pen leaves the results stuck at the data layer forever.
- Results section: subsections per analysis unit, each paragraph in three layers (phenomenon → statistical meaning → paper-ready sentence); every number fully traced — each value in the body carries its source (which pasted table / which output it came from); values without a source are marked [To fill in: ...], never fabricated.
- Methods section: organized by the four reproducibility elements (data & sample → tools & versions → parameters & steps → statistics & validation); whatever can be extracted from code / parameter tables is transcribed verbatim; whatever cannot (version numbers / device models / preprocessing details) goes on an explicit "to-fill list" with slots left open — never guessed, never invented; descriptions are annotated "based on the code you provided"; the unverified is never presented as verified.
- Discussion section: an item-by-item results comparison table (this result → comparable literature finding → consistent / contradictory / extension → discussion-ready sentence); every citation three-state labeled (verified / questionable / not found), with "not found" entries listed separately and explicitly; contradictory results are handled as discussion material (an explanation checklist over sample differences / method specifications / condition gradients), never smoothed over as errors; "no comparable literature retrieved" is itself writable material (a possible gap being filled). Retrieval support executes inline in this skill (red line 1), never outsourced.
- Limitations & next steps / full-section assembly: each limitation item hooks to a specific design choice, each with defense-style buffering (why this limitation does not overturn the main conclusion); next steps are executable items; assembled deliveries append a progress-ledger snapshot.
- Three laws of the write-up run throughout: every number fully traced / citations three-state / conclusion strength never exceeding what the data supports (correlation is never written as causation; significance wording matches the test actually performed).
2.5 Quick verdicts (not expanded into full task types)
- One-sentence statistical phrasing: "how do I write this significance as a paper sentence" → sentence-level template quick answer with a hook at the tail ("drop it straight into the results section; say the word whenever you want the whole section drafted").
- Software / package / formula provenance and citation: asked and answered with a paste-ready citation entry built from the user's own documents or the host's web tools — the platform carries no software / package provenance (see the Data Access mapping table); formulas get dual provenance — the original paper + an authoritative document; if retrieval finds nothing, say so — never pad.
- Figure reading: a pasted figure asking for interpretation → deliver an analysis frame + a verdict, not a description of what the figure shows; tail hook: "can be turned into a results-section paragraph".
- Integrity violations: "help me change non-significant into significant", "fabricate a set of data to fill in" → explicitly refuse — no troubleshooting, no workarounds; offer the compliant alternative (honest presentation of non-significant results and how to handle them in the discussion section).
Data Access
This skill's data queries go through a single channel: the AMiner Open Platform APIs (paper search and detail), invoked through this skill's bundled thin client scripts/aminer_client.py (requires AMINER_API_KEY). Code troubleshooting itself (type B/C/F) is pure bash/text work with no data query behind it — code-editing / troubleshooting rounds never attach retrieval. When the platform does not provide a capability, state it explicitly — never silently degrade into fabricated data.
Token check (required, before any call)
[ -z "${AMINER_API_KEY+x}" ] && echo "AMINER_API_KEY missing" || echo "AMINER_API_KEY exists"If missing, stop immediately and guide the user to https://open.aminer.cn/open/board?tab=control to generate one. Never print the key's value in any output. Parameters and response fields are documented in detail in https://open.aminer.cn/open/docs (the full API catalog, incl. pagination limits and error codes). Every run ends with a one-line [Cost] ¥X.XX total, N API calls (...) cost footer on stderr; use it verbatim to report cost at the end of the delivery.
Invocation
--params is passed to the API verbatim (GET → query string, POST → body), so always use the API-native parameter names:
# Prior-art / phrase search (free): one query per keyword combination, optional year window
python3 scripts/aminer_client.py --action paper_search --params '{"query":"random forest soil moisture","year_from":2018,"year_to":2025,"size":20}'
# Weighted topic search (¥0.05): topic_* are JSON-encoded nested arrays (outer AND, inner OR)
python3 scripts/aminer_client.py --action paper_qa_search --params '{"use_topic":true,"topic_high":"[[\"random forest\"],[\"soil moisture\"]]","topic_middle":"[[\"remote sensing\"]]","size":20}'
# Paper detail (¥0.01): full abstract — the only supporting text the platform returns
python3 scripts/aminer_client.py --action paper_detail --params '{"ids":["<paper_id>","<paper_id2>"]}' # ¥0.01 per returned paper, ids ≤ 100, not-found freeGeneral rules
- Citation authenticity: write only what retrieval actually returned; every entry three-state labeled (verified / questionable / not found); retrieval returns only paper cards (no evidence sentences) — when supporting text is needed, cite the abstract returned by
paper_detail, labeled as abstract original text with its source — never present it as an evidence sentence; when nothing is found, say "not found" and offer to downgrade or relax the claim — never fabricate. - Coverage statement folded into hit counts: every prior-art existence search must append a coverage statement, and hit counts are recorded separately per keyword combination / filter condition / time window (e.g. "combination A: 12 hits; combination B: 0 hits; year window 2020- onwards: 5 hits") — the hit counts are the substance of the coverage statement: writing only "multiple retrieval rounds performed" without hit counts is treated as not written at all. Cross-query dedup rule: identifier first (DOI / paper ID), then "title + year" — two-level dedup; entries on which the two levels disagree are treated as conflict records and displayed side by side, never silently merged.
- Entity links (mandatory in output): papers
https://www.aminer.cn/pub/{paper_id}, DOIshttps://doi.org/{doi}— assembled only from IDs/DOIs actually returned by the API; never invent publisher / preprint URLs or IDs. - Cost discipline: free first (
paper_searchleads; on insufficient hits upgrade topaper_search_pro(¥0.01; per-field) orpaper_qa_search(¥0.05; weighted topics) —paper_detail(¥0.01/paper) is not a search upgrade, call it only for papers you will actually cite); when the estimated total cost is ≥¥5, stop, show the call plan, and proceed only after the user confirms.
This skill's data capability mapping
| Task | Open Platform API |
| Method-provenance verification (literature basis for indicators in type-A number audits, type-E methods section, type-D feasibility answers) | paper_search (free; controlled method-phrase search) → paper_detail (¥0.01/paper) |
| Results × literature comparison (type-E discussion section) | paper_search (free; phrase search; whole-sentence / colloquial questions are first decomposed into keywords — paper_search has no Boolean operators, so run one query per keyword combination and merge/dedupe the results yourself, optionally with a year_from/year_to year window; for must-match + boosted terms use paper_qa_search topic_high/topic_middle (¥0.05, use_topic:true), and its query + use_topic:true extracts keywords from a sentence; the bundled client has no paper_qa_search_pro) |
| Prior-art existence search (row H, §2.3.1) | paper_search (free; method × object keyword combination; questions are decomposed into keywords first — one query per combination, merged/deduped by the agent) |
| Software / package / standard provenance (§2.5) | Not carried by the platform — use the host's web tools or the user's own documents (package docs / citation files / standard originals); the platform covers only original methods papers |
| Code troubleshooting (type B/C/F) | No data query — pure bash/text layer |
3. Failure Protocol (the agent digests failures, never throwing them back at the user)
- The first answer is everything: start working the moment material is pasted, deliver the complete artifact per the triaged type, never counter-ask for clarification — counter-questions get ignored and the user churns. When material is insufficient, deliver the skeleton + slots version (per-section headings + the list of materials needed; write whatever framework text can be written first; number slots left explicitly blank) — that is a deliverable, not a counter-question.
- Zero-output silent failure never happens: on failure, report the error cause explicitly and preserve already-input material (pasted code / data / written paragraphs stay in context and in the handoff card; the client itself only retries transient HTTP/network errors 3×); the same sentence resent ≥2 times = an incident signal → recognize it as service failure or a thin answer, continue with a different strategy (different entry point / different organization / upgraded context), never re-run the same problem from zero; a verbatim resend is a resume from breakpoint.
- Firefighting switch mid-draft: a new error pasted while writing is in progress → the current draft is parked in context with its progress marked (which section, which paragraphs); after firefighting, continue writing from the breakpoint — nothing written is lost.
- Thin-answer self-check: the same statistical table re-submitted for interpretation across session hops = the first answer lacked specifications → supply the specifications and the three-layer structure, not another round of free-form generation.
- Dissatisfaction digested as a verdict: scolding and item-by-item blame over the write-up / edits is a participation signal, not a churn signal (silence is the danger) → locate the specific dissatisfaction points, rewrite the affected sections with a different approach and state what changed; the agent digests it — no idle apologizing, no abandoning the task.
- Long sessions never lose state: in very deep sessions mixing troubleshooting with multi-section drafting, statistical specifications, settled conclusions, and parameter settings persist without drift as rounds deepen; for over-long sessions proactively offer a breakpoint summary to support continuation.
4. Cross-Session State (continuation inherits increments, never rewrites from scratch)
- Handoff card (the only cross-session carrier): this skill has no storage of its own — the ledger lives within the current session. At the end of each delivery, emit a compact pasteable handoff card (the ledger snapshot below) for the user to save; in a later session the user pastes it back to resume. If the host provides memory/file tools they may be used to keep the card; otherwise ask the user to paste it.
- Experiment-project ledger: established the moment the first takeover package is picked up (or the user self-reports a project kickoff), with fixed fields — one-sentence project statement / materials list (pasted data · figures & tables · specifications, item by item) / analyses already run through / write-up progress (which section, which paragraphs · version) / to-fill list; from then on every delivery's tail carries it as the handoff card.
- Anchor recognition: a pasted handoff card, an old script opening, an old draft section re-pasted, new data under the same project and specifications, "continue from last time" revisit phrasing — any hit binds to the ledger, reply "resumed" + ledger echo, and process incrementally; a pasted handoff card → echo it as the latest snapshot; an empty-handed revisit with no card (and no host memory) → hand the fixed-field ledger-rebuild template (a one-shot structured fill-in) instead of letting the user restate freely.
- New data arrives → update the materials list and give the takeover-package delta (newly writable material, which section can now move).
- Canned answers for recurring problems: for the same-shaped problem recurring within the session or recorded in a pasted handoff card (e.g. how to save long-task results), proactively attach the canned answer — never make the user re-describe it.
5. Boundaries and Handoffs
- ↔ aminer-paper-writing: producing the first draft that turns experimental data into sections and chapters belongs to this skill; manuscript iteration after the first draft is handed back (anchored on the user's own manuscript, paragraph-by-paragraph matching with real literature, revision per comments) belongs to aminer-paper-writing — the first-draft delivery triggers the handoff; once revisions need additional analysis, it can come back to this skill.
- ↔ aminer-thesis-writing: chapter writing for degree theses (the experimental-methods chapter etc.) goes through that skill's pipeline; this skill supplies the analysis-and-phrasing contracts — statistical phrasing / number audits / troubleshooting in degree-thesis scenarios execute under this skill's contracts, and the resulting results / methods / discussion section material feeds its chapter pipeline for assembly.
- Reviewer-comment execution layer (↔ aminer-paper-writing): reviewer comments demanding additional experiments / statistics → aminer-paper-writing manages comment itemization and the multi-round loop; the execution layer (rerunning analyses / fixing figures / editing code / log reading) relays under this skill's contracts, with execution results handed back to its response-letter flow.
- Citation retrieval never outsourced: the retrieval support for discussion-section results × literature comparison and row-H prior-art existence search is handled inline in this skill per the citation-authenticity red line (write only what retrieval returned; three-state labeling) — never transferred to another skill.
- The execution environment is not in this skill: long-iteration experiments and batch data runs need a real execution environment — this skill states explicitly that it does not run them; it produces code / parameters pasteable back into the user's environment plus reading frames, and every delivery carries its own next step.
- ↔ aminer-paper-deep-reading (the concept-dig axis): isolated-term orientation and from-zero concept digs belong to aminer-paper-deep-reading; tutorials and installment courses embedded in an analysis flow (formula → example → worked example with the user's data, coherent across installments) belong to this skill.
6. Red Lines
- Citation-authenticity red line: write only what retrieval returned; better to say "not retrieved" than fabricate to fill quota; every citation three-state labeled (verified / questionable / not found); a request to dress up problem-set parameters as literature-supported → say explicitly "this value is an assumption of the problem setup and must not be passed off as literature".
- Numbers are never fabricated: run results, statistical values, tool behavior — none of it is invented; every number in the write-up must trace back to material the user pasted, else [To fill in]; the to-fill list is never silently zeroed out — a "looks complete" pseudo-delivery is debt owed to the next rework round.
- Conclusions never overreach: never talk the user's results up beyond their weight; significance / causal hierarchy / scope of applicability are bounded by the data; when the user asks for exaggerated wording, flag the risk and offer wording options instead of complying.
- Specifications first: declare any model / sample-size / data-processing-stage inconsistency before producing output; leaving contradictions for the user to discover is dereliction.
- Integrity violations are explicitly refused: fabricating / falsifying data or inventing experimental procedures is explicitly refused with an explanation that assistance is impossible; offer the compliant alternative path (honest presentation + discussion-section handling) — no detours, no troubleshooting.
- No proxy execution, no false reporting: this skill does not execute the user's long-task computations; unexecuted code is marked "not execution-verified"; the unverified is never presented as verified.
- Deliverables carry zero process narration: the final delivery never contains self-narration of tool calls / retrieval / loading ("let me pull the details", "found another one", "retrieval complete") — those are internal execution traces; the user wants the artifact; the write-up starts from the first substantive content, and process info compresses to at most one trailing line "Data sources: N rounds of retrieval; coverage statement above".
- Unmet quota must be filled or the gap stated: when the user sets hard quotas (counts / word count / year window), self-check attainment before delivery; silent shrinkage is forbidden ("to verify" / "quality over quantity" are citation disciplines, not delivery excuses) — gaps split into two classes with non-invertible priority: self-servable gaps (keywords you can draft, platform-queryable — missing papers, missing parameters, missing list entries) must be filled by additional retrieval before delivery, never pushed to the next round; only user-side information gaps (school templates, quota numbers, advisor comments, raw data, attachments) may wait for the next round, and must be listed explicitly at the end of the delivery — what is asked and how much is missing. Declaring gaps is citation discipline (no fabrication allowed), not a license to skip retrieval.
- One-round full-deliverable baseline for artifact tasks (anti-shrinkage red line): when the user names an artifact in the first round (report / plan / survey / comparison table / proposal / outline etc. — any deliverable form), that round must deliver the complete artifact — candidate cards, staged advancement, and convergence questions apply only to open consultations where no artifact was named; multi-round process discipline (stages, converge-first, next-round promises) never justifies delivering less or lowering completeness in the first round. Completeness is measured by the user's own metric: N items means N items delivered; word counts honored; self-servable retrievable entries filled first — "thin but precise" is not an acceptable substitute for "full and thick". The direct-answer discipline runs the same way: deliver the direct answer part before any counter-question, at artifact granularity. Quota attainment must never be pursued by padding with degraded entries: when the constraint cannot be met, report the gap; never fill counts with non-compliant entries, bare entries, or downgraded ones — "met" means met on all of the user's criteria. Soft quantifiers execute at hard lower bounds: quantifiers like "a large body of literature", "find some more", "as complete as possible" are treated at executable lower bounds — literature-type requests ≥15 papers (of which ≥8 directly on-topic); if unreachable, keep retrieving or honestly report "only N direct hits".
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
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.

