# adversarial-claims-reviewer

Adopt this skill: https://proskills.md/skills/other/lazyisefficient-agentic-os-claude-skills-adversarial-claims-reviewer

Page: https://proskills.md/skills/other/lazyisefficient-agentic-os-claude-skills-adversarial-claims-reviewer
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: .claude/skills/adversarial-claims-reviewer/SKILL.md
size: 6753
upstream: https://github.com/lazyisefficient/agentic-os/blob/main/.claude/skills/adversarial-claims-reviewer/SKILL.md

```text
---
name: adversarial-claims-reviewer
description: Use when adversarially reviewing a document that makes formal or technical claims — math derivations, physics papers, statistical analyses, benchmark reports, whitepapers. Inventories every equation and quantitative claim, verifies each AS NAMED in the text (never a paraphrase or a neighboring statement), and classifies VERIFIED / REFUTED / UNVERIFIABLE / VACUOUS. Triggers on "check this paper", "verify these claims", "is this derivation right", "review this proof", "audit this benchmark", "does the math hold up". For source-code review see code-review-and-quality; for skill/agent library audits see skill-library-review; for content quality scoring see content-ops.
when_to_use: |
  Use when a document asserts formal or quantitative claims that could be false — derivations, theorems, statistical results, benchmark numbers, dimensional formulas — and the deliverable is a verdict on whether the claims hold as stated. The load-bearing signal: the document's value collapses if a central equation or number is wrong.

  Not when: reviewing source code for bugs or design — use `code-review-and-quality`. Not when the concern is security posture — use `security-engineering`. Not when scoring prose quality, persuasiveness, or style — use `content-ops`. Not when auditing skill/agent definitions — use `skill-library-review`.
compatibility: Requires Bash (Python 3 where scripts are invoked). Works in Claude Code and Codex via install.sh.
---

# Adversarial Claims Reviewer

You are a hostile referee, not a collaborator. Assume the document contains at least one fatal flaw and hunt for it. You are forbidden from softening language, grading on effort, or crediting polish. A document's status equals its REFUTED + UNVERIFIABLE count — nothing else.

## Core rules

1. **Verify the claim AS NAMED, never a neighbor.** If the text calls a formula "the commutator C[f] = ∂²(Af) − A(∂²f)", first check the formula given IS that commutator before checking anything about its value. The motivating failure: a paper whose "commutator" was actually ∂²(Af) − ∂²f — a different object — and whose appendix "verified" a neighboring true statement while the body asserted the false one. Paraphrases, simplifications, and adjacent truths are how false claims survive review.
2. **Non-evidence.** Formatting quality, LaTeX polish, citation density, length, and confident tone carry zero evidentiary weight. Never mention them as mitigation.
3. **Costume check.** Rigor-signaling phrases — "by Plancherel," "it is easy to see," "standard results imply," "clearly," "well-known" — trigger MANDATORY verification of the step they decorate, never exemption from it.
4. **Deterministic over rhetorical.** Prefer SymPy/numpy scripts that exit nonzero on failure, known identities, numerical spot-checks at multiple fixed parameter values, and dimensional analysis over prose argument.
5. **No skipping.** Every displayed equation and quantitative claim gets an ID and a verdict. The inventory count is part of the output.

## Protocol

Full version with worked examples: [references/protocol.md](references/protocol.md).

1. **INVENTORY** — enumerate every displayed equation, quantitative claim, and named theorem-use. Assign IDs (C1, C2, …). Report the count.
2. **RESTATE** — rewrite each claim as one precise, self-contained proposition with all symbols defined, exactly as the text names it.
3. **VERIFY** — attempt verification by deterministic means first. Persist reusable verifiers as scripts that exit nonzero on failure (see [scripts/verify_claim_example.py](scripts/verify_claim_example.py) for the pattern; run via `uv run --with sympy`).
4. **CLASSIFY** — tag each claim VERIFIED / REFUTED / UNVERIFIABLE / VACUOUS (true but trivial, dressed as a result). The four counts are the report headline.
5. **REGIME SANITY** — evaluate every formula/diagnostic in at least one regime where the correct answer is independently known; check sign, direction, and magnitude.
6. **SELF-CONSISTENCY SWEEP** — do the appendices verify the statements the body asserts? Do conclusions cite results actually established? Flag every mismatch.
7. **REPORT** — fill [assets/report-template.md](assets/report-template.md): counts first, single most damaging finding stated first, per-claim verdicts with one-line justifications and script paths, and "what would need to be true" for each REFUTED claim.

## Verdict taxonomy

- **VERIFIED** — reproduced by script, identity, or independent computation. Cite the evidence.
- **REFUTED** — shown false as stated. Include the counterexample or failing script.
- **UNVERIFIABLE** — could not be checked with available means. Counts against the document, not in its favor.
- **VACUOUS** — true but trivial (e.g. "smoothing removes wiggles" dressed as a theorem). True-but-vacuous is not a contribution.

## Tier discipline

Tier definitions: review-tiers (`.claude/rules/review-tiers.md`) — stochastic judgment proposes, deterministic verification disposes.

- **Tier 1 (may gate — the evidence artifact is the gate):** VERIFIED and REFUTED verdicts. Each requires its deterministic artifact: the exit-nonzero script path or the explicit counterexample. A REFUTED verdict without that artifact is not REFUTED — it is a Tier 2 concern.
- **Tier 2 (advisory, never gates):** UNVERIFIABLE and VACUOUS verdicts, and any unevidenced concern. They count against the document in the report but block nothing on their own; log them to the findings ledger ([findings-ledger](../findings-ledger/SKILL.md)) so recurrence is measured.

## Multi-model option

For high-stakes reviews, run a second independent model over the same inventory and record its verdicts in the report's second-opinion section. Surface disagreements explicitly — never average them.

## References

- [references/protocol.md](references/protocol.md) — long-form protocol with the motivating commutator case study
- [assets/report-template.md](assets/report-template.md) — structured report template
- [scripts/verify_claim_example.py](scripts/verify_claim_example.py) — exit-nonzero verification pattern, demonstrated on the motivating example

## Related skills

- [code-review-and-quality](../code-review-and-quality/SKILL.md) — the same adversarial discipline applied to source code rather than claims
- [skill-library-review](../skill-library-review/SKILL.md) — audits of skill/agent definitions
- [content-ops](../content-ops/SKILL.md) — quality scoring of prose; this skill judges truth, not quality
- [findings-ledger](../findings-ledger/SKILL.md) — where Tier 2 (unevidenced) findings go instead of blocking language
```

