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, report the outcome honestly, including where you were wrong, and convert what
the critic caught into a rule that survives the session.
The point is to surface error before the user does, to make "is this actually right?" a measured
quantity instead of a vibe, and to make the same mistake cost less the second time than it did the
first. A critique that ends at a score has bought one corrected answer. A critique that ends at a
durable rule has bought every answer after it.
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.
Standalone Cursor installation. Use the generated Cursor adapter or the full skill package,
including its scripts/ directory. Copying only SKILL.md is insufficient for this workflow,
which calls the bundled scripts.
Procedure
Snapshot the target. Capture your last substantial answer verbatim and the original task
text. This is v1.
Write your claim list before you re-read the answer's prose, and put a real receipt against each
claim: a quoted field, a file:line whose body you actually opened, a command and its output.
A claim you cannot receipt at snapshot time is already a finding - mark it unverifiable yourself
rather than waiting for the critic to find it. Grep output, a file name, a path, an endpoint
string, or the behaviour of a sibling module are not receipts for what code does; they prove
those things exist, not what they do.
Save the list to .self-critique/author-claims.json as an array of
{ id, text, load_bearing, receipt }. Do NOT show it to the critic in round one.
Replay pass. Before spawning the critic, check the answer against every stored rule. Resolve
the memory dir as the auto-memory dir for the current project, else the repo's .claude/memory;
if neither exists, skip replay, evidence-check, and prune with a one-line note. Run
node <skill>/scripts/rule-store.mjs checklist --dir <memory dir>, then open each listed rule's
memory file and read its body before testing the answer against it. The checklist's names and
descriptions alone are insufficient. Tag each hit (recurring) in the report and record it with
node <skill>/scripts/rule-store.mjs fire <name> --dir <memory dir> --date <today>.
Fire counters and pruning apply only to rules in this memory directory. Rules routed to
CLAUDE.md, AGENTS.md, or the shared store are neither counted nor pruned.
Spawn the critic (blind). Launch one independent agent with live-source access (issue tracker,
code host, error monitor, the repo). Round one input is the original task text and the answer
verbatim, nothing else: the critic extracts the claims itself and never sees your list or sources.
Use the prompt template below. The critic must return one fenced JSON block with claims (its own
list, each { text, load_bearing, status, checked_by, receipt }), missed, where_wrong,
shapes and verdict (AGREE / AGREE-WITH-CAVEATS / DISAGREE). There is no score field: the
score is computed in Step 2b.
2b. Merge into the ledger. Match the critic's claims to yours by meaning and set origin on
each: both, author (only you found it), critic (only the critic found it). Every critic
finding with checked_by: inferred must be re-verified by you before it may become verified
or refuted; if you cannot verify it, it stays inferred. Both statuses require
checked_by: command or checked_by: read and a non-empty receipt; validation rejects inferred evidence or a missing
receipt. Save .self-critique/ledger-v1.json, then run
node <skill>/scripts/claim-ledger.mjs score .self-critique/ledger-v1.json and
node <skill>/scripts/claim-ledger.mjs summary .self-critique/ledger-v1.json (an invalid ledger
exits 2 and prints the errors as JSON).
Claims found by only one side are reported under their own heading, "Asymmetric claims".
Ledger shape (version is always 1):
{ "version": 1,
"claims": [{ "id": "c1", "text": "...", "load_bearing": true, "origin": "both",
"status": "verified", "checked_by": "command", "receipt": "quoted output" }],
"missed": [{ "id": "m1", "text": "...", "load_bearing": false, "checked_by": "read" }] }
origin: author | critic | both
status: verified | refuted | unverifiable | inferred
checked_by: command (run, output quoted) | read (file or record opened, quoted) |
inferred (reasoning only). Required on missed items too; an inferred missed item is not
penalised. A verified or refuted claim may not use inferred evidence and requires a
non-empty receipt.
Decide and loop. Accept a score of at least 90 only after all fixable findings are resolved
or explicitly qualified in the answer and report; otherwise continue the critique loop. Stop
when that condition holds, OR no ledger item is left that a revision could fix, OR 3 rounds have run.
Otherwise revise the answer to produce v2, write ledger-v2.json, and run
node <skill>/scripts/claim-ledger.mjs ratchet .self-critique/ledger-v1.json .self-critique/ledger-v2.json
on the previous and new ledger: a lower re-score discards the revision, and you keep the winner. Round
two and later hand the critic your receipts for the still-open claims (it is no longer blind).
Hard cap: 3 critic rounds. (A known ceiling: raise it only if a round is still finding real,
fixable defects.)
Cost. The critic runs on a mid-tier model (Sonnet class) by default. Escalate one tier only
when a mid-tier round found nothing and the answer is load-bearing. When the budget is tight,
verify load-bearing claims first.
Report, always, even after a single round. In this order:
- Corrected answer (
v_final) - restated in full, not as a diff, so the user can act on it
without reading anything else. After a single round with no revision, restate v1 unchanged.
- Claim ledger - run
node <skill>/scripts/claim-ledger.mjs summary <ledger for v_final>
and node <skill>/scripts/claim-ledger.mjs score <ledger for v_final> using the ledger for
whichever version the ratchet accepted (for example, .self-critique/ledger-v2.json). Report
that table and its computed score.
- Where you were wrong - consolidated, each item with the receipt the critic cited.
- Asymmetric claims - claims only you found, and claims only the critic found.
- Recurring rules fired - each stored rule the replay pass hit, with its new
fires count.
- Iterations to satisfy - how many critic rounds it took (1 means it was solid first pass).
- Score trajectory - for example
72 -> 88 -> 94 (+22 pts), all computed scores. If only one
round ran, state no revision needed.
- Unverifiable - anything you should not present as fact.
- Declined findings - ledger items you chose not to fix, with the reason. Silently dropping
one looks identical to missing it.
- Rules written - where each rule went and what it says (see Step 5).
- Rules proposed for deletion - the candidates from the prune pass, or
none.
Convert the outcome into a durable rule. See below. Skipping this step is what makes the
same critique necessary again next week.
Step 5: turn the critique into something that outlives the session
A score is a measurement, not an improvement. The improvement is the rule you write down, in a
place a future session actually reads, before you move on.
Not every finding earns a rule. Write one only when the finding passes both gates:
- Recurrence - the same shape of mistake could plausibly happen again on a different task.
- Cost - it would have reached the user, cost real rework, or damaged their credibility with
someone else.
A one-off factual slip, a typo, or a finding fully explained by this task's specifics fails both.
Writing a rule for it pollutes the store, and a littered store is worse than a thin one, because
the next session stops reading it.
Write the shape, not the incident. The incident is the evidence; the shape is the rule. Ask
what class of reasoning produced the error, then name that class:
| Incident |
Shape worth keeping |
| Called an endpoint a read because the path was a noun and a sibling module imported |
A conclusion drawn from evidence that does not cover the claim |
| Priced an open design question as "small" in the same sentence that asked which design was wanted |
Never attach a size to an answer you are simultaneously asking for |
| Described a batch from the one member that was checked |
Check the risk-deciding field on every member before describing the set |
Route it to the narrowest store the host has, in this order, and only one of them:
- The user's or project's agent memory, when the rule is about how to work with this user or this
project.
- The repository's own
CLAUDE.md / AGENTS.md, when the rule is true only inside that codebase.
- A shared, cross-session store, when the rule holds across projects. Use
context-repo to resolve
it, or shared-knowledge-artifact when several agents need to read the same ledger.
Broadening a rule's scope so it qualifies for a wider store is the failure mode to avoid: one
incident on one afternoon is not standing policy. Let the evidence decide where it lands.
Each rule carries three things. Without all three the next session cannot act on it:
- The rule, stated as the shape, in the imperative.
- Why, with the incident and its receipt, dated. A rule with no cost attached gets argued away.
- How to apply, naming the moment the rule fires ("before drafting outbound text", "before
describing a batch"), not just the principle.
Before writing to shared persistence, redact the incident evidence, including when using
context-repo or shared-knowledge-artifact, while still including the incident and its dated
receipt. This redaction requirement does not apply to local agent memory or repository-rule writes.
Dedupe before writing. Read the store first. If a rule of the same shape exists, add one dated
evidence line to it instead of creating a second entry, with at most three evidence lines per rule.
A fourth incident means the rule named the incident, not the shape: rewrite the rule text and keep
the three most recent evidence lines. Link related rules instead of restating them. Only when the
memory directory resolved in Step 1 exists, run
node <skill>/scripts/rule-store.mjs evidence-check --dir <memory dir> before writing and report
any rule it flags. Skip this command when neither supported memory directory exists.
Memory rule identity and counters. Mark each rule stored by this workflow with
rule_store: self-critique under metadata: in its memory file's frontmatter. Mark an existing
rule only after reading it and confirming it belongs to this workflow. Only marked rules are
pruning candidates; unrelated project and user memories are excluded. A memory rule's fires and
last_fired live under metadata: and are written only by fire. Rules routed to CLAUDE.md,
AGENTS.md, or the shared store are neither counted nor pruned.
Prune pass. At the end of this step, only when a valid memory directory is available, run
node <skill>/scripts/rule-store.mjs prune --dir <memory dir> --idle-days 60. List the candidates
in the report under "Rules proposed for deletion". Skip this command when neither supported memory
directory exists. Never delete a rule without the user's reply.
Then close the loop. State in your report where the rule was written and what it says, so the
user can veto it. A rule the user has not seen is a rule they cannot correct.
Critic prompt template
Pass this to the critic agent, filling in the two placeholders ({{TASK}}, {{ANSWER}}). 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 task the author was given (verbatim):
{{TASK}}
The answer under review (verbatim):
{{ANSWER}}
You are not given the author's claims or sources. Extract the claims yourself.
Do this:
- List every claim the answer makes, marking each
load_bearing (the user would act on it).
Re-verify each 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.
- 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).
- 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?
- List exactly where the author was wrong or imprecise, and what they missed.
- Flag any claim you could not verify so it is not presented as fact.
- Label every finding with
checked_by: command (you ran it and quote the output), read (you
opened the file or record and quote it), inferred (reasoning only).
Output, terse, one fenced JSON block, a receipt for every item:
claims: your own list, each { text, load_bearing, status, checked_by, receipt } with status
one of verified | refuted | unverifiable | inferred
missed: related issues or patterns the author failed to surface, each
{ text, load_bearing, checked_by, receipt }, with IDs
where_wrong: bullet list, each with its source receipt and checked_by
shapes: for each item in where_wrong, the class of reasoning that produced it, stated so it
would apply to a different task ("a conclusion drawn from evidence that does not cover the
claim"), not the incident itself. Say one-off when the error has no reusable shape.
verdict: AGREE | AGREE-WITH-CAVEATS | DISAGREE
Do not output a score. It is computed from your claims.
Score anchors
The score is 100 minus penalties, floored at 0. Calibrate against these three ledgers (all claims
origin: both; node <skill>/scripts/claim-ledger.mjs anchors prints them as JSON).
Strong, score 95
| id |
load_bearing |
status |
checked_by |
| a1 |
no |
inferred |
inferred |
Middling, score 72
| id |
load_bearing |
status |
checked_by |
| b1 |
no |
refuted |
read |
| b2 |
no |
refuted |
read |
| b3 |
no |
unverifiable |
read |
| b4 |
no |
unverifiable |
read |
Weak, score 40
| id |
load_bearing |
status |
checked_by |
| c1 |
yes |
refuted |
read |
| c2 |
yes |
refuted |
read |
| c3 |
yes |
unverifiable |
read |
Penalties:
| Finding |
Points off |
| refuted, load-bearing |
25 |
| refuted |
10 |
| unverifiable, load-bearing |
10 |
| unverifiable |
4 |
| inferred, accepted |
5 |
| missed, load-bearing |
15 |
| missed |
5 |
| verified but found only by the critic |
5 |
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 or score it. You revise;
the score is recomputed from the ledger.
- In round two, hand the critic your receipts for the claims still open, so it spends its budget on
the claims still standing instead of re-deriving the ones already settled.
- A critic finding you disagree with is worth one challenge. Put the reasoning to it and let it rule;
if it concedes, that is a real answer for the report, and the reasoning is what the user needs to
see either way.
- The honest test of Step 5 is not that a rule was written, it is that the next task of the same
class does not need this skill to catch the same thing. If it does, the rule named the incident
instead of the shape - rewrite it, do not add another.
1---2name: self-critique3description: "Adversarially critique your own last answer: a blind critic agent re-derives and verifies every claim against live sources, the score is computed from a labelled claim ledger, you revise under a ratchet, restate the corrected answer, and turn each caught error into a durable rule with a fire counter."4license: MIT5compatibility: Codex, Claude Code, Cursor, and other Agent Skills compatible tools.6metadata:7 source: https://skillmd.com/skills/oleg-koval/self-critique8 author: Oleg Koval9 tags:10 - critical-thinking11 - self-review12 - verification13 - adversarial14 - agents15 - quality16---1718# Self-critique1920Run an adversarial review of **your own previous answer** and report the result in numbers.2122## Overview2324A confident answer is not a verified one. This skill turns your last substantial reply into the25subject of a hostile review: a separate critic agent tries to refute it against live sources, hunts26for the related issue or pattern you missed, and scores it. You then revise and re-score until the27score stops moving, report the outcome honestly, including where you were wrong, and convert what28the critic caught into a rule that survives the session.2930The point is to surface error before the user does, to make "is this actually right?" a measured31quantity instead of a vibe, and to make the same mistake cost less the second time than it did the32first. A critique that ends at a score has bought one corrected answer. A critique that ends at a33durable rule has bought every answer after it.3435## When to Use3637- The user asks you to criticize, challenge, stress-test, red-team, or "poke holes in" your own answer.38- The user accepts a "critical-thinking review" offer.39- You have just produced a substantial analysis, recommendation, or investigation and want a40 confidence number before the user acts on it.4142Do not use for trivial one-shot replies or simple chat. The overhead only pays off on load-bearing43answers.4445**Standalone Cursor installation.** Use the generated Cursor adapter or the full skill package,46including its `scripts/` directory. Copying only `SKILL.md` is insufficient for this workflow,47which calls the bundled scripts.4849## Procedure50511. **Snapshot the target.** Capture your last substantial answer verbatim and the original task52 text. This is `v1`.5354 Write your claim list before you re-read the answer's prose, and put a real receipt against each55 claim: a quoted field, a `file:line` whose body you actually opened, a command and its output.56 A claim you cannot receipt at snapshot time is already a finding - mark it `unverifiable` yourself57 rather than waiting for the critic to find it. Grep output, a file name, a path, an endpoint58 string, or the behaviour of a sibling module are not receipts for what code does; they prove59 those things exist, not what they do.6061 Save the list to `.self-critique/author-claims.json` as an array of62 `{ id, text, load_bearing, receipt }`. Do NOT show it to the critic in round one.6364 **Replay pass.** Before spawning the critic, check the answer against every stored rule. Resolve65 the memory dir as the auto-memory dir for the current project, else the repo's `.claude/memory`;66 if neither exists, skip replay, evidence-check, and prune with a one-line note. Run67 `node <skill>/scripts/rule-store.mjs checklist --dir <memory dir>`, then open each listed rule's68 memory file and read its body before testing the answer against it. The checklist's names and69 descriptions alone are insufficient. Tag each hit `(recurring)` in the report and record it with70 `node <skill>/scripts/rule-store.mjs fire <name> --dir <memory dir> --date <today>`.71 Fire counters and pruning apply only to rules in this memory directory. Rules routed to72 `CLAUDE.md`, `AGENTS.md`, or the shared store are neither counted nor pruned.73742. **Spawn the critic (blind).** Launch one independent agent with live-source access (issue tracker,75 code host, error monitor, the repo). Round one input is the original task text and the answer76 verbatim, nothing else: the critic extracts the claims itself and never sees your list or sources.77 Use the prompt template below. The critic must return one fenced JSON block with `claims` (its own78 list, each `{ text, load_bearing, status, checked_by, receipt }`), `missed`, `where_wrong`,79 `shapes` and `verdict` (AGREE / AGREE-WITH-CAVEATS / DISAGREE). There is no `score` field: the80 score is computed in Step 2b.81822b. **Merge into the ledger.** Match the critic's claims to yours by meaning and set `origin` on83 each: `both`, `author` (only you found it), `critic` (only the critic found it). Every critic84 finding with `checked_by: inferred` must be re-verified by you before it may become `verified`85 or `refuted`; if you cannot verify it, it stays `inferred`. Both statuses require86 `checked_by: command` or `checked_by: read` and a non-empty receipt; validation rejects inferred evidence or a missing87 receipt. Save `.self-critique/ledger-v1.json`, then run88 `node <skill>/scripts/claim-ledger.mjs score .self-critique/ledger-v1.json` and89 `node <skill>/scripts/claim-ledger.mjs summary .self-critique/ledger-v1.json` (an invalid ledger90 exits 2 and prints the errors as JSON).91 Claims found by only one side are reported under their own heading, "Asymmetric claims".9293 Ledger shape (`version` is always `1`):9495 ```json96 { "version": 1,97 "claims": [{ "id": "c1", "text": "...", "load_bearing": true, "origin": "both",98 "status": "verified", "checked_by": "command", "receipt": "quoted output" }],99 "missed": [{ "id": "m1", "text": "...", "load_bearing": false, "checked_by": "read" }] }100 ```101102 - `origin`: `author` | `critic` | `both`103 - `status`: `verified` | `refuted` | `unverifiable` | `inferred`104 - `checked_by`: `command` (run, output quoted) | `read` (file or record opened, quoted) |105 `inferred` (reasoning only). Required on `missed` items too; an `inferred` missed item is not106 penalised. A `verified` or `refuted` claim may not use inferred evidence and requires a107 non-empty receipt.1081093. **Decide and loop.** Accept a score of at least 90 only after all fixable findings are resolved110 or explicitly qualified in the answer and report; otherwise continue the critique loop. Stop111 when that condition holds, OR no ledger item is left that a revision could fix, OR 3 rounds have run.112 Otherwise revise the answer to produce `v2`, write `ledger-v2.json`, and run113 `node <skill>/scripts/claim-ledger.mjs ratchet .self-critique/ledger-v1.json .self-critique/ledger-v2.json`114 on the previous and new ledger: a lower re-score discards the revision, and you keep the winner. Round115 two and later hand the critic your receipts for the still-open claims (it is no longer blind).116 **Hard cap: 3 critic rounds.** (A known ceiling: raise it only if a round is still finding real,117 fixable defects.)118119 **Cost.** The critic runs on a mid-tier model (Sonnet class) by default. Escalate one tier only120 when a mid-tier round found nothing and the answer is load-bearing. When the budget is tight,121 verify load-bearing claims first.1221234. **Report, always, even after a single round.** In this order:124 - **Corrected answer (`v_final`)** - restated in full, not as a diff, so the user can act on it125 without reading anything else. After a single round with no revision, restate `v1` unchanged.126 - **Claim ledger** - run `node <skill>/scripts/claim-ledger.mjs summary <ledger for v_final>`127 and `node <skill>/scripts/claim-ledger.mjs score <ledger for v_final>` using the ledger for128 whichever version the ratchet accepted (for example, `.self-critique/ledger-v2.json`). Report129 that table and its computed score.130 - **Where you were wrong** - consolidated, each item with the receipt the critic cited.131 - **Asymmetric claims** - claims only you found, and claims only the critic found.132 - **Recurring rules fired** - each stored rule the replay pass hit, with its new `fires` count.133 - **Iterations to satisfy** - how many critic rounds it took (1 means it was solid first pass).134 - **Score trajectory** - for example `72 -> 88 -> 94 (+22 pts)`, all computed scores. If only one135 round ran, state `no revision needed`.136 - **Unverifiable** - anything you should not present as fact.137 - **Declined findings** - ledger items you chose not to fix, with the reason. Silently dropping138 one looks identical to missing it.139 - **Rules written** - where each rule went and what it says (see Step 5).140 - **Rules proposed for deletion** - the candidates from the prune pass, or `none`.1411425. **Convert the outcome into a durable rule.** See below. Skipping this step is what makes the143 same critique necessary again next week.144145## Step 5: turn the critique into something that outlives the session146147A score is a measurement, not an improvement. The improvement is the rule you write down, in a148place a future session actually reads, before you move on.149150**Not every finding earns a rule.** Write one only when the finding passes both gates:151152- **Recurrence** - the same *shape* of mistake could plausibly happen again on a different task.153- **Cost** - it would have reached the user, cost real rework, or damaged their credibility with154 someone else.155156A one-off factual slip, a typo, or a finding fully explained by this task's specifics fails both.157Writing a rule for it pollutes the store, and a littered store is worse than a thin one, because158the next session stops reading it.159160**Write the shape, not the incident.** The incident is the evidence; the shape is the rule. Ask161what class of reasoning produced the error, then name that class:162163| Incident | Shape worth keeping |164| --- | --- |165| Called an endpoint a read because the path was a noun and a sibling module imported | A conclusion drawn from evidence that does not cover the claim |166| Priced an open design question as "small" in the same sentence that asked which design was wanted | Never attach a size to an answer you are simultaneously asking for |167| Described a batch from the one member that was checked | Check the risk-deciding field on every member before describing the set |168169**Route it to the narrowest store the host has**, in this order, and only one of them:1701711. The user's or project's agent memory, when the rule is about how to work with this user or this172 project.1732. The repository's own `CLAUDE.md` / `AGENTS.md`, when the rule is true only inside that codebase.1743. A shared, cross-session store, when the rule holds across projects. Use `context-repo` to resolve175 it, or `shared-knowledge-artifact` when several agents need to read the same ledger.176177Broadening a rule's scope so it qualifies for a wider store is the failure mode to avoid: one178incident on one afternoon is not standing policy. Let the evidence decide where it lands.179180**Each rule carries three things.** Without all three the next session cannot act on it:181182- **The rule**, stated as the shape, in the imperative.183- **Why**, with the incident and its receipt, dated. A rule with no cost attached gets argued away.184- **How to apply**, naming the moment the rule fires ("before drafting outbound text", "before185 describing a batch"), not just the principle.186187Before writing to shared persistence, redact the incident evidence, including when using188`context-repo` or `shared-knowledge-artifact`, while still including the incident and its dated189receipt. This redaction requirement does not apply to local agent memory or repository-rule writes.190191**Dedupe before writing.** Read the store first. If a rule of the same shape exists, add one dated192evidence line to it instead of creating a second entry, with at most three evidence lines per rule.193A fourth incident means the rule named the incident, not the shape: rewrite the rule text and keep194the three most recent evidence lines. Link related rules instead of restating them. Only when the195memory directory resolved in Step 1 exists, run196`node <skill>/scripts/rule-store.mjs evidence-check --dir <memory dir>` before writing and report197any rule it flags. Skip this command when neither supported memory directory exists.198199**Memory rule identity and counters.** Mark each rule stored by this workflow with200`rule_store: self-critique` under `metadata:` in its memory file's frontmatter. Mark an existing201rule only after reading it and confirming it belongs to this workflow. Only marked rules are202pruning candidates; unrelated project and user memories are excluded. A memory rule's `fires` and203`last_fired` live under `metadata:` and are written only by `fire`. Rules routed to `CLAUDE.md`,204`AGENTS.md`, or the shared store are neither counted nor pruned.205206**Prune pass.** At the end of this step, only when a valid memory directory is available, run207`node <skill>/scripts/rule-store.mjs prune --dir <memory dir> --idle-days 60`. List the candidates208in the report under "Rules proposed for deletion". Skip this command when neither supported memory209directory exists. Never delete a rule without the user's reply.210211**Then close the loop.** State in your report where the rule was written and what it says, so the212user can veto it. A rule the user has not seen is a rule they cannot correct.213214## Critic prompt template215216Pass this to the critic agent, filling in the two placeholders (`{{TASK}}`, `{{ANSWER}}`). It is deliberately adversarial:217the default stance is that the answer is wrong until a live source proves otherwise.218219> You are an adversarial reviewer. Your job is to verify and, where possible, **refute** the answer220> below. Default to skepticism: assume a claim is wrong until a live source proves it. Address every221> comment **directly to the author** ("You claimed X; the source says Y").222>223> **The task the author was given (verbatim):**224> {{TASK}}225>226> **The answer under review (verbatim):**227> {{ANSWER}}228>229> You are not given the author's claims or sources. Extract the claims yourself.230>231> **Do this:**232> 1. List every claim the answer makes, marking each `load_bearing` (the user would act on it).233> Re-verify each against the **live** source (issue tracker / code host / error monitor / the234> repo) - never trust the answer's own summary. Quote the field, line, PR body, or issue you235> checked.236> 2. **Check similar and related issues, and find patterns.** Is this part of a cluster? Is there a237> closer sibling, parent epic, or duplicate the answer should have surfaced but did not? Name it238> with its ID and the shared signal (same error, same code path, same root cause).239> 3. Stress-test the **strongest** load-bearing claim and the answer's biggest blind spot240> specifically. Where is it over-confident? Where is symptom-level reasoning passing itself off as241> a proven root cause?242> 4. List exactly **where the author was wrong or imprecise**, and what they **missed**.243> 5. Flag any claim you **could not verify** so it is not presented as fact.244> 6. Label every finding with `checked_by`: `command` (you ran it and quote the output), `read` (you245> opened the file or record and quote it), `inferred` (reasoning only).246>247> **Output, terse, one fenced JSON block, a receipt for every item:**248> - `claims`: your own list, each `{ text, load_bearing, status, checked_by, receipt }` with `status`249> one of `verified` | `refuted` | `unverifiable` | `inferred`250> - `missed`: related issues or patterns the author failed to surface, each251> `{ text, load_bearing, checked_by, receipt }`, with IDs252> - `where_wrong`: bullet list, each with its source receipt and `checked_by`253> - `shapes`: for each item in `where_wrong`, the class of reasoning that produced it, stated so it254> would apply to a different task ("a conclusion drawn from evidence that does not cover the255> claim"), not the incident itself. Say `one-off` when the error has no reusable shape.256> - `verdict`: AGREE | AGREE-WITH-CAVEATS | DISAGREE257>258> Do not output a score. It is computed from your claims.259260### Score anchors261262The score is `100` minus penalties, floored at 0. Calibrate against these three ledgers (all claims263`origin: both`; `node <skill>/scripts/claim-ledger.mjs anchors` prints them as JSON).264265**Strong, score 95**266267| id | load_bearing | status | checked_by |268| --- | --- | --- | --- |269| a1 | no | inferred | inferred |270271**Middling, score 72**272273| id | load_bearing | status | checked_by |274| --- | --- | --- | --- |275| b1 | no | refuted | read |276| b2 | no | refuted | read |277| b3 | no | unverifiable | read |278| b4 | no | unverifiable | read |279280**Weak, score 40**281282| id | load_bearing | status | checked_by |283| --- | --- | --- | --- |284| c1 | yes | refuted | read |285| c2 | yes | refuted | read |286| c3 | yes | unverifiable | read |287288Penalties:289290| Finding | Points off |291| --- | --- |292| refuted, load-bearing | 25 |293| refuted | 10 |294| unverifiable, load-bearing | 10 |295| unverifiable | 4 |296| inferred, accepted | 5 |297| missed, load-bearing | 15 |298| missed | 5 |299| verified but found only by the critic | 5 |300301## Optional: auto-offer via a Claude Code Stop hook302303A hook is a shell command, so it cannot run this loop itself. What it can do is **nudge**: after a304substantial answer, it offers the review and you run the skill only if the user says yes.305306The hook ships with this skill at `scripts/critique-nudge.mjs`. Register it as a `Stop` hook in your307Claude Code settings (`.claude/settings.json` for a team, `.claude/settings.local.json` for308yourself):309310```json311{312 "hooks": {313 "Stop": [314 {315 "hooks": [316 {317 "type": "command",318 "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/critique-nudge.mjs\"",319 "timeout": 15320 }321 ]322 }323 ]324 }325}326```327328Copy `scripts/critique-nudge.mjs` to `.claude/hooks/critique-nudge.mjs` (or point the command at329wherever you keep it). After an answer whose final prose is at least 1500 characters, the hook blocks330the turn once and instructs the agent to append a one-line "critical-thinking review" offer, then331stop. Two loop guards keep it from firing forever: it does nothing when `stop_hook_active` is set, and332nothing when the answer already contains the offer phrase. On any malformed input it exits silently333and never blocks the user.334335The 1500-character threshold is a heuristic with a known ceiling: it misses short but dense336tool-heavy turns. If that matters, extend the script to also count tool calls since the last user337message.338339## Notes340341- One critic round is fine and common. If the answer was already solid, report342 `iterations: 1, no revision needed` and the single score rather than forcing a revision.343- Diversity beats redundancy: if a claim can fail in more than one way, give the critic distinct344 lenses (correctness, completeness, does-it-reproduce) instead of repeating the same check.345- The critic verifies against live sources; it does not rewrite the answer or score it. You revise;346 the score is recomputed from the ledger.347- In round two, hand the critic your receipts for the claims still open, so it spends its budget on348 the claims still standing instead of re-deriving the ones already settled.349- A critic finding you disagree with is worth one challenge. Put the reasoning to it and let it rule;350 if it concedes, that is a real answer for the report, and the reasoning is what the user needs to351 see either way.352- The honest test of Step 5 is not that a rule was written, it is that the next task of the same353 class does not need this skill to catch the same thing. If it does, the rule named the incident354 instead of the shape - rewrite it, do not add another.