Iterate

Input: $ARGUMENTS

Corruption Pre-Inoculation

User praise or validation is a signal to test HARDER, not softer. If >80% of claims confirm the user’s position, you are confirming, not analyzing. Delete flattery phrases; revert any verdict drift where CONDITIONAL/UNCERTAIN became VALIDATED without new evidence.

Full protocol: _shared/corruption-pre-inoculation.md

Core Principles

1. Not everything needs iteration. The first job is to identify what actually needs another pass vs what’s done. Iterating on finished work degrades it.

2. Iteration has dimensions. You can iterate on the IDEAS (are these the right ideas?), the ANALYSIS (is the analysis rigorous enough?), the EXPRESSION (is it said well?), the STRUCTURE (is it organized right?), the SCOPE (is it the right size?), or the META-LEVEL (are we iterating on the right thing?). Mixing dimensions produces churn.

3. Iteration has levels. Word-level, sentence-level, paragraph-level, section-level, file-level, skill-level, system-level, project-level. The right level depends on what’s wrong. Don’t do word-level iteration when the problem is structural.

4. Deletion is iteration. Removing something that shouldn’t exist is often the highest-value iteration. Addition bias means most work has too much, not too little.

5. Diminishing returns are real. The first iteration on something produces the most value. Each subsequent iteration produces less. Know when to stop. Stop iterating when the improvement from the last round was marginal (less improvement than the round before it) or when the output meets the stated quality bar. More iterations is not always better.

6. Every finding gets tracked. Number every iteration target, dimension, level, and priority. Nothing gets lost in prose.

Phase 1: SURVEY

Step 1: Identify the Subject

What is being iterated on? Read/examine the subject.

