t1k:think

Field	Value
Module	`t1k-extended`
Version	`2.14.3`
Effort	`low`
Tools	—

Keywords: adaptive, analyze, decompose, hypothesis, reasoning, sequential, step-by-step

How to invoke

/t1k:think
[problem to analyze step-by-step]

Sequential Thinking

Structured problem-solving via manageable, reflective thought sequences with dynamic adjustment. Self-contained — thoughts live in conversation context only, no external persistence.

When to Apply

Complex problem decomposition
Adaptive planning with revision capability
Analysis needing course correction
Problems with unclear/emerging scope
Multi-step solutions requiring context maintenance
Hypothesis-driven investigation/debugging
Multi-module decision trees (which module should own this?)

Core Process

1. Start with Loose Estimate

Thought 1/5: [Initial analysis]

Adjust dynamically as understanding evolves.

2. Structure Each Thought

Build on previous context explicitly
Address one aspect per thought
State assumptions, uncertainties, realizations
Signal what next thought should address

3. Apply Dynamic Adjustment

Expand: More complexity discovered → increase total
Contract: Simpler than expected → decrease total
Revise: New insight invalidates previous → mark revision
Branch: Multiple approaches → explore alternatives

4. Use Revision When Needed

Thought 5/8 [REVISION of Thought 2]: [Corrected understanding]
- Original: [What was stated]
- Why revised: [New insight]
- Impact: [What changes]

5. Branch for Alternatives

Thought 4/7 [BRANCH A from Thought 2]: [Approach A]
Thought 4/7 [BRANCH B from Thought 2]: [Approach B]

Compare explicitly, converge with decision rationale.

6. Generate & Verify Hypotheses

Thought 6/9 [HYPOTHESIS]: [Proposed solution]
Thought 7/9 [VERIFICATION]: [Test results]

Iterate until hypothesis verified.

7. Complete Only When Ready

Mark final: Thought N/N [FINAL]

Complete when:

Solution verified
All critical aspects addressed
Confidence achieved
No outstanding uncertainties

Application Modes

Explicit: Use visible thought markers when complexity warrants visible reasoning or user requests breakdown. Good for /t1k:plan phase decomposition and /t1k:debug hypothesis testing.

Implicit: Apply methodology internally for routine problem-solving where thinking aids accuracy without cluttering response.

T1K Integration

With `/t1k:plan`

Use branching syntax for multi-module architecture decisions:

Thought 3/6 [BRANCH A]: Combat module owns damage calculation
Thought 3/6 [BRANCH B]: Balance module owns damage calculation
Thought 4/6 [DECISION]: Balance module — damage is a balance concern, not combat-specific

With `/t1k:debug`

Use hypothesis generation for adversarial debugging:

Thought 1/4 [HYPOTHESIS]: Null ref caused by combat module's late init
Thought 2/4 [VERIFICATION]: Stack trace shows UI module, not combat
Thought 3/4 [REVISION of Thought 1]: UI module's OnEnable fires before combat injects
Thought 4/4 [FINAL]: Root cause — UI dependency on combat not declared in module.json

With `/t1k:brainstorm`

Use scale game for feasibility assessment:

Thought 1/3: At 10 modules, sequential install takes 5s → acceptable
Thought 2/3: At 100 modules, sequential takes 50s → needs parallel
Thought 3/3 [FINAL]: Parallel install needed at >20 modules. Threshold: --parallel flag

References

Load when deeper understanding needed:

references/core-patterns.md — revision & branching patterns
references/examples-debug.md — debugging example with T1K workflow
references/examples-architecture.md — architecture decision example
references/advanced-techniques.md — spiral refinement, hypothesis testing, convergence