Iteration

What This Skill Is

Iteration is the practice of refining results through repeated cycles of evaluation and modification. Rather than attempting to produce a final output in a single attempt, iteration accepts that initial versions will be imperfect and uses feedback from each version to inform the next.

In AI-assisted work, iteration means treating outputs as drafts subject to improvement. Each cycle produces a new version that addresses deficiencies identified in the previous version. The process continues until the result meets quality standards or no further improvements can be made.

Iteration operates on a simple feedback loop: produce, evaluate, modify, repeat. The evaluation step is critical—it requires explicit assessment against objective criteria rather than subjective satisfaction. The modification step must target specific identified issues rather than making indiscriminate changes.

Why This Skill Matters

Without iteration, AI interactions follow a one-shot pattern. A request is made, an output is generated, and that output is accepted as-is regardless of quality. This approach produces work that is functional but rarely optimal. Common issues persist: structural problems, logical gaps, missed edge cases, and stylistic inconsistencies.

The limitation of one-shot attempts lies in the nature of complex work. Complex problems have interdependent requirements that cannot all be satisfied simultaneously. Addressing one requirement may reveal conflicts with another. Iteration allows these conflicts to be surfaced and resolved progressively.

More fundamentally, iteration compensates for incomplete specification. Initial requirements rarely capture all nuances of a problem. As work progresses, understanding deepens and new requirements emerge. Without iteration, these late-emerging requirements force awkward workarounds or go unaddressed.

Iteration also enables experimentation. When multiple approaches are possible, iteration allows trying alternatives and comparing results. This empirical testing reveals which approaches work in practice rather than in theory.

The absence of iteration creates a fragile process. If the initial output has fundamental flaws, the entire request must be repeated from the beginning. This wastes the partial value that was produced and obscures which aspects of the request were handled correctly.

Core Concepts

Incremental Improvement

Incremental improvement means making targeted changes that address specific issues rather than wholesale revisions. Each iteration should focus on a defined set of problems identified in the previous version. This approach preserves what works while fixing what doesn't.

Incremental improvement requires diagnostic precision through reasoning. The evaluation step must pinpoint exactly what is wrong, not just that something is wrong. "The function is slow" is insufficient; "the function performs O(n²) database queries" enables targeted optimization.

Convergence Criteria

Convergence criteria define when iteration should stop. Without clear stopping conditions, iteration can continue indefinitely with diminishing returns. Criteria may include quantitative thresholds (performance metrics, error rates), qualitative standards (readability, maintainability), or practical constraints (time, budget).

Effective convergence criteria are established before iteration begins. They prevent moving the goalposts as work progresses and ensure that iteration terminates when output quality is acceptable rather than when exhaustion sets in.

Isolation of Changes

Each iteration should change as little as necessary to address identified issues. When multiple changes are introduced simultaneously, it becomes impossible to know which change produced which effect. This obscures cause-and-effect relationships and makes future iterations less effective.

Isolation supports rollback. If an iteration makes the output worse rather than better, isolated changes allow precise reversal of the problematic modification. When changes are entangled, reverting requires discarding all progress from that iteration.

Baseline Comparison

Iteration requires maintaining the previous version as a baseline. Each new version is compared against this baseline to verify that improvements are genuine and that no regressions were introduced. Without baseline comparison, iteration can drift—changes accumulate without clear progress.

Baseline comparison extends beyond functional correctness to all quality dimensions: performance, maintainability, resource usage, and compatibility. A change that improves one dimension while degrading another may not represent net progress.

Feedback Integration

Feedback comes from multiple sources: automated testing, manual review, user testing, and production metrics. Effective iteration synthesizes these disparate signals into coherent action. Conflicting feedback requires prioritization—some issues must be deferred to maintain focus.

Feedback integration involves filtering noise from signal. Not all feedback represents genuine problems. Some reflects preferences rather than defects, some reflects misunderstanding rather than issues, and some is too rare to justify action. Iteration requires judgment about which feedback warrants modification.

How This Skill Is Used

Iteration begins by establishing a baseline. The first version may be rough, but it provides a starting point for refinement. This initial version is evaluated against requirements to identify gaps and deficiencies.

The evaluation produces a prioritized list of issues. Not all issues are equally severe. Critical defects that prevent the output from functioning take priority. Minor issues that affect polish or optimization are addressed later. This prioritization ensures that iteration focuses on high-impact improvements first.

Each iteration cycle targets a subset of the identified issues. The modifications are made with intent—changing specific aspects of the output to address specific problems. The modified version is then evaluated against both the original requirements and the previous version.

Progress is measured by comparing the new version to the baseline. Did the targeted issues resolve? Were any regressions introduced? Is the output closer to meeting convergence criteria? This assessment determines whether the iteration was successful and what the next cycle should target.

The process repeats with each iteration addressing the remaining highest-priority issues. As major defects are resolved, focus shifts to optimization and refinement. The iteration continues until convergence criteria are met or until an iteration produces negligible improvement.

When an iteration makes things worse rather than better, the response is rollback using error recovery. The problematic version is discarded, and the baseline is restored. Analysis focuses on why the modification failed before attempting a different approach.