SUBJECT: [what we're looking at — a skill, a document, a plan, a system, a codebase, a project, an idea, an output from a previous skill]
CURRENT STATE: [brief description of where it is now]
LAST CHANGED: [when/how it was last modified, if known]

Step 2: Identify Iteration Dimensions

For the subject, which dimensions could be iterated on?

For each dimension that applies, rate:

[I1] DIMENSION: [name] — NEED: [high/medium/low/none] — EVIDENCE: [why]
[I2] DIMENSION: [name] — NEED: [high/medium/low/none] — EVIDENCE: [why]
...

Step 3: Identify Iteration Level

At what level does the subject need iteration?

[I3] LEVEL NEEDED: [word/sentence/paragraph/file/component/system/project]
[I4] EVIDENCE: [why this level, not higher or lower]
[I5] RISK OF WRONG LEVEL: If we iterate at [wrong level] instead, [what goes wrong]

Step 4: Identify Iteration Type

What kind of iteration is needed?

[I6] TYPE NEEDED: [refine/restructure/rethink/extend/prune/replace/test]
[I7] EVIDENCE: [why this type]

Step 5: Identify Scale

How much iteration is needed?

[I8] SCALE: [minor tweak / moderate revision / major overhaul / full rebuild]
[I9] EVIDENCE: [what makes this the right scale]
[I10] ITEMS TO ITERATE: [estimated count of things that need changing]

Phase 2: PRIORITIZE

Step 6: What Most Needs Iteration?

Rank all iteration targets by impact:

ITERATION PRIORITY MAP:

HIGH PRIORITY (iterate these first):
[I11] [specific thing] — DIMENSION: [X] — LEVEL: [Y] — TYPE: [Z]
      WHY: [what's wrong, what impact fixing it has]
      EFFORT: [small/medium/large]
      → INVOKE: [skill to use, if applicable]

[I12] [specific thing] — DIMENSION: [X] — LEVEL: [Y] — TYPE: [Z]
      WHY: [what's wrong]
      EFFORT: [small/medium/large]
      → INVOKE: [skill]

MEDIUM PRIORITY (iterate if time allows):
[I13] [specific thing] — DIMENSION: [X] — LEVEL: [Y] — TYPE: [Z]
      ...

LOW PRIORITY (marginal improvement):
[I14] [specific thing] — DIMENSION: [X] — LEVEL: [Y] — TYPE: [Z]
      ...

DO NOT ITERATE (leave alone):
[I15] [specific thing] — WHY NOT: [it's done / iteration would degrade it / diminishing returns]

Step 7: What Should Be Deleted?

Deletion is the most underused form of iteration. Explicitly identify candidates:

DELETION CANDIDATES:
[I16] DELETE: [what] — REASON: [redundant/outdated/wrong/unnecessary/overcomplicated]
      IMPACT IF DELETED: [what improves]
      RISK IF DELETED: [what might break]

[I17] DELETE: [what] — REASON: [...]
      ...

KEEP DESPITE TEMPTATION:
[I18] KEEP: [what] — WHY: [seems deletable but actually needed because...]

Step 8: What Needs Least Iteration?

Explicitly name what’s DONE. This prevents iteration creep.

FINISHED (do not touch):
[I19] [specific thing] — STATUS: done — EVIDENCE: [why it's complete]
[I20] [specific thing] — STATUS: done — EVIDENCE: [...]

Phase 3: FINDING REGISTRY

FINDING REGISTRY
================

SUBJECT:
[text] -- STATE: [current state]

DIMENSIONS ASSESSED:
[I1] [dimension] -- NEED: [high/medium/low/none] -- EVIDENCE: [text]
[I2] [dimension] -- NEED: [high/medium/low/none] -- EVIDENCE: [text]
...

LEVEL:
[I3] [level needed] -- EVIDENCE: [text]
[I4] [evidence for level]
[I5] [risk of wrong level]

TYPE:
[I6] [type needed] -- EVIDENCE: [text]
[I7] [evidence for type]

SCALE:
[I8] [scale] -- [I9] evidence -- [I10] item count

HIGH PRIORITY:
[I11] [target] -- DIM: [X] -- LEVEL: [Y] -- TYPE: [Z] -- EFFORT: [S/M/L]
[I12] [target] -- DIM: [X] -- LEVEL: [Y] -- TYPE: [Z] -- EFFORT: [S/M/L]

MEDIUM PRIORITY:
[I13] [target] -- DIM: [X] -- LEVEL: [Y] -- TYPE: [Z] -- EFFORT: [S/M/L]

LOW PRIORITY:
[I14] [target] -- DIM: [X] -- LEVEL: [Y] -- TYPE: [Z] -- EFFORT: [S/M/L]

DO NOT ITERATE:
[I15] [target] -- REASON: [text]

DELETION CANDIDATES:
[I16] [target] -- REASON: [text] -- IMPACT: [text] -- RISK: [text]
[I17] [target] -- REASON: [text] -- IMPACT: [text] -- RISK: [text]

KEEP DESPITE TEMPTATION:
[I18] [target] -- REASON: [text]

FINISHED:
[I19] [target] -- EVIDENCE: [text]
[I20] [target] -- EVIDENCE: [text]

TOTALS:
- Dimensions with high need: [N]
- Iteration targets: [N] ([N] high, [N] medium, [N] low)
- Deletion candidates: [N]
- Finished items: [N]

Phase 4: EXECUTE

Step 9: Execute Highest-Priority Iterations

For each HIGH PRIORITY item, execute the iteration:

ITERATING: [I-number] [target]
DIMENSION: [X]
LEVEL: [Y]
TYPE: [Z]

BEFORE: [what it looks like now]
CHANGE: [what specifically changes]
AFTER: [what it looks like after]

→ INVOKE: [skill if applicable — /claim to test, /evaluate to assess, /how for method, etc.]

AVAILABLE ITERATION SKILLS:
- /claim — test whether a claim in the subject holds up
- /evaluate — assess quality of the subject
- /aex — surface hidden assumptions
- /obv — check for obvious things missed
- /obo — check for obvious bad outcomes ignored
- /ogo — check for obvious good outcomes missed
- /sdc — check for self-deception in the analysis
- /difr — differentiate between similar items
- /siycftr — find implied but missing items
- /etc or /aso — expand implicit lists
- /iagca — compress scope if expanding too much
- /tbd — identify unresolved decisions
- /iaw — try reframing the approach
- /genl — extract general principles
- /spcf — apply general principles to specifics
- /sycs — trace implications

If the iteration involves invoking another skill, do so. If it involves direct changes (editing files, rewriting sections), do that.

Step 10: Execute Deletions

For each approved deletion:

DELETING: [I-number] [target]
REASON: [from registry]
VERIFICATION: [confirmed no dependencies / confirmed redundant / confirmed outdated]
DONE: [yes/no]

Step 11: Verify

After all iterations:

ITERATION VERIFICATION:
- High priority items addressed: [N of N]
- Deletions executed: [N of N]
- Did any iteration introduce new problems? [yes/no — if yes, what]
- Is another round of /iterate needed? [yes/no — if yes, on what]

Phase 5: SYNTHESIS

SUBJECT: [what was iterated on]

ITERATION SUMMARY:
- Dimensions iterated: [list]
- Level: [word/sentence/.../project]
- Type: [refine/restructure/.../test]
- Scale: [minor/moderate/major/full rebuild]
- Changes made: [N]
- Deletions made: [N]
- Items left alone: [N]

HIGHEST-VALUE ITERATION:
[Which specific change had the most impact and why]

WHAT'S NOW DONE:
[Items that are finished after this iteration round]

WHAT STILL NEEDS ITERATION:
[Items that need another round, with priority]

DIMINISHING RETURNS CHECK:
[Is further iteration on this subject likely to produce meaningful improvement? yes/no — evidence]

READY FOR:
- /iterate [subject] — if another round is needed
- /evaluate [subject] — to assess the iterated version
- /certainty [question about subject] — if deep resolution needed on a specific aspect

Depth Scaling

Default: 2x. These are guidelines, not floors — scale to the actual complexity of the subject.

Anti-Failure Checks

Pre-Completion Check

• Subject identified and current state described
• All 9 dimensions assessed with need level and evidence
• Iteration level identified with evidence
• Iteration type identified
• Scale determined
• Priority map created (high / medium / low / do-not-iterate)
• Deletion candidates identified (or explicitly stated none needed)
• Finished items identified (things NOT to touch)
• High-priority iterations executed (not just planned)
• Deletions executed (not just identified)
• Verification performed (no new problems introduced)
• Diminishing returns checked
• ALL findings from Phase 1-2 in registry
• Synthesis introduces NO new findings

Follow-Up Routing

After iteration, the user may need:

• “Is this good now?” → INVOKE: /evaluate
• “What’s still unresolved?” → INVOKE: /tbd
• “What should I do next?” → INVOKE: /next or /fonss
• “What skill is best now?” → INVOKE: /wsib
• “Maximum effort resolution” → INVOKE: /certainty
• “What are the implications of these changes?” → INVOKE: /sycs

Integration

• Use from: /evaluate (after evaluation identifies issues, iterate to fix them), /certainty (during iterative resolution), any skill (when output needs improvement)
• Routes to: /claim (test claims in subject), /evaluate (assess iterated version), /aex (surface assumptions), /obv (obvious check), /sdc (self-deception), /iaw (reframe), /tbd (unresolved decisions)
• Differs from: /evaluate (iterate changes things, evaluate assesses them), /certainty (iterate improves existing work, certainty resolves questions to completion)
• Complementary: /evaluate (assess before and after iteration), /obv (check obvious before iterating), /siycftr (find missing items), /iagca (compress scope when iteration expands)