⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

adversarial-claims-reviewer

lazyisefficient@lazyisefficient⭐ 17 stars· last commit 18d ago· 35 open issues

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.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 17 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Engineering Heresy — Agentic Framework

A collection of skills and agents for Claude 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 by Glenn Eggleton — challenging conventional wisdom in AI and software engineering. Subscribe on Substack →


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 for the design thesis.

What you get

PieceWhat it isHow you use it
Skills (24 core, plus 14 in opt-in packs)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).
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.
HooksSmall shell scripts that run on IDE events (session start, before shell, before compaction).Installed and registered automatically; power the awareness harness. Disable by editing your global hook config.
Operating rulesAlways-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 — 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.

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.

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.

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

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • .claude/skills/adversarial-claims-reviewer/SKILL.md6.6 KBupstream ↗
    ---
    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
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/lazyisefficient-agentic-os-claude-skills-adversarial-claims-reviewer.md

// REPO STATS

17 stars
35 open issues
Last commit: 18d ago