Iterativedepth

Customization

Before executing, check for user customizations at: ~/.claude/PAI/USER/SKILLCUSTOMIZATIONS/IterativeDepth/

If this directory exists, load and apply any PREFERENCES.md, configurations, or resources found there. These override default behavior. If the directory does not exist, proceed with skill defaults.

IterativeDepth

Structured multi-angle exploration of the same problem to extract deeper understanding and richer ISC criteria.

Grounded in 20 established scientific techniques across cognitive science (Hermeneutic Circle, Triangulation), AI/ML (Self-Consistency, Ensemble Methods), requirements engineering (Viewpoint-Oriented RE), and design thinking (Six Thinking Hats, Causal Layered Analysis).

Core Concept

Instead of analyzing a problem once, run 2-8 structured passes through the same problem, each from a systematically different lens. Each pass surfaces requirements, edge cases, and criteria invisible from other angles. The combination yields ISC criteria that no single-pass analysis could produce.

Use / Win

When to use: Any time you have time budget beyond Standard tier and the task is important enough that getting the ISC right matters more than speed. This is the single most valuable thinking capability for the OBSERVE phase. If you're at Extended effort or above, you should be asking "why NOT use IterativeDepth?" rather than "why use it?"

Concrete triggers:

• Extra time available — Extended+ effort means you have the budget. Spend it on understanding the problem deeply before writing ISC, not on writing more code faster.
• Deep analysis of what's actually being asked — The user said X. But what do they actually need? What are they trying to accomplish? What would make them rate this 9-10? Single-pass reverse engineering catches the obvious. IterativeDepth catches the rest.
• Different angles of approach — Before committing to an approach, explore the problem from stakeholder, failure, temporal, experiential, and constraint-inversion angles. The right approach often only becomes obvious after seeing the problem from 3-4 directions.
• Important or critical tasks — When the user says "this is critical" or the task has high blast radius, the cost of missing a dimension is much higher than the cost of 2-5 extra minutes of analysis.
• Tasks you've never done before — Novel work has the highest density of hidden requirements. IterativeDepth is insurance against the things you don't know you don't know.

What you win:

• ISC criteria that single-pass analysis cannot produce. Each lens surfaces requirements invisible from other angles. A 4-lens pass routinely discovers 30-50% more criteria than direct analysis.
• Blind spot elimination before they become mid-EXECUTE surprises. Rework from missed requirements is 5-10x more expensive than the upfront analysis. IterativeDepth pays for itself by preventing restarts.
• Approach clarity. Seeing the problem from failure, stakeholder, and constraint-inversion angles often reveals that the obvious approach is wrong and a better path exists.
• Confidence. When ISC criteria are built on multi-angle analysis, you can execute with conviction instead of discovering gaps halfway through.

The default mental model should be: At Extended+ effort, IterativeDepth is not optional enrichment — it's the standard way to understand what you're building before you build it.

Workflow Routing

Quick Reference

• 8 Lenses available, scaled by SLA (2-8)
• Each lens is a structurally different exploration angle
• Output is new/refined ISC criteria per pass
• Integration point: Deeper understanding through structured multi-angle analysis

Full Documentation:

• Scientific grounding: ScientificFoundation.md
• Lens definitions: TheLenses.md

Gotchas

• 2-8 lens passes, not infinite. Diminishing returns after ~5 passes for most topics.
• Each pass should surface genuinely NEW requirements, not restate previous findings. If passes start repeating, stop early.
• This is a BPE-fragile skill. Monitor whether smarter models make it unnecessary. Quarterly test recommended.

Examples

Example 1: Surface hidden requirements

User: "use iterative depth on this API redesign"
→ Pass 1: Functional requirements
→ Pass 2: Security implications
→ Pass 3: Performance constraints
→ Pass 4: Backward compatibility
→ Each pass surfaces new requirements missed by previous

Execution Log

After completing any workflow, append a single JSONL entry:

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"IterativeDepth","workflow":"WORKFLOW_USED","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

