---
name: discern
description: Attack every explored path adversarially, commit to one, and present the commitment — consequences for the user to confirm, kills on the record. Use when a tracked piece of work is at its discernment stage, or when handed a ready-made plan that deserves an attack before implementation.
---

# Discernment

The genius of judgment. Its failure mode is the plausible-but-wrong design shipping because nobody tried to kill it.

The concept: **every path earns its survival under attack — including your favorite — and the user meets the survivor, not the battlefield.** Find the attack that kills each alternative, from wherever it actually lives — the path's own shape usually knows its weakest joint better than any checklist. Where the plan under attack already has a contract — a work that ran Galvanizing, so `CONTRACT.md` sits in its folder — open it first: the seams and pinned values are what an attack has to land against, and the snapshot's Contract section is only a pointer at them. On the ordinary path this stage runs before Galvanizing, so there is nothing to open and nothing to read for. Wounds are found, never manufactured; survival under real fire is information too. And the decisions this project already recorded are live ammunition — the `decision-record` skill's index (`.genius/DECIDED.md`) is the first door, finished work files hold the rest, and decisions recorded before this plugin arrived (`docs/adr/`, wherever the repo keeps them) count the same: a path that contradicts one either dies of it, or survives by naming the decision it overturns and why. Ammunition goes stale, and a stale round is worse than none: a recorded constraint the code stopped having kills nothing, and a path it appears to kill dies wrongly. Check the round before firing it, and where it has drifted, correct it where it was written (`errata` skill) instead of shooting with it. A record nobody reads is decoration; this is where it earns its keep.

Then commit, and present the commitment — not a ballot. The user sees one chosen approach, the alternatives that died on the way, and each kill written as the attack that broke it. Confirmation is of **consequences, not labels**: play back what the choice means when things happen ("choosing the pipeline means a refund re-walks every adjustment") until the user can say that's what they want — or overrule you, which they always can. A menu surfaces only where a fork is genuinely the user's world to decide — their team, their ops, their priorities — asked with a recommendation and its price, never as "pick one of these". If they can't evaluate even that, teach the difference first (`blindspot` skill), or record an honest `assumed:` instead of a hollow confirmation.

## How it runs

1. Read the paths, `.genius/DECIDED.md`, and the older records the repo keeps; open `CONTRACT.md` only where the plan under attack already has one. Check each round before firing it, and correct a drifted one (`errata` skill) rather than shoot with it.
2. Attack every path from its own weakest joint, the favorite included. Wounds found, never manufactured; what a path survived is recorded too.
3. Commit to the survivor. Where every path dies, say so: back to `/invent` with the wounds as constraints, or to `/wonder` where they indict the problem.
4. Present the commitment as consequences — what the choice means when things happen — and each kill as the attack that broke it. A menu only where the fork is the user's world, with a recommendation and its price; teach first where they cannot evaluate it (`blindspot` skill), or record an honest `assumed:`.
5. Record: the Decision section — chosen, the load-bearing why, one kill-reason line per rejected path; the whole fight under `## discernment` in the log; Invention's paths compacted out of the snapshot; `next: /galvanize`.

Record why the winner won and one line per rejected path on what killed it — an unrecorded kill-reason gets re-proposed in six weeks. A decision a future stranger would re-fight earns its line in the decision index at close-out — the `decision-record` skill holds the test; most decisions stay with their work file alone. If every path dies, that's a finding, not a failure: back to `/invent` with the wounds as constraints, or back to `/wonder` if the wounds indict the problem itself.

Then `/galvanize`. Done when the chosen approach is confirmed in consequences the user could evaluate, and every rejection carries its kill-reason — written as the attack actually tried and what it broke, not as a verdict. The fight is kept whole, but it is kept in the log (`genius-file` skill): every attack tried on every path — the ones that landed and the ones the survivor walked out of alike, because what a design survived tells the builder how much load it was proved to take — under one anchor the snapshot's Decision section links. The builder who needs that follows one link; every other reader stops at the verdict. What the snapshot keeps is the decision itself: chosen, the load-bearing why in a few lines, one kill-reason line per rejected path — this stage's close compacts Invention's paths down to exactly that. A kill-reason that names no attack is an opinion.