Throughout iteration, documentation tracks what was changed and why. This history supports debugging and provides insight into the evolution of the output. When requirements change or issues resurface, this context informs how to respond.

Common Mistakes

Iteration Without Evaluation

The most common failure mode is making changes without assessing their impact. New versions are generated based on intuition rather than analysis, and problems accumulate rather than resolve. This is not iteration—it is random variation.

Effective iteration always includes an evaluation step. Before making changes, identify what is wrong and why. After making changes, verify that the specific issues were addressed and that no new problems were introduced.

Premature Abandonment

Iteration takes time. The first few cycles may produce minimal visible improvement as fundamental issues are addressed. Abandoning iteration before it converges wastes the investment made in early cycles and returns work to a one-shot process.

The corrective approach is to establish convergence criteria in advance and commit to reaching them. If early iterations feel unproductive, this may indicate that the issues being addressed are foundational and must be resolved before higher-level improvements become visible.

Scope Drift

Each iteration should target identified issues. A common mistake is introducing new features or requirements during iteration, expanding scope rather than refining the existing output. This prevents convergence and creates a moving target. Proper Task Scoping prevents this.

When iteration reveals legitimate gaps in requirements, the correct response is to explicitly update the requirements and reassess convergence criteria. Introducing scope through the back door obscures whether iteration is making progress.

Over-Iteration

Iteration has diminishing returns. Early cycles produce major improvements; later cycles produce incremental gains. At some point, the cost of additional iteration exceeds the value of further improvement. Continuing past this point wastes time and risks introducing defects through unnecessary changes.

The signal of over-iteration is when changes become debates rather than corrections. If you cannot objectively articulate what problem an iteration will solve, iteration has likely run its course.

Ignoring Regressions

Focusing on fixing specific issues can cause blindness to other aspects of the output. An iteration that successfully addresses a targeted problem may subtly break something that previously worked. Without comprehensive evaluation, these regressions accumulate.

Each iteration should assess the entire output, not just the changed portions. Automated tests and checklists help ensure that modifications are net improvements rather than localized fixes with global costs.

When This Skill Is Needed

Iteration is essential when requirements are complex or ambiguous. Complex problems have no perfect solution on the first attempt—understanding develops through engagement. Iteration allows solutions to evolve as understanding deepens.

Novel problem spaces require iteration. When the domain or approach is unfamiliar, initial attempts are experimental. Iteration provides structure for learning what works and refining approaches based on evidence rather than theory.

Quality-critical work demands iteration. When correctness, security, or performance requirements are stringent, one-shot attempts rarely suffice. Iteration allows progressive refinement until strict standards are met.

Exploratory work benefits from iteration. When the goal is to discover what is possible rather than produce a specified output, iteration enables trying multiple approaches and comparing results. Each iteration narrows the space of promising directions.

Collaborative work requires iteration. Multiple stakeholders have different perspectives and requirements. Initial outputs serve as talking points that surface misalignment and missing requirements. Iteration incorporates this feedback and builds shared understanding.

How This Skill Connects to Other Skills

Iteration provides the execution mechanism for planning. Plans identify what needs to be done; iteration performs the work progressively. Planning breaks complex objectives into tasks, and iteration completes those tasks through refinement cycles.

Testing makes iteration effective. Without test results, iteration lacks objective feedback. Testing provides the evaluation data that informs what needs to change in the next iteration. The more comprehensive the test coverage, the more targeted iteration can be.

Analysis enables effective iteration. Each iteration requires diagnosing why the current version falls short and what changes would improve it. This analytical work separates productive iteration from random variation.

Iteration relies on clear communication of requirements. When iteration produces outputs that don't match expectations, the issue is often a specification problem rather than an execution problem. Clear requirements provide the evaluation criteria that guide iteration.

Skill Boundaries

Iteration cannot compensate for fundamentally flawed approaches. If the initial direction is wrong, iteration will efficiently produce a refined version of the wrong solution. When fundamental issues surface, the correct response is to reconsider the approach, not to continue iterating.

Iteration does not create specificity. Iteration refines existing work based on identified gaps. If requirements are vague ("make it faster" or "improve the design"), iteration cannot resolve the ambiguity. Specific criteria must be established before iteration can proceed.

Iteration is not a substitute for planning. Planning establishes what should be built; iteration builds it. Attempting to iterate without planning produces work that may be well-executed but misdirected. The two skills are complementary, not interchangeable.

Iteration has limits when dependencies are high. If one component cannot be evaluated until another component is complete, iterating on the first component produces limited insight. In these cases, parallel development or stub interfaces may be more effective than pure iteration.

Iteration cannot converge when criteria conflict. If requirements demand mutually exclusive properties (e.g., minimal code complexity and maximal performance), iteration will oscillate between competing objectives rather than converging. The solution is to resolve the conflict at the requirements level, not to continue iterating.

Related Skills

Prerequisite Skills

Evaluation: Can't iterate effectively without first evaluating what needs improvement.

Complementary Skills

Error Recovery: Iteration generalizes recovery patterns; recovery is a specialized iteration focused on failure cases.

Planning: Planning adjusts through iteration as understanding improves and new information emerges.