self-critique

name	self-critique
description	Adversarially critique your own last substantial answer before the user has to. Spawn a critic agent that verifies every claim against live sources, checks similar and related issues, finds patterns, and addresses comments directly to you. Loop (revise, re-score) until satisfied, then report where you were wrong, iterations-to-satisfy, the numeric improvement, and a final score. Use when the user asks you to criticize, challenge, stress-test, or red-team your own answer, or accepts a "critical-thinking review" offer.
license	MIT
compatibility	Codex, Claude Code, Cursor, and other Agent Skills compatible tools.
metadata	{"targets":["cursor"],"author":"Oleg Koval","tags":["critical-thinking","self-review","verification","adversarial","agents","quality"]}

Self-critique

Run an adversarial review of your own previous answer and report the result in numbers.

Overview

A confident answer is not a verified one. This skill turns your last substantial reply into the subject of a hostile review: a separate critic agent tries to refute it against live sources, hunts for the related issue or pattern you missed, and scores it. You then revise and re-score until the score stops moving, and report the outcome honestly, including where you were wrong.

The point is to surface error before the user does, and to make "is this actually right?" a measured quantity instead of a vibe.

When to Use

• The user asks you to criticize, challenge, stress-test, red-team, or "poke holes in" your own answer.
• The user accepts a "critical-thinking review" offer.
• You have just produced a substantial analysis, recommendation, or investigation and want a confidence number before the user acts on it.

Do not use for trivial one-shot replies or simple chat. The overhead only pays off on load-bearing answers.

Procedure

1. Snapshot the target. Capture your last substantial answer verbatim, plus the concrete claims it makes and the source each claim rests on. This is v1.

2. Spawn the critic. Launch one independent agent with live-source access (issue tracker, code host, error monitor, the repo). Use the prompt template below. The critic must return: score (0-100), verdict (AGREE / AGREE-WITH-CAVEATS / DISAGREE), where_wrong (list), missed (related issues or patterns you failed to surface), unverifiable (claims it could not confirm), and fixes (ranked, actionable).

3. Decide and loop. Stop if score >= 90 OR no actionable fixes remain. Otherwise revise the answer using the fixes to produce v2, then re-spawn the critic to score v2. Repeat. Hard cap: 3 critic rounds. (A known ceiling: raise it only if a round is still finding real, fixable defects.)

4. Report, always, even after a single round:

   • Where you were wrong - consolidated, each item with the receipt the critic cited.
   • Iterations to satisfy - how many critic rounds it took to reach the stop condition (1 means it was solid on the first pass).
   • Improvement in numbers - the score trajectory, for example 72 -> 88 -> 94 (+22 pts, +31%). If only one round ran, state no revision needed.
   • Final score - the critic's last score and verdict.
   • Unverifiable - anything you should not present as fact.

Critic prompt template

Pass this to the critic agent, filling in the two placeholders. It is deliberately adversarial: the default stance is that the answer is wrong until a live source proves otherwise.

You are an adversarial reviewer. Your job is to verify and, where possible, refute the answer below. Default to skepticism: assume a claim is wrong until a live source proves it. Address every comment directly to the author ("You claimed X; the source says Y").

The answer under review (verbatim): {{ANSWER}}

Its claims and the source each rests on: {{CLAIMS_AND_SOURCES}}

Do this:

1. Re-verify every claim against the live source (issue tracker / code host / error monitor / the repo) - never trust the answer's own summary. Quote the field, line, PR body, or issue you checked.
2. Check similar and related issues, and find patterns. Is this part of a cluster? Is there a closer sibling, parent epic, or duplicate the answer should have surfaced but did not? Name it with its ID and the shared signal (same error, same code path, same root cause).
3. Stress-test the strongest load-bearing claim and the answer's biggest blind spot specifically. Where is it over-confident? Where is symptom-level reasoning passing itself off as a proven root cause?
4. List exactly where the author was wrong or imprecise, and what they missed.
5. Flag any claim you could not verify so it is not presented as fact.

Output, terse, with a receipt for every line:

• verdict: AGREE | AGREE-WITH-CAVEATS | DISAGREE
• score: 0-100 (rubric: 100 = every claim verified, nothing missed, confidence correctly calibrated; subtract for each unverified claim, each missed sibling or pattern, and each over- or under-statement)
• where_wrong: bullet list, each with its source receipt
• missed: related issues or patterns the author failed to surface, with IDs
• unverifiable: claims that need a source you do not have
• fixes: ranked, actionable - what to change to raise the score

Optional: auto-offer via a Claude Code Stop hook

A hook is a shell command, so it cannot run this loop itself. What it can do is nudge: after a substantial answer, it offers the review and you run the skill only if the user says yes.

The hook ships with this skill at scripts/critique-nudge.mjs. Register it as a Stop hook in your Claude Code settings (.claude/settings.json for a team, .claude/settings.local.json for yourself):

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/critique-nudge.mjs\"",
            "timeout": 15
          }
        ]
      }
    ]
  }
}

Copy scripts/critique-nudge.mjs to .claude/hooks/critique-nudge.mjs (or point the command at wherever you keep it). After an answer whose final prose is at least 1500 characters, the hook blocks the turn once and instructs the agent to append a one-line "critical-thinking review" offer, then stop. Two loop guards keep it from firing forever: it does nothing when stop_hook_active is set, and nothing when the answer already contains the offer phrase. On any malformed input it exits silently and never blocks the user.

The 1500-character threshold is a heuristic with a known ceiling: it misses short but dense tool-heavy turns. If that matters, extend the script to also count tool calls since the last user message.

Notes

• One critic round is fine and common. If the answer was already solid, report iterations: 1, no revision needed and the single score rather than forcing a revision.
• Diversity beats redundancy: if a claim can fail in more than one way, give the critic distinct lenses (correctness, completeness, does-it-reproduce) instead of repeating the same check.
• The critic verifies against live sources; it does not rewrite the answer. You revise; it re-scores.