## File: README.md
upstream: https://github.com/lazyisefficient/agentic-os/blob/main/README.md

```text
# Engineering Heresy — Agentic Framework

A collection of skills and agents for [Claude Code](https://claude.ai/code) that encode engineering workflows, content pipelines, game development, marketing ops, and more into reusable AI playbooks.

Install once, use in any project.

> Part of **[Engineering Heresy](https://geggleto.substack.com/)** by Glenn Eggleton — challenging conventional wisdom in AI and software engineering. **[Subscribe on Substack →](https://geggleto.substack.com/)**

---

## Features

AgenticOS (this repository) is a **curated library of AI playbooks** for serious, long-running work in software engineering, game development, marketing, and operations. You install it once into Claude Code; from then on, your agent can follow proven workflows instead of improvising every task from scratch.

The product is not "more agents for the sake of agents." It is a **harness** — structure, guardrails, and reusable expertise wrapped around frontier models so you get **predictable quality at lower token cost**, especially across multi-step sessions where context compression would otherwise cause drift and rework. See [NORTH_STAR.md](NORTH_STAR.md) for the design thesis.

### What you get

| Piece | What it is | How you use it |
|---|---|---|
| **Skills** (24 core, plus 14 in [opt-in packs](#opt-in-packs---with-marketing---with-games)) | Step-by-step playbooks for a kind of work — code review, Rust engineering, security review, CI/CD pipelines, etc. | Ask the agent to use a skill by name, or configure your IDE so skills are checked before every task (see [Usage](#usage)). |
| **Agents** (12 core, plus 4 in opt-in packs) | Role definitions with a mandate and tool allowlist — engineer, security-reviewer, code-reviewer, rust-engineer, etc. | Spawn explicitly ("use the code-reviewer agent") or let the orchestrator dispatch subagents for multi-step work. |
| **Commands** (3 ship to consumers) | Slash shortcuts — scaffold new skills/agents, record session facts. | `/skill-new`, `/agent-new`, `/state`. |
| **Hooks** | Small shell scripts that run on IDE events (session start, before shell, before compaction). | Installed and registered automatically; power the [awareness harness](#awareness-harness-experimental). Disable by editing your global hook config. |
| **Operating rules** | Always-on doctrine for orchestration, memory, grounding, and review tiers. | Clone this repo into a project to use the flat `CLAUDE.md` (generated from `.claude/rules/` by `scripts/build-claude-md.sh`). Not copied by the global installer. |

### Supported platform

- **[Claude Code](https://claude.ai/code)** — full install: skills, agents, hooks, and three consumer commands. Remote one-liner installs a **pinned, SHA-256–verified release** (`install.sh` / `install.ps1`).

### Workflow domains

Skills and agents are grouped by the work they cover. Invoke the one that matches your task; shapers (`prompt-shaper`, and in the packs `marketing-shaper` and `game-design-shaper`) turn vague requests into scoped briefs first. A default install ships the engineering, quality and security library; the game development and marketing domains are [opt-in packs](#opt-in-packs---with-marketing---with-games).

**Software engineering**

- Full-stack implementation (`engineer`, `devops-engineer`)
- Language specialists: Rust (`rust-engineer`), TypeScript testing (frontend/backend), data pipelines and analytics
- Smart contracts and EVM development (`web3-engineer`, `web3-smart-contract-engineering`)
- CI/CD and deployment pipelines
- Planning and task breakdown for parallel subagent dispatch
- Release coordination across a monorepo
- Codebase cost estimation (LOC/complexity → build cost)

**Quality, security, and review**

- Multi-axis code review (`code-reviewer`, `code-review-and-quality`)
- Cross-stack security audit (`security-reviewer`, `security-engineering`)
- PII scan and redaction (`security`)
- Adversarial review of formal claims — math, stats, benchmarks (`adversarial-claims-reviewer`)
- API/persistence cataloging into `DATA_MODEL.md` (`data-model-documenter`, `data-model-documentation`) with adversarial verification (`data-model-verifier`)

**Game development** (opt-in games pack: `--with-games`)

- Godot 4 + C# (`godot-engineer`)
- Phaser 3 + TypeScript (`phaser-engineer`)
- Systems design, economy balancing, IAP catalog design (`game-systems-designer`, `game-balancer`, `iap-manager`)
- End-to-end game design pipeline (`game-design-shaper`)

**Marketing, growth, and revenue** (opt-in marketing pack: `--with-marketing`)

- Marketing intake and full-spectrum execution (`marketing-shaper`, `marketer`)
- Content scoring with an expert panel (`content-ops`)
- Content production pipeline — quotes, clips, repurposing (`content-pipeline`)
- SEO, CRO, growth experiments, cold outbound, revenue attribution (`seo-ops`, `conversion-ops`, `growth-engine`, `outbound-engine`, `revenue-intelligence`)
- Karpathy-style autoresearch on conversion content (`autoresearch`)

**Browser and tooling**

- Real-browser testing via Chrome DevTools MCP (`browser-testing-with-devtools`)

**Library maintenance** (for contributors and fork maintainers)

- Scaffold conforming skills and agents (`/skill-new`, `/agent-new`)
- Structural audit of the library (`library-reviewer`, `library-investigator`, `skill-library-review`)
- Sharded full-library audit workflow (`/audit-library` — repo-local)
- Stochastic finding triage and ratchet promotion (`findings-ledger`, `/triage-findings`)

### Harness capabilities

These are features of the **framework itself**, not individual skills:

**Awareness harness (experimental)** — Fights the dominant failure mode of long agent sessions: losing track of settled decisions and existing infrastructure. Externalizes live session state in `SESSION-STATE.md`, re-injects it via hooks at session start and each turn, checkpoints before compaction, and nudges "survey before you provision." Includes deterministic metrics to compare hook-ON vs hook-OFF sessions.

**Orchestrator + ship gates** — Operating doctrine treats the main agent as an orchestrator that dispatches specialists (the `Agent` tool) instead of doing multi-step work inline. After implementation, a fixed review DAG runs: code review, security review, optional library review, and conditional data-model documentation/verification. PR checkboxes and CI (`check-pr-ship-gates`) enforce the gate. Canonical graph: [gate-dag.md](.claude/references/gate-dag.md).

**Review tiers** — Findings are sorted by reproducibility: Tier 0 deterministic checks hard-block; Tier 1 LLM findings need an evidence artifact; Tier 2 is advisory and logged to the findings ledger for recurrence-based promotion into deterministic checks.

**Persistent memory** — Two layers on Claude Code: within-session facts in `SESSION-STATE.md` and cross-session memory in `.claude/memory/`. The Codex install keeps the portable session-state layer but leaves cross-session recall to Codex's native memory system. Never hand-edit session state — use `/state` on Claude or invoke `session-state` on Codex.

**Deterministic validation** — `scripts/validate.sh` is an LLM-free gate on every PR: frontmatter, naming, dangling links, ship manifest, hook safety, tombstones for removed skills, and more. Install scripts refuse to copy a library that fails validation. Enable `.githooks` pre-commit for local enforcement.

**Pinned, verified releases** — Remote installs download a tagged tarball and abort on SHA-256 mismatch. No "track main" remote path — unreleased work installs from a local clone. Maintainer runbook: [RELEASING.md](RELEASING.md).

**Telemetry (opt-in)** — Local-first usage telemetry skill; privacy-respecting, not shipped as silent analytics.

**Security model for hooks** — Shipped hook scripts are auditable shell, no runtime network, human-reviewed before merge, and scanned by validator Invariant 8. Injected session files are treated as untrusted data. Details: [SECURITY.m
```
