Anti-Autoresearch skill

A set of 11 Claude Code skills that audits a third-party paper for self-consistency and fabrication and writes a report.

  • 181 ★ on the repository
  • Last commit
  • MIT
Skill

Extended access

Why this level

  • The installer copies skills into the Claude Code directory and the cross-model reviewer needs Codex connected through MCP.
  • The text and data of the audited work go to the models, so confidential manuscripts need care.
All reasons and checks

wanshuiyin/anti-autoresearch

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/anti-autoresearch

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • The installer copies skills into the Claude Code directory and the cross-model reviewer needs Codex connected through MCP.
  • The text and data of the audited work go to the models, so confidential manuscripts need care.

This is third-party code. Review the repository files before installing.

What it does

Anti-Autoresearch audits a scientific work for self-consistency and fabrication, regardless of who or what wrote it. A reviewer, an area chair or an honest author receives a report anchored to text spans. The skill does not estimate AI authorship probability and does not rule on misconduct: it surfaces discrepancies for a human to investigate. The set holds 11 skills and one orchestrator. The catalog has 46 integrity patterns in eight families: numbers in tables and text, method and scope, baseline integrity, experiment integrity, citations and more. It also lists 13 zero-weight impressions of AI writing style and 2 advisories. Language models only propose findings, and a deterministic rules-only report builds the result. The `/anti-autoresearch ~/papers/submission` command runs every auditor in turn and writes `REPORT.md`, `report.json` and `claims.json`. Each auditor is also available as a standalone skill.

Who it is for. Conference reviewers, program chairs and authors who need to check whether a paper stands on its own evidence.

Good fit when

  • A reviewer received a paper whose tables do not match its text.
  • A paper lists baselines and their fair configuration must be checked.
  • Citations look doubtful: some sources may be fabricated or misattributed.
  • Before journal submission an author wants to check their own text for contradictions.

Not a fit when

  • You need an AI text detector with an authorship probability: the skill does not give one.
  • You want a misconduct verdict: the skill surfaces discrepancies and the decision stays with a human.
  • The work has no code or data but you want its experiments checked: some families need code.

Example request

Run /anti-autoresearch on the ~/papers/submission folder and show the findings anchored to text spans.

Limitations

The skill runs in Claude Code and installs with the `tools/install_anti_autoresearch.sh` script, which places the skills in `~/.claude/skills`. The cross-model reviewer is attached through `claude mcp add codex -- codex mcp-server`, so Codex is needed. The experiment integrity family works only when code is available. The result is a set of findings for a human and no quality grade. AI writing-style impressions carry no weight in the verdict, so a paper can be clean on integrity and still collect many such notes.

How to disable. Delete the Anti-Autoresearch skill directories from `~/.claude/skills`. Drop the Codex connection with `claude mcp remove codex` if you no longer need it.

FAQ

How do I install Anti-Autoresearch?

Clone the repository and run `./Anti-Autoresearch/tools/install_anti_autoresearch.sh`. Skills land in `~/.claude/skills`, or pass the path of a project `.claude/skills`.

Does it detect whether AI wrote the paper?

No. The skill gives no authorship probabilities and no AI-written verdict. It checks self-consistency and fabrication and keeps style impressions in a separate zero-weight section.

What does the report contain?

The `REPORT.md`, `report.json` and `claims.json` files, plus each skill findings anchored to text spans with an evidence hash.

Can I run auditors one by one?

Yes, the installer places each auditor as its own skill. An evidence ledger is built first, then the chosen auditor writes `<skill>.findings.json`.

Which check families exist?

Eight: numbers, method and scope, baselines, experiments, citations and three more. There are 46 integrity patterns in total.

Discussion

No questions or reviews yet.

Skills

A research system on top of Codex CLI or Claude Code: runs of experiments, discussion of progress and a paper draft.

CLIBroad access115Repository stars
Official

Feynman — a terminal AI agent for scientific research: literature reviews, source checks, paper critique and comparing a paper with its code

CLIExtended access10.1KRepository stars

A skill set that runs a research repository from its README within bounds and keeps verifiable evidence, without rewriting the original README

SkillBroad access486Repository stars

Academic plugin for Claude Code, Gemini CLI, Codex and OpenCode: literature reviews, peer review and citation checks

PluginExtended access138Repository stars

An autonomous research assistant: from idea and plan through experiments and analysis to a paper, relying only on real results

CLIBroad access1.3KRepository stars

ARIS

ARIS (Auto-Research-In-Sleep)

A skill set for autonomous machine learning research: literature review, idea discovery, experiments and paper writing with review by a separate model

PluginBroad access19.1KRepository stars

README in short

The project starts from auditing someone else work: it points the audit mechanisms of the ARIS project outward. It describes the skill set, the deterministic spine with an evidence ledger, the report rules and launch examples. Separate instructions exist for single-skill use.

README badge

Original SKILL.md

---
name: consistency-audit
description: "Flagship intra-paper self-consistency forensics: does the paper contradict ITSELF across abstract/intro/tables/body/appendix, and does the method DESCRIBED match the method EVALUATED? Needs no external ground truth — works PDF-only (L0). Runs a deterministic arithmetic pass + a fresh cross-model semantic pass, every finding span-anchored to the evidence ledger (claims.json), reviewer≠adjudicator. Emits consistency-audit.findings.json; NEVER computes the verdict. Triggers: \"consistency audit\", \"check the paper against itself\", \"self-consistency\", \"内部自洽\"."
argument-hint: [paper-dir | claims.json]
allowed-tools: Bash(*), Read, Write, mcp__codex__codex
---

# Consistency Audit — the paper vs itself

Audit intra-paper self-consistency for: **$ARGUMENTS** (requires `claims.json`
from `/evidence-ledger`). Emit span-anchored `consistency-audit.findings.json`;
the deterministic adjudicator — not this skill — computes the verdict.

> 🔒 **Do not wrap this skill in `/loop`, `/schedule`, or `CronCreate`.** It is
> verdict-bearing input — it proposes the findings the deterministic adjudicator
> turns into the report. Re-firing it on a wall-clock timer adds no signal: its
> output changes only when the **paper / ledger** changes, not with the clock.
> Schedule the *external wait that precedes it* — ledger built → audit **once**.
> (Mirrors ARIS's external-cadence doctrine.)

> The flagship instrument. Internal contradiction is the single most defensible
> thing you can check on an unknown submission: it needs no external GT, runs at L0
> (PDF-only), and is exactly where machine-generated papers crack — they hallucinate
> *local* coherence. Recall scales with the ledger: a PDF-text (L0) ledger extracts
> only number/scope spans, so the table/caption/method-drift checks gain teeth at L1
> (LaTeX), where tables and captions are actually extracted. Adapted from ARIS
> `paper-claim-audit`, reframed from "paper vs result files" to **"paper vs
> itself."** There is no external ground truth in this skill.

## Why this exists

An autoresearch pipeline (or rushed human) writes the abstract, the tables, the
method section, and the appendix in separate passes and never reconciles them. The
result is a paper that disagrees with **itself**:

- abstract quotes 85.3% accuracy; the best row of its own Table 2 is 84.7%;
- "improves by 16%" when 73.1 → 78.0 is +6.7% relative / +4.9 points;
- "mean over 5 seeds" where the number is the single best seed, and N=3 in the table;
- method section says "no test-time labels"; the experimental-setup paragraph loads
  gold labels for calibration;

Report a problem