Replace WORKFLOW_USED with the workflow executed, 8_WORD_SUMMARY with a brief input description, and SECONDS with approximate wall-clock time. Log status: "error" if the workflow failed.

Iterative Depth — Scientific Foundation

The practice of examining the same problem from multiple structured angles to extract deeper understanding is one of the most widely validated techniques across human inquiry.

The Core Insight

"Iterative Depth" is not a single named technique — it is a meta-pattern that appears independently across virtually every serious domain of inquiry. The fact that cognitive scientists, AI researchers, requirements engineers, designers, and philosophers all independently converged on this pattern is itself strong evidence of its validity.

The pattern: Examining the same phenomenon N times, each from a systematically different angle, yields understanding that no single examination can achieve.

---

Validated Techniques by Domain

Cognitive Science & Epistemology

1. Hermeneutic Circle (Hans-Georg Gadamer, 1960) Understanding emerges through iterative cycles between parts and whole. Each pass through a text refines pre-understanding, which changes what the next pass reveals. Understanding is "always on the way" — never complete from a single reading.

• Source: Truth and Method (1960); Stanford Encyclopedia of Philosophy
• Maps to: Each iteration refines the "pre-understanding" of what the user wants

2. Triangulation (Norman Denzin, 1970) Using multiple methods, investigators, theories, or data sources to study the same phenomenon. Four types: method triangulation, investigator triangulation, theory triangulation, data source triangulation. Overcomes single-method bias.

• Source: The Research Act (1970); PMC: Principles, Scope, and Limitations of Methodological Triangulation
• Maps to: Each iteration IS a different "method" applied to the same problem

3. Cognitive Flexibility Theory (Rand Spiro et al., 1988) Revisiting the same material from multiple perspectives at different times aids transfer to new situations and deeper understanding. "Criss-crossing the landscape" of a concept from different directions.

• Source: Cognition and Instruction, 1988
• Maps to: Each lens is a different "crossing" of the problem landscape

4. Dialectical Thinking (Hegel, refined by many) Thesis-antithesis-synthesis cycles. Examining a proposition, then its negation, then integrating both into a higher understanding. Each cycle deepens the analysis.

• Maps to: Constraint inversion and failure lenses as structured antithesis

5. Reflective Equilibrium (John Rawls, 1971; Nelson Goodman, 1955) Justified belief emerges from working back and forth between particular judgments and general principles, adjusting each in light of the other until coherence is achieved. Explicitly iterative, with no fixed endpoint.

• Source: A Theory of Justice (1971); Fact, Fiction, and Forecast (1955); Stanford Encyclopedia of Philosophy
• Maps to: Each pass tests emerging understanding against a new angle, revising until the ISC model coheres

6. Equilibration (Jean Piaget, 1975) Cognitive development proceeds through cycles of disequilibrium and equilibrium. New information conflicting with existing schemas forces accommodation — restructuring mental models. This is THE driver of cognitive growth.

• Source: The Equilibration of Cognitive Structures (1975)
• Maps to: Each new lens creates productive disequilibrium that forces genuine understanding forward

7. Abductive Reasoning (Charles Sanders Peirce, 1903) Generating hypotheses to explain surprising observations, then iteratively testing and revising them. Peirce characterized this as inherently provisional. Different outputs from the same prompt are different abductive hypotheses.

• Source: Harvard Lectures on Pragmatism (1903); Stanford Encyclopedia of Philosophy
• Maps to: Non-determinism in AI is not noise — it's abductive hypothesis generation. A FEATURE, not a defect.

8. Progressive Refinement of Mental Models (Gentner & Stevens, 1983) Mental models develop through iterative elaboration: each pass adds detail, corrects errors, integrates new information. Early passes establish rough structure; later passes add precision and catch edge cases.

• Source: Mental Models (1983); Johnson-Laird, Mental Models (1983)
• Maps to: The cognitive mechanism for WHY each successive lens pass produces deeper understanding

9. Multiple External Representations / DeFT Framework (Shaaron Ainsworth, 2006) Learning with multiple representations of the same content supports deeper understanding through complementing (different aspects), constraining (limiting errors), and constructing (building abstraction). Critically, representations must be sufficiently different — too similar wastes cycles, too different loses coherence.

• Source: Learning and Instruction, 16(3), 183-198 (2006)
• Maps to: Directly validates the 2-8 pass range as well-calibrated. Also validates that lenses must be structurally different (not just re-runs)

10. Perspectivism (Friedrich Nietzsche, 1887; Ronald Giere, 2006) "The more eyes, different eyes, we train on the same matter, the more complete will our concept of it be." Giere extended this to scientific modeling — all models are irreducibly perspectival and partial.

• Source: On the Genealogy of Morals (1887); Scientific Perspectivism (2006)
• Maps to: Each pass is a different "eye" — objectivity comes from accumulating partial views, not from a view from nowhere

AI/ML & Prompt Engineering

11. Self-Consistency (Wang et al., 2022) Sample multiple diverse reasoning paths for the same problem, select the most consistent answer. Achieved +17.9% on GSM8K, +11.0% on SVAMP, +12.2% on AQuA over single-path chain-of-thought.

• Source: arXiv:2203.11171
• Maps to: Multiple reasoning paths = multiple lenses on the same ISC extraction

12. Multi-Agent Debate (Du et al., 2023) Multiple AI agents examine the same problem, debate their findings, and converge on better answers through structured disagreement.

• Source: arXiv:2305.14325
• Maps to: Each iteration could be a different "agent perspective"

13. Ensemble Methods (Breiman, Schapire, Freund) Combining multiple models/runs yields accuracy no single model achieves. Bagging, boosting, and random forests all exploit diverse perspectives on the same data.

• Maps to: Combining multiple ISC extraction passes = ensemble of requirements

14. DiVeRSe (Diverse Verifier on Reasoning Step) (Li et al., 2023) Generating diverse prompts for the same problem and verifying each reasoning step. Structural diversity in prompting yields better coverage.

• Maps to: Structurally different lenses = diverse prompt engineering

Requirements Engineering

15. Viewpoint-Oriented Requirements Engineering (Finkelstein & Nuseibeh, 1992) Organizing requirements elicitation through multiple stakeholder viewpoints, each encapsulating partial knowledge. Inconsistencies between viewpoints reveal hidden requirements.

• Source: Requirements Engineering Journal; IEEE Conf on RE
• Maps to: Each iteration adopts a different stakeholder viewpoint

16. Misuse Cases (Sindre & Opdahl, 2005) Examining the same system from an adversary's perspective to uncover security and safety requirements invisible from the user's viewpoint.

• Maps to: The Failure/Adversarial lens

17. Progressive Elaboration (PMBOK/PMI) Iterative refinement of project understanding over time. Each pass adds detail and precision to requirements that were initially vague.

• Maps to: Each iteration adds precision to ISC criteria

Design Thinking & Problem Solving

18. Six Thinking Hats (Edward de Bono, 1985) Six structured perspectives (facts, emotions, risks, benefits, creativity, process) applied sequentially to the same problem. Forces systematic multi-angle examination.

• Source: Six Thinking Hats (1985)
• Maps to: The direct inspiration for our 8 lenses

19. Causal Layered Analysis (Sohail Inayatullah, 1998) Examining the same phenomenon at four depth layers: litany (surface data), social/structural causes, worldview/discourse, and myth/metaphor (deep archetypes).

• Source: Futures, 1998; metafuture.org
• Maps to: Progressive depth through iterations, not just different angles

20. Soft Systems Methodology (Peter Checkland, 1981) Building multiple "root definitions" of the same situation, each from a different worldview. The CATWOE analysis forces systematic perspective shifts.

• Maps to: Each iteration builds a different "root definition" of ideal state

---

Key Distinction: CS Iterative Deepening vs. Iterative Depth

The CS technique searches the SAME TREE deeper each time. Our technique searches the SAME PROBLEM from DIFFERENT ANGLES each time. Related in spirit (both benefit from re-examination), fundamentally different in mechanism.

---

Why It Works: Three Mechanisms

1. Perspective Blindness Compensation — Any single viewpoint has blind spots. Structured rotation through viewpoints covers gaps that no individual pass catches.

2. Productive Non-Determinism — Even with the same lens, AI non-determinism means each pass surfaces slightly different aspects. Combined with structural variation, this becomes a feature, not a bug.

3. Progressive Pre-Understanding — Each iteration updates the analyst's "pre-understanding" (Gadamer), making subsequent iterations more perceptive. Pass 5 sees things Pass 1 couldn't, because Passes 2-4 changed what the analyst knows to look for.

The 8 Lenses of Iterative Depth

Each lens is a structured perspective that forces exploration of a problem from a fundamentally different angle. They are ordered from most concrete to most abstract, and from most commonly useful to most specialized.

---

Lens 1: LITERAL (Surface Requirements)

Question: "What did they explicitly say? What are the concrete, stated requirements?" Grounded in: Requirements elicitation fundamentals Focus: Parse the exact words. Identify every stated requirement, constraint, preference. No interpretation — only what was said. ISC Output: Criteria for every explicitly stated requirement. Example prompt variation: "List every concrete, testable requirement explicitly stated in this request. Do not infer — only extract."

---

Lens 2: STAKEHOLDER (Who Else Cares?)

Question: "Who are all the people, systems, and entities affected by this? What does each need?" Grounded in: Viewpoint-Oriented RE (Finkelstein & Nuseibeh), Triangulation (Denzin) Focus: Identify every stakeholder beyond the requester. End users, maintainers, administrators, downstream systems, future developers. What does each need that wasn't stated? ISC Output: Criteria for stakeholder needs not in the original request. Example prompt variation: "Identify every stakeholder affected by this work. For each, what requirement would THEY add that the requester didn't mention?"

---

Lens 3: FAILURE (What Goes Wrong?)

Question: "What could fail? What would an adversary exploit? What are the edge cases?" Grounded in: Misuse Cases (Sindre & Opdahl), Pre-Mortem (Klein), STRIDE Threat Modeling Focus: Assume the solution exists. Now break it. Error states, race conditions, security holes, data corruption, user confusion, performance under load. Every way this could go wrong. ISC Output: Anti-criteria (what must NOT happen) and defensive criteria. Example prompt variation: "This solution ships tomorrow. List every way it fails in the first week. Be adversarial."

---

Lens 4: TEMPORAL (Past, Present, Future)

Question: "How does this change over time? What's the history? What happens in 6 months?" Grounded in: Causal Layered Analysis (Inayatullah), Progressive Elaboration (PMBOK) Focus: Why does this problem exist now? What was tried before? What changes in the future that would break this solution? Migration paths, backwards compatibility, scale changes. ISC Output: Criteria for durability, migration, and future-proofing. Example prompt variation: "What context created this request? What will change in 3-12 months that could invalidate this solution?"

---

Lens 5: EXPERIENTIAL (How Should It Feel?)

Question: "When this works perfectly, how does the user FEEL? What's the experience?" Grounded in: Appreciative Inquiry (Cooperrider), de Bono Red Hat (emotions) Focus: Beyond functional correctness — the qualitative experience. Speed, elegance, surprise, delight, confidence, trust. What's the difference between "works" and "works beautifully"? ISC Output: Quality-of-experience criteria that elevate from functional to euphoric. Example prompt variation: "Describe the perfect user experience of this solution. What makes someone say 'this is exactly what I wanted' vs. 'this technically works'?"

---

Lens 6: CONSTRAINT INVERSION (What If?)

Question: "What if we removed all constraints? What if we added extreme ones?" Grounded in: TRIZ (Altshuller), Lateral Thinking (de Bono), Reframing (Dorst) Focus: Remove assumed constraints — what would we build with infinite time/resources? Then add extreme constraints — what if it had to work offline, in 100ms, with zero dependencies? Both directions reveal hidden assumptions. ISC Output: Criteria that challenge assumptions and reveal what's truly essential. Example prompt variation: "What constraints are we assuming that weren't stated? Remove them — what changes? Now impose extreme constraints — what's truly essential?"

---

Lens 7: ANALOGICAL (What Patterns Apply?)

Question: "What similar problems have been solved before? What patterns from other domains apply?" Grounded in: Cognitive Flexibility Theory (Spiro), Cross-Domain Transfer Focus: This problem isn't unique. What similar problems exist in other codebases, other industries, other fields? What patterns emerged there? What mistakes were made? ISC Output: Criteria derived from proven patterns and lessons from analogous solutions. Example prompt variation: "What are 3-5 analogous problems in other domains? What solutions worked there? What criteria would those solutions imply here?"

---

Lens 8: META (Is This the Right Question?)

Question: "Are we solving the right problem? Is the framing itself correct?" Grounded in: Hermeneutic Circle (Gadamer), Double-Loop Learning (Argyris), Soft Systems Methodology (Checkland) Focus: Step outside the problem entirely. Is the request a symptom of a deeper issue? Is there a reframing that dissolves the problem instead of solving it? Would a different question yield a better outcome? ISC Output: Criteria that reframe or expand the problem definition itself. Example prompt variation: "Forget the specific request. What is the UNDERLYING need? Is there a reframing that produces a better outcome than what was asked for?"

---

SLA-Based Lens Selection

At Fast SLA, the two most commonly productive lenses (surface requirements + what goes wrong) run as brief internal thought exercises — not spawned agents.

At Standard, 4 lenses run. These can be parallelized as 2 pairs of background agents.

At Deep, all 8 lenses run. These can be parallelized as 4 pairs or 8 individual agents for maximum coverage.

---

Lens Selection for Custom Depth

When invoked with a specific count (e.g., "do 3 passes"), select lenses in order from Lens 1 through Lens N. The ordering is designed so that earlier lenses are more universally applicable.

For specialized domains, the Algorithm can override lens selection:

• Security-focused task: Prioritize Failure, Stakeholder, Temporal
• UX-focused task: Prioritize Experiential, Stakeholder, Literal
• Architecture task: Prioritize Temporal, Constraint Inversion, Analogical
• Ambiguous request: Prioritize Meta, Stakeholder, Literal

Explore Workflow — Iterative Depth

Purpose

Run N structured exploration passes over the same problem, each from a different lens, to extract richer ISC criteria than single-pass analysis produces.

Invocation

This workflow is invoked: 1. Directly by the user: "use iterative depth on this problem" 2. By the Algorithm during OBSERVE phase when the Capability Audit selects IterativeDepth 3. By other skills that need enhanced requirement extraction

Inputs

• Problem/Request: The original user request or problem statement
• Context: Any available context (conversation history, codebase state, prior work)
• Depth: Determined by SLA or explicit user request

Execution

Step 1: Determine Depth

IF SLA = Instant → SKIP (return immediately, no iterative depth)
IF SLA = Fast → N = 2 (Literal + Failure)
IF SLA = Standard → N = 4 (Literal + Stakeholder + Failure + Experiential)
IF SLA = Deep → N = 8 (All lenses)
IF user specifies a number → N = that number (2-8)

Step 2: Load Lenses

Read TheLenses.md for the lens definitions being used this run.

For domain-specific tasks, the ordering may be overridden:

• Security tasks: Failure, Stakeholder, Temporal, Constraint Inversion
• UX tasks: Experiential, Stakeholder, Literal, Analogical
• Architecture tasks: Temporal, Constraint Inversion, Analogical, Meta
• Ambiguous requests: Meta, Stakeholder, Literal, Failure

Step 3: Execute Passes

For each lens (1 through N):

┌─────────────────────────────────────────────┐
│ 🔍 ITERATIVE DEPTH — Pass {i}/{N}: {LENS_NAME}                      │
│                                                                       │
│ Lens Question: "{The lens's core question}"                          │
│                                                                       │
│ Exploring from this angle...                                         │
│                                                                       │
│ Findings:                                                            │
│ - [Finding 1 — potential ISC criterion]                              │
│ - [Finding 2 — potential ISC criterion]                              │
│ - [Finding 3 — refinement of existing criterion]                     │
│                                                                       │
│ New/Refined ISC:                                                     │
│ + C{N}: [new criterion, 8-12 words, state not action]               │
│ ~ C{M}: [refined criterion, was X, now Y]                           │
│ + A{N}: [new anti-criterion]                                         │
└─────────────────────────────────────────────┘

Execution modes by SLA:

• Fast (2 lenses): Run both lenses inline as structured thought. No agents spawned. Output directly into the Algorithm's OBSERVE phase.

• Standard (4 lenses): Run lenses 1-2 inline, then spawn 2 background agents for lenses 3-4 in parallel. Merge results.

• Deep (8 lenses): Spawn 4 pairs of background agents (or 8 individual agents) for maximum parallelization. Each agent gets:
• The original problem/request
• Their assigned lens definition
• Current ISC criteria so far (from earlier lenses)
• Instruction: "Return 2-5 new ISC criteria or refinements from this lens"
• SLA: "Complete within 30 seconds"

Step 4: Synthesize

After all passes complete:

1. Deduplicate: Remove criteria that are semantically identical across lenses 2. Merge refinements: If multiple lenses refined the same criterion, take the most specific version 3. Prioritize: Order criteria by how many lenses surfaced them (consensus = high priority) 4. Format: Output all new/refined criteria in ISC format (8-12 words, state not action, binary testable)

Step 5: Integrate

Return the enriched criteria to the calling context:

• If called from Algorithm OBSERVE: Feed directly into TaskCreate calls
• If called standalone: Present the enriched criteria set to the user

Output Format

🔍 ITERATIVE DEPTH COMPLETE ({N} lenses applied)

📊 Coverage:
- Lenses used: {list of lens names}
- New criteria discovered: {count}
- Existing criteria refined: {count}
- Anti-criteria discovered: {count}

📋 NEW ISC CRITERIA:
[Use TaskCreate for each, prefixed "ISC-"]

📋 REFINED ISC CRITERIA:
[Use TaskUpdate for each, with evidence of what changed]

📋 NEW ANTI-CRITERIA:
[Use TaskCreate for each, prefixed "ISC-A"]

💡 Key Insight: [The most surprising finding across all lenses — the thing single-pass analysis would have missed]

Agent Prompt Template (for Deep SLA)

When spawning agents for individual lenses:

CONTEXT: You are performing Iterative Depth analysis — examining a problem from a specific structured angle to discover requirements that other angles miss.

PROBLEM: {original user request / problem statement}

YOUR LENS: {lens name} — {lens description}
YOUR QUESTION: {lens core question}

CURRENT ISC (from prior lenses):
{list of criteria already discovered}

TASK: Explore this problem EXCLUSIVELY through your assigned lens. Do NOT repeat criteria already found. Find what only YOUR lens can see.

OUTPUT FORMAT:
- 2-5 new ISC criteria (8-12 words each, state not action, binary testable)
- 0-3 refinements to existing criteria (what changed and why)
- 0-2 anti-criteria (what must NOT happen)

SLA: Complete within 30 seconds.

Integration with Algorithm OBSERVE Phase

When the Capability Audit selects IterativeDepth (#4 Skills match), it runs AFTER the initial Reverse Engineering block but BEFORE ISC CREATION. The flow becomes:

OBSERVE Phase:
1. Reverse Engineering (standard — what they said/implied/don't want)
2. Capability Audit (standard — 20/20 scan)
3. >>> ITERATIVE DEPTH (if selected) <<<
   - Takes Reverse Engineering output as input
   - Runs N lenses over it
   - Produces enriched requirement understanding
4. ISC CREATION (now informed by iterative depth findings)
5. ISC Quality Gate (standard)

This means ISC criteria benefit from multi-angle exploration BEFORE they're created, rather than being corrected after the fact.