version: "1.0.0" name: check-target description: Tests whether a failure pattern named as "the thing to fix" is one real defect class, by recomputing its signature over all rows (passing ones included), reporting hits, failures, precision and counterexamples, and splitting the hits by cause. Use when a cluster, tell, signature, or failure pattern has been named as the fix target — before proposing, scoping, or starting any fix. Triggers on "the biggest failure class is X", on a fix target inherited from a handoff note, roadmap, or review, and on sizing a defect class by counting rows that match a tag or substring. Not for producing the candidate targets (use cluster-failures) or for locating the code site to change (use spy-site).

Check the target before you propose a fix

A signature that matches passing rows is a lead, not a defect. This skill exists because one project's review named a naming-output pattern (a prefix emitted without its locant) as the top fix target, and measurement then showed:

• 30 hits, 29 failures — the 30th row already round-tripped correctly in the shipped

config, so the flagged construction is legal in one sub-family

• three unrelated causes, not one: missing-locant on an acyl chain (~15), a

glycosidic-oxygen case (~13), a raw input string emitted verbatim as output (2)

• the glycosidic sub-case is a double-counted feature — the parent structure was named as

if a substituted oxygen were a free hydroxyl, so a locant-only fix would leave the output wrong

The lesson generalizes past naming: a whole iteration was scoped against "one defect" that was three, one of which was not a defect at all.

The procedure

1. Resolve the target to an explicit row list from a committed eval/benchmark run. Not a description, not a cluster name — the actual inputs (SMILES, molecule IDs, or whatever your unit of analysis is).

2. Recompute the signature over ALL emitted rows, not just failures. This is the whole point. A signature computed inside a failures loop is structurally incapable of seeing its own counterexamples — a clustering script that only iterates failing rows has exactly this bug.

3. Report four numbers:

4. Decompose by cause. Inspect the actual outputs (names, labels, values). If the matched rows split into groups with different mechanisms, the target is N targets and must be re-scoped before any fix.

5. Check the outcome spread. A single defect class does not usually span parse_fail + wrong_structure + exact_match. Spread across outcome types is evidence of multiple causes.

Refusal conditions

Report NOT A SINGLE DEFECT and stop if:

• precision < 1.0 — the signature matches rows that already succeed. Call it a lead and

name what distinguishes the failures from the passes.

• n < 10 — too small to be worth a task, and too small to see a second cause.
• the hits decompose into ≥2 mechanisms — re-scope to the largest single mechanism and

re-run this check on it.

• the hits span ≥3 outcome types — almost certainly multiple causes.
• the signature is a string pattern on the emitted output and no structural cause has been

identified. Output patterns are symptoms; the same wrong output arises from unrelated causes.

Size from the named inputs, not from a tag

Size a defect class only from the actual inputs, each traced to its cause; a count of rows that match a tag or substring is not a size. Projects repeatedly over-count 15–50× by counting tags: a curated "~100 candidate defects" list that turns out to have 2 genuine instances on re-derivation; a static sweep's "12 live defects" that turns out to be 4 once each case is traced.

Related

• spy-site — once the target survives this check, prove the code site is on the path.
• cluster-failures — produces the candidate targets this skill validates.
• Your project's fix-methodology / engineering-log doc, if it has an equivalent invariant.