Challenge

challenge — hunt the blind spots before the plan inherits them

The skill is named challenge; it is the blind-spot discovery leg of the devague method — the seventh origin skill, sitting third in flow order, between the spec leg and the plan leg:

scope -> think -> challenge -> spec-to-plan -> assign-to-workforce -> deviate -> summarize-delivery

Before this leg existed, a frame could converge on precisely stated claims while the original framing was still incomplete: open questions only captured uncertainty someone had already noticed — nothing actively hunted omitted dimensions, hidden dependencies, or assumptions shared by everyone in the frame, and no record existed of which surfaces were ever examined (issue 73's problem statement). Strictly speaking, an unknown unknown cannot be listed directly — once articulated, it becomes a known unknown. The useful capability is therefore to raise the odds of discovering blind spots and lower the cost of the surprises that remain, not to promise their elimination.

That is the surprise-cost rationale: an articulated blind spot becomes a known unknown the method can manage; an unexamined one surfaces later as a mid-run /deviate or a production surprise. Discovery before planning is cheaper than either — a proposed claim the human rejects costs minutes; the same gap found mid-fan-out stops a wave, and found in production it costs whatever the blast radius costs.

This doc is written for two readers. The operator — the main agent — runs the pass: sweeps the lenses, drives the deterministic CLI move by move, and proposes findings. The gate-owning human adjudicates: every finding lands proposed, and confirming, rejecting, or resolving it is the human exercising the existing spec gate (gate 1) — challenge adds no fourth gate, mirroring how /deviate amends gate 2 rather than adding one.

When it runs

The timing is a recorded decision — quote it, don't re-derive it:

the challenge pass runs after /think exports: challenge the converged, exported frame before devague plan new; findings reopen the frame, reconverge, and re-export the same dated spec file — /think stays self-contained (resolves q1)

— decision c17 in docs/specs/2026-07-15-challenge-skill.md.

Concretely: /think finishes its own arc (converge, export) untouched. Then /challenge pressure-tests the exported spec before devague plan new seeds a plan from it. Findings land as proposed claims, honesty conditions, questions, or parks — which reopens the frame — the human adjudicates, the frame reconverges, and devague export re-exports the same dated file (docs/specs/<created-date>-<slug>.md; exports are prefixed with the frame's creation date, so a re-export overwrites in place rather than spawning a duplicate). That reconverge-and-re-export loop repeats until the pass's findings are all adjudicated and the spec artifact carries them.

Proportionality — scale the pass to the risk

The pass is mandatory but proportional: lightweight for ordinary work, rigorous for high-risk work (integration option 1 from issue 73, per the issue author — a distinct operator skill, no new CLI engine until the workflow proves it needs one). Which work is high-risk is likewise a recorded decision:

the named escalation signals that deepen the pass from lightweight to rigorous: migrations, security-sensitive work, distributed state, hardware, destructive operations, other hard-to-reverse changes, concurrency hazards, and any surface that can lose user data (resolves q3)

— decision c19 in docs/specs/2026-07-15-challenge-skill.md.

If any escalation signal applies, run the rigorous form: every lens, deliberate counter-evidence hunting, and cheap probes where they would settle a real question. If none applies, a lightweight sweep — one pass over the lenses against the exported spec, minutes not hours — satisfies the method. Lightweight never means skipped: even the lightest pass leaves durable records (see the hard rules).

The lenses

Sweep the exported spec, the live frame, and the surfaces the idea touches through these structured lenses (from issue 73):

• adjacent systems and hidden dependencies — what else reads, writes, or assumes the thing being changed;
• unstated assumptions and missing counter-evidence — what everyone in the frame believes without a claim saying so, and what was never checked because nobody argued the other side;
• overlooked actors, lifecycle stages, data flows, and failure modes — who and what the frame forgot: other users, upgrade/downgrade paths, half-completed operations;
• security, migration, concurrency, operations, and reversibility — the classic hard surfaces, each also an escalation signal when present;
• missing observability, containment, rollback, and recovery paths — when the surprise happens anyway, how it is seen, bounded, and undone;
• cheap probes or experiments — small, scratch-space checks that could expose a surprise now instead of mid-run (probes never mutate the repo or .devague/ state).

The method

1. Confirm the entry condition. A converged frame that /think has already exported, and no plan seeded from it yet (devague status shows where the frame stands; the exported spec-md is the artifact under challenge).
2. Set the depth. Check the idea against the c19 escalation signals above. Any hit → rigorous; none → lightweight. Say which you chose and why — the depth decision is part of the pass's record.
3. Sweep the lenses read-only. Read the exported spec claim by claim, the frame's parked vagueness and resolved questions, and the actual surfaces the idea touches. Nothing mutates during the sweep; the only mutations are the deterministic moves that record findings.
4. Route every finding through an existing move. Use the routing table below. Everything the agent proposes carries --origin llm and lands proposed — the pass cannot silently convert speculation into confirmed requirements.
5. Let the human adjudicate. devague review lists every proposal with ids; devague confirm / devague reject / devague question --resolve are user-only decisions. This is the existing spec gate doing its job.
6. Reconverge and re-export. devague converge, then devague export — the same dated spec file now carries the adjudicated findings and the pass's provenance (the exported spec renders scope entries in its Scope exploration section).
7. On a clean pass, record the pass itself. A sweep that finds nothing still records which lenses and surfaces were examined (devague scope entries, one per lens/surface, e.g. challenge pass / concurrency lens: devague/store.py) and what residual uncertainty remains (park). A bare "no issues found" is not an outcome this skill produces.

Where findings land

Challenge keeps no parallel prose-only artifact — the frame is the record, and every output category from issue 73 has an existing deterministic move to land in:

Every finding names the lens and surface it came from (the challenge pass / <lens>: <surface> convention in scope entries; provenance citations inside claim text). That provenance bar is how the method hunts blind spots without encouraging speculative issue generation — a finding you cannot trace to something you actually read is speculation, not a finding.