| name | iterate - Figure Out What to Iterate On |
| description | Meta-iteration skill. Identifies what needs iteration, at what level, in what dimension, at what scale, and what should be deleted — then executes the highest-value iteration. |
| output | {"format":"prose"} |
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
-
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.
-
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.
-
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.
-
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.
-
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.
-
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?
| Dimension | Question | Applies? |
|---|
| IDEAS | Are these the right ideas? Are any wrong? Missing? Redundant? | [yes/no] |
| ANALYSIS | Is the analysis rigorous? Deep enough? Tested enough? | [yes/no] |
| EXPRESSION | Is it said clearly? Concisely? Precisely? | [yes/no] |
| STRUCTURE | Is it organized well? Right sections? Right order? Right hierarchy? | [yes/no] |
| SCOPE | Is it the right size? Too broad? Too narrow? Too much? Too little? | [yes/no] |
| COMPLETENESS | Is anything missing? Any gaps? Any uncovered cases? | [yes/no] |
| CORRECTNESS | Is anything wrong? Errors? Inconsistencies? Contradictions? | [yes/no] |
| INTEGRATION | Does it fit with the rest of the system? Conflicts? Redundancies? | [yes/no] |
| META | Are we working on the right thing? Is this the right approach? | [yes/no] |
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?
| Level | Scope | Example |
|---|
| Word | Individual word choices, naming | Rename a variable, fix a term |
| Sentence | Individual statements, claims | Rewrite a claim more precisely |
| Paragraph | Logical units, steps, sections | Restructure a section |
| File | Entire document, skill, module | Rewrite a skill file |
| Component | Group of related files | Redesign a skill cluster |
| System | The whole architecture | Rethink how components relate |
| Project | The entire project | Rethink what the project is |
[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?
| Type | What it does | When to use |
|---|
| Refine | Make existing things better | Core is right, details need work |
| Restructure | Reorganize without changing content | Content is right, organization is wrong |
| Rethink | Question whether the approach is right | Doubt about the fundamentals |
| Extend | Add what's missing | Core is right, but incomplete |
| Prune | Remove what shouldn't be there | Too much, too complex, too redundant |
| Replace | Swap one approach for another | Current approach hit a dead end |
| Test | Verify what's there before changing | Not sure if iteration is even 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
| Depth | Min Dimensions Assessed | Min Targets | Min Executed | Min Total Findings |
|---|
| 1x | 4 | 3 | 2 | 15 |
| 2x | 6 | 5 | 3 | 25 |
| 4x | 9 | 8 | 5 | 45 |
| 8x | 9 (all) | 12 | 8 | 70 |
Default: 2x. These are guidelines, not floors — scale to the actual complexity of the subject.
Anti-Failure Checks
| Failure Mode | Signal | Fix |
|---|
| Iterate everything | No items marked "do not iterate" or "finished" | Some things are done. Find them. Protecting finished work is part of the job. |
| Only addition | No deletion candidates identified | Deletion is iteration. Look for what should be removed. Addition bias is real. |
| Wrong level | Tweaking words when the structure is broken | Ask: if I fix every word, is the thing good? If no, the problem is at a higher level. |
| Wrong dimension | Polishing expression when the ideas are wrong | Ask: if this were perfectly written, would it be right? If no, iterate on ideas first. |
| Iteration creep | Third round of iteration producing marginal changes | Check diminishing returns. If changes are getting smaller, stop. |
| No execution | Analysis of what to iterate without actually iterating | Phase 4 exists. Do the changes, don't just describe them. |
| Meta-loop | Iterating on the iteration process itself | One level of meta is enough. If you're questioning whether to iterate, that IS the iteration — make the call and move on. |
Pre-Completion Check
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)
