completion-validation

Files (1)

• SKILL.md

SKILL.md (first lines)

# Completion Validation

Compare what was intended vs. what blind verification inferred. Make a decision. No sugarcoating.

## Execution Modes

| Mode | Behavior |
|------|----------|
| `full` | Full reconciliation |
| `fast` | Full reconciliation |
| `prototype` | Full reconciliation |
| `spike` | Skip this skill entirely |

In `spike` mode, validation is skipped. The user owns the consequences.

## What This Is (and Isn't)

**IS:** Reconciliation — compare two descriptions, decide accept/iterate/reject

**IS NOT:**
- A test suite
- A second QA pass
- A re-verification of code

If testing is needed, the decision is **Iterate** and testing happens back in implementation.

## Inputs Required

1. **Original request** (from evaluator or requester) — 1 sentence summary
2. **Blind inference** (from implementation-verification) — the inference snapshot
3. **Critical criteria** (from planning) — what MUST be present

## Output Format (Fixed, Minimal)

```
RECONCILIATION DECISION
═══════════════════════

Original request (1 sentence):
[What was supposed to be built]

Blind inference (1 sentence):
[What implementation-verification says was built]

---

Alignment: [MATCH / PARTIAL / MISMATCH]

Critical miss: [Yes / No]
If Yes: [What critical item is missing — 1 bullet]

Confidence: [High / Medium / Low] (from blind inference)
If Low + observable intent: [Flag — implementation should be more legible]

Gaps (0-3 bullets):
- [Gap 1]
- [Gap 2]

---

Decision: [Accept / Accept with caveat / Iterate / Reject]

If Iterate:
  Smallest fix: [1 bullet — the ONE thing to change]
  Updated criterion: [1 bullet — how to verify it's fixed]
  Iteration: [N] of 2 max

If Accept with caveat:
  Caveat: [What's not fully verified and why that's okay]

If Reject:
  Reason: [Why this can't be fixed with small iterations]
```

## Decision Logic (Explicit Precedence)

Evaluate in this order. Stop at first applicable rule.

```
┌─────────────────────────────────────────────────────────────┐
│                    PRECEDENCE ORDER                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. CRITICAL MISS CHECK (first — overrides everything)     │
│     ┌─────────────────────────────────────────────────┐    │
│     │ Critical miss = Yes?                            │    │
│     │   → Force Alignment = PARTIAL                   │    │
│     │   → Decision = Iterate (critical fix)           │    │
│     │   → Stop here                                   │    │
│     └─────────────────────────────────────────────────┘    │
│                           │                                 │
│                           ▼ No                              │
│  2. CONFIDENCE CHECK (second — routes weak evidence)       │
│     ┌─────────────────────────────────────────────────┐    │
│     │ Confidence = Low?                               │    │
│     │   If intent is observable:                      │    │
│     │     → Decision = Iterate (improve legibility)   │    │
│     │     → Stop here                                 │    │
│     │   If intent is non-observable:                  │    │
│     │     → Decision = Accept with caveat             │    │
│     │       OR escalate verification method           │    │
│     │     → Stop here                                 │    │
│     └─────────────────────────────────────────────────┘    │
│                           │                                 │
│                           ▼ Medium/High                     │
│  3. ALIGNMENT CHECK (third — normal path)                  │
│     ┌─────────────────────────────────────────────────┐    │
│     │ MATCH    → Accept                               │    │
│     │ PARTIAL  → Iterate (smallest fix)               │    │
│     │ MISMATCH → Reject                               │    │
│     └─────────────────────────────────────────────────┘    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

## Decision Definitions

### Accept
All critical items present. Blind inference captures intent. Ship it.

From autoencoders/skills, CC-BY-4.0.

More from autoencoders/skills