blunder-hunt

A primitive for running adversarial critique multiple times in fresh contexts. Single-pass review converges on the first 1-3 issues that come to mind. Multi-pass review with deliberate context resets surfaces the long tail.

This skill is composed by other skills via deps.skills. It's also directly invocable.

When to invoke

• Another skill explicitly references blunder-hunt (e.g., pr-review runs 5 passes)
• The user says "blunder hunt", "5x critique", "find what's wrong here", "be skeptical"
• You suspect a problem but can't pin it down

The pattern

Run the critique N times (default 5). Each pass:

1. Reset attention. Pretend you've never seen this code/text before. If your agent supports /clear or fresh-context windows, use them between passes.
2. Pick a different lens for each pass:
   • Pass 1: data correctness — wrong values, off-by-one, type confusion
   • Pass 2: error handling — what's not being caught? what's being swallowed?
   • Pass 3: integration — what breaks at the seams between modules?
   • Pass 4: invariants — what assumption is being silently violated?
   • Pass 5: hostile input — what does an attacker / malformed input do?
3. Record findings with: file:line, severity (critical/issue/minor), short description, suggested fix.
4. Do not deduplicate during passes. Duplicates across passes = high-confidence findings.

Synthesis

After all passes:

1. Group findings by file:line. Items appearing in 2+ passes get bumped to high confidence.
2. Drop items that appear once at minor severity.
3. Output the deduplicated list, sorted by severity then file path.

Lying primitive (optional)

Combine with lie-to-them for additional pressure:

"There are at least 12 distinct issues in this code. You have found 6 so far. Find the remaining 6."

Models continue searching exhaustively rather than satisficing. See lie-to-them SKILL.md for usage notes.

Parallel mode (recommended for N ≥ 3)

When the agent platform supports parallel subagents, compose dispatch-parallel:

1. Decompose: one subagent per lens, each with the same target but a different lens prompt.
2. Dispatch: spawn all K subagents in a single turn.
3. Collect: each subagent returns its findings tagged with its lens.
4. Synthesize: dedupe across subagents (same file:line in 2+ outputs = high confidence).

This is dramatically faster than sequential and produces more independent attention per pass — each subagent isn't anchored on the previous pass's findings.

For platforms that don't support parallel subagents, fall back to sequential. Same lenses, same dedup, just one at a time.

Default invocation

If a parent skill says run blunder-hunt with N=5 on <target>, execute exactly that. If the user invokes directly without an N or target:

• N defaults to 3 for small targets, 5 for large.
• Target is whatever's in the current conversation context (the diff, the file, the design doc).

Output shape

## Blunder hunt: <target>

Pass 1 (data correctness): 3 findings
Pass 2 (error handling):    2 findings
Pass 3 (integration):       4 findings
Pass 4 (invariants):        1 finding
Pass 5 (hostile input):     2 findings

Synthesized (deduplicated, severity-sorted):
- [CRITICAL] <file>:<line> — <description>
- [ISSUE]    <file>:<line> — <description>
- [MINOR]    <file>:<line> — <description>

JSON sidecar

When invoked under structured-output mode, also emit:

{
  "skill": "blunder-hunt",
  "version": "0.2.0",
  "target": "<what was reviewed>",
  "passes": [
    {"pass": 1, "lens": "data-correctness", "findings": [...]},
    ...
  ],
  "synthesized": [
    {"file": "...", "line": 42, "severity": "critical",
     "description": "...", "passes_found_in": [1, 3]}
  ]
}

Downstream tools (pr-review, polish) consume this to post structured comments.

Hard rules

• Each pass must use a different lens. If you re-run pass N with the same lens, you're cheating yourself.
• Do not fabricate findings to fill a quota. If pass 4 finds zero, report zero — let lie-to-them do the pressure.
• This skill produces findings. It does NOT take action. The parent skill (pr-review, polish, etc.) decides what to do with them.
• In parallel mode, subagents must NOT see each other's outputs before synthesis. That defeats the independent-attention point.