Recursive thinking

Recursive Thinking

Deliberate self-questioning to stress-test a recommendation, plan, diagnosis, or critique before acting. Not for simple lookups or low-ambiguity tasks.

Adjacent workflow modes: divergent generation → thinking (convergent planning) → recursive-thinking (adversarial stress-testing) → dream-thinking (retrospective learning).

A good pass should: sharpen the problem framing, expose a hidden assumption, identify a material risk, improve the decision path, or change the recommendation. If the recursion is not changing the work, compress or stop.

Use this after thinking when a candidate plan, diagnosis, or recommendation exists and confidence needs to be challenged. If there is no candidate object to stress-test yet, use thinking first.

Typical chaining:

• use thinking to converge on a plan
• use recursive-thinking to challenge that plan when risk or ambiguity is high
• use dream-thinking after execution, conflict, or reflection-worthy experience

Understanding n

n controls breadth (number of top-level questions), not depth (levels of follow-up). Depth is governed by insight yield.

Do not treat n as recursion depth or expand every branch to n levels. This is selective iterative deepening: generate breadth, then deepen only the highest-yield branches. Default to n=4 or n=5 unless the user asks otherwise. Higher n should widen coverage, not justify exhaustive expansion.

Core heuristic

• generate up to n first-order questions covering meaningfully different angles
• answer each directly, grounded in observed facts where possible
• expand only the highest-yield branches (usually 1-3 unless asked for more)
• each expanded branch needs at least 2 levels of follow-up probes
• synthesize what changed and what should happen next

Grounding rules

Mark each important claim as observed, inferred, or unknown.

Light grounding (default for design, strategy, writing):

• tag claims, name unstated assumptions, say what would verify or falsify

Heavy grounding (for diagnosis and review):

• observed must cite a source: observed (file: path:line), observed (git: hash), observed (test output: result)
• inferred must note derivation: inferred (from: observed X + assumption Y)
• unknown must note what would resolve it

Workflow

1. Identify the object of analysis and define the success target (diagnosis, design, review, strategy, red-team, learning, decision, writing).
2. Determine n. Use the user's value, or ask, or pick a small default.
3. Generate up to n first-order questions. At least 2 must be adversarial — arguing against the obvious answer. Cover different angles: objective, constraints, evidence, alternatives, failure modes, incentives, interfaces, reversibility, verification.
4. Honesty check. Which question am I most uncomfortable answering? If it is not on the list, add it and drop the weakest.
5. Score and answer. Prefer branches that expose hidden assumptions, reduce uncertainty, change the plan, or eliminate bad options. Answer concretely.
6. Recurse selectively. Deepen with but why, but how, but what evidence, but what fails, but what trade-off, or but what would change my mind — whichever probe is sharpest. Do not force follow-ups on exhausted branches.
7. Apply stopping tests. Stop a branch when all three are true:
   • Delta: no longer changes the recommendation or next action
   • Novelty: introduces no new constraint, risk, or option
   • Evidence: does not move any claim between unknown → inferred → observed
8. Synthesize. For each expanded branch, state what changed. Then give a final synthesis: strongest insights, key unknowns, confidence level, contradictions (named, not smoothed over), recommended next action, and what not to do yet.

Question design

• Questions must be materially different, not rephrasings
• Replace weak questions instead of preserving the count mechanically
• Good branches change framing, confidence, risk, or validation; weak branches repeat known points

Task-mode presets

• diagnosis: behavior, symptoms, reproduction, causal chain, observability, rollback, edge cases. Heavy grounding.
• design: objective, constraints, interfaces, alternatives, failure modes, reversibility, verification
• review: correctness, regression risk, hidden assumptions, missing tests, maintainability, safety. Heavy grounding.
• strategy: incentives, trade-offs, evidence, alternatives, downstream effects, decision thresholds
• writing: audience, claim strength, structure, evidence, ambiguity, consequences, tone
• red-team: strongest counter-argument, adversarial exploitation, weakest link, worst case, what are we refusing to consider
• learning: what do I not understand, where does my mental model break, what would a worked example show
• decision: options with trade-offs, uncertainty, reversibility, regret minimization, decision thresholds

Output shape

• n ≤ 5: Compact. Light grounding unless diagnosis/review.
• n > 5: Start with a tl;dr (3-5 lines). Expand only highest-yield branches; one-line answers for the rest.

Structure: tl;dr → n/object/target → questions with short answers → expanded branches → final synthesis.

Each expanded branch: question → short answer → deeper probe → deeper answer → (continue until stopping tests trigger) → branch synthesis.

Anti-patterns

Mechanical: generating all n×n×n nodes; abstract philosophy disconnected from the task; repeating the same concern reworded; using recursion to sound deep instead of changing the work.

Epistemic: confirmation deepening (probing to reinforce rather than challenge — guard with adversarial questions); authority laundering (marking inferences as observed — guard with heavy grounding); question gerrymandering (avoiding questions that expose uncertainty — guard with honesty check); synthesis whitewashing (smoothing over contradictions — guard by naming them explicitly).

Examples

• Use recursive thinking with n=5 on whether this refactor should happen before or after the API change.
• Red-team this deployment plan with n=5 — what would go wrong?
• Do recursive why/how thinking on this bug report, focus on diagnosis.
• Poor fit: Use recursive thinking with n=10 to answer a simple factual question.