Deepen

Turn a one-shot skill into a multi-pass grind. Point it at any skill (ux-scan, polish-pass, a security sweep, optimize-proof, unslop), name a target and a pass cap, and it runs the skill repeatedly with each pass digging past the last: prior findings are fixed and off the table, so every pass is forced into new territory until territory runs out.

Core Insight: N passes of the same prompt is not N× the value; it's 1× the value plus N−1 reruns. The value of a repeat comes from three disciplines: deepen (pass k carries the log of passes 1..k−1, so it cannot re-find old ground and must go further), fix-then-pass (every pass's findings are fixed before the next pass fires, so the next pass inspects the improved artifact, not a stale one plus a findings pile), and stop on saturation (a pass that surfaces nothing materially new ends the loop, even with passes left on the cap; chasing literal zero manufactures non-findings). This is a successive-prompter: one pass at a time, each issued only when the prior pass's fixes are banked green, never a "do 5 passes" megaprompt.

Preconditions / guards

1. The wrapped skill exists and applies. /deepen adds repetition discipline, not capability. If one pass of the skill wouldn't help, five won't.
2. Green baseline + checkpoint. The ratchet needs a recoverable starting point: build + tests + smoke green, checkpoint commit taken, before pass 1.
3. A verification command. Know what "green" means for this target (test suite, build, smoke) before starting. A ratchet with no test is a hope.
4. For review/audit-class skills: the smart-model re-review gate (Phase per-pass, step c) is NON-SKIPPABLE; budget for it.

The Pipeline (staged: issue each pass only when the prior pass is banked)

Phase 0: Arm

Resolve the four parameters: Skill (what to apply), Target (where), Passes (the cap: a ceiling, never a quota), Stop (the convergence rule; default saturation). Confirm the green baseline, take the checkpoint, create <target>/.deepen/PASSLOG.md.

Per pass k (1..cap): the loop body

a. Brief. Issue the wrapped skill against the target. Pass 1 runs broad: the skill as designed. Pass k ≥ 2 gets the PASSLOG prepended with the deepening charge: everything already found and fixed is settled; do not re-litigate it; go deeper (new categories, edge cases, layers beneath the surface fixes, what the prior fixes themselves exposed). Verbatim templates in references/PASSES.md.

b. Collect. Capture the pass's findings as a numbered list with impact (material / minor / nit).

c. Smart-model re-review gate (review/audit-class passes; non-skippable, standing rule). Fresh top-model eyes on the findings against the actual code: is each one real, still-present, and worth fixing? Demote hallucinated or already-fixed findings before spending fix effort. Skip only for skills that change code directly rather than emit findings.

d. Fix all of it, now. Every surviving material finding gets fixed in this pass, one at a time, before pass k+1 exists. Green ratchet between fixes: a fix that breaks build/tests/smoke gets 2 repair attempts, then is REVERTED to checkpoint and logged reverted. A pass's change that breaks a test is not kept, however right the finding felt. Checkpoint after the pass ends green.

e. Log + stop-check. Append the pass entry to PASSLOG.md (findings, fixed, reverted, deferred-with-reason). Then apply the Stop rule. Default: saturation, not zero: the pass produced no materially new findings relative to effort spent (only nits, rephrases of settled items, or manufactured work). Saturated → exit the loop even with passes remaining. Cap reached → exit with status cap-hit and say so; never silently grind on.

Phase Ω: Report

Final verify green, final checkpoint, then a short done report: passes run, exit reason (saturated / cap-hit / stop-rule), the per-pass deltas, and anything reverted or deferred. PASSLOG.md is the audit trail.

Contract (what orchestrators can rely on)

ux-maximizer runs its quality cascade through this skill (3× ux-scan, 5× polish-pass, 3× design-intel: "each with progressive deepening; fix every pass's findings"), and project-autopilot routes "repeated multi-pass refinement of one facet" here, bounded by its CONVERGENCE.md saturation gate. The interface is fixed:

• Parameters in: skill/command · target · max passes (cap) · stop condition.
• <target>/.deepen/PASSLOG.md: per-pass log (format in references/PASSES.md): what each pass found, fixed, reverted, deferred. The caller reads this to see what changed per pass.
• Green exit, always: the loop never hands back a red target; last action is verify + checkpoint or revert.
• Honest exit status: saturated (the good ending) / cap-hit (cap was the binding constraint; caller may re-arm with a higher cap) / stop-rule (a caller-supplied condition fired).

THE EXACT PROMPT

/deepen
Skill:   <skill or slash command to apply, e.g. ux-scan>
Target:  <project path or scope, e.g. ~/my-app or "the checkout flow">
Passes:  <max pass cap, e.g. 5 — a ceiling, not a quota>
Stop:    <optional override — default: saturation (no materially new findings)>

Anti-Patterns

• Re-running the identical prompt N times. Without the PASSLOG charge, pass 3 proudly re-finds pass 1's settled items.
• Collecting findings across passes and "fixing them at the end." Pass k+1 must inspect the fixed artifact, or it audits a ghost.
• Keeping a pass's change that broke a test because the finding was right. Revert it; right-but-red is red.
• Treating the cap as a quota. Grinding to N after saturation manufactures non-findings (the Convergence clamp exists for exactly this).
• Chasing literal zero. The stop signal is diminishing returns per token, not an empty findings list.
• Skipping the smart-model re-review on audit passes because the findings "look real." First-draft findings always look real to their author.
• One megaprompt ("do 5 ux-scan passes and fix everything"). Successive prompts, one pass at a time, or the deepening discipline collapses.
• Widening scope mid-loop ("while I'm here..."). The loop deepens one facet; new facets are a new /deepen run or an inbox item.

References

• PASSES.md: verbatim pass-1 and pass-k prompt templates, the saturation test, and the PASSLOG.md entry format