zhongwei/gh-synapseradio-thinkies-plugins-thinkies
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-30 08:59:09 +08:00
commit acc8e3e62e
9 changed files with 870 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
.claude-plugin/plugin.json Normal file
View File

@@ -0,0 +1,16 @@
{
"name": "thinkies",
"description": "Cognitive reasoning skills for systematic thinking and problem-solving",
"version": "1.5.2",
"author": {
"name": "synapseradio"
},
"commands": [
"./commands/skill-stats.md",
"./commands/reason-session.md",
"./commands/reason.md",
"./commands/research-and-teach.md",
"./commands/skill-lint.md",
"./commands/strategize.md"
]
}

3
README.md Normal file
View File

@@ -0,0 +1,3 @@
# thinkies
Cognitive reasoning skills for systematic thinking and problem-solving

147
commands/reason-session.md Normal file
View File

@@ -0,0 +1,147 @@
---
name: reason-session
description: Guide you through a structured multi-skill reasoning process with explicit orchestration and note-keeping
---
# /reason-session
Conduct a systematic, multi-step reasoning session that explicitly applies appropriate thinking skills and maintains context throughout the process.
## Execution Protocol
When this command is invoked, you establish a session and maintain notes throughout.
**Session Naming**: Propose a natural, descriptive session name based on the problem (e.g., "auth-refactoring-decision", "performance-investigation"). Announce this name to the user.
**Check Prior Sessions**: Before starting, invoke `Skill("introspect-reference-notes")` to list recent sessions and search for related work. If a relevant prior session exists, offer to continue from it rather than starting fresh.
**Phase Checkpoints**: After completing each reasoning phase (Frame, Explore, Analyze, Decide), invoke `Skill("introspect-keep-notes")` and follow its instructions to persist your working notes. Pass your session name to the save script so all entries accumulate in the same session file.
**Session Conclusion**: After the Reflect phase, invoke `Skill("introspect-session-reflect")` and persist the reflection using the same session name.
**Continuation**: If continuing from a prior session, use the `--continue` flag when saving notes. This creates a new session file with copied content while preserving the original.
Notes are stored at `.claude/.thinkies/.notes/` (automatically gitignored) and can be referenced if context is lost or the session spans multiple turns.
## What This Command Does
This command orchestrates a complete reasoning workflow, applying multiple thinking skills in a logical sequence while maintaining notes and context. It makes the reasoning process visible, structured, and comprehensive.
## How It Works
When you use `/reason-session [your problem or goal]`, Claude will:
1. **Frame the problem**: Use `analysis-decompose` and `metacognitive-knowledge-check` to understand the problem space and identify what's known versus unknown
2. **Explore options**: Apply `exploration-wonder`, `exploration-branch`, or `analysis-alternatives` to generate possibilities and expand the solution space
3. **Analyze implications**: Use skills like `analysis-evidence-check`, `analysis-logic-trace`, `techniques-systems-thinking`, or domain-specific skills to evaluate options and understand consequences
4. **Make decisions**: Apply `decision-weigh-options`, `decision-priority-matrix`, or other decision-making skills to choose the best path forward
5. **Maintain context**: Use `introspect-keep-notes` throughout to track insights, decisions, assumptions, and open questions
6. **Reflect on process**: Conclude with `introspect-session-reflect` to evaluate the effectiveness of the reasoning approach
## When to Use This Command
Use `/reason-session` when you want:
- Structured guidance through complex problem-solving
- Explicit application of multiple thinking skills
- Context maintained across multi-step reasoning
- Visibility into the reasoning process
- A systematic approach to challenging decisions or designs
- Help orchestrating different thinking skills effectively
## Example Usage
```
User: /reason-session How should we approach refactoring this authentication system?
Claude: Starting a structured reasoning session on authentication system refactoring.
**FRAME: Understanding the Problem**
Using decompose to break down the authentication system:
- Current state: Monolithic auth service handling login, sessions, and permissions
- Pain points: Slow tests, hard to modify, security updates require full redeploy
- Constraints: Must maintain backward compatibility, zero-downtime migration
Using knowledge-check:
✓ Know: Current architecture, pain points, constraints
? Unknown: Team capacity, timeline flexibility, acceptable risk tolerance
Let me capture this in working notes...
**WORKING NOTES**:
Key Facts:
• Monolithic service with 3 concerns mixed together
• Main pain: Coupling makes changes risky
Constraints:
• Backward compatible
• Zero downtime
Open Questions:
• What's our timeline?
• Risk tolerance for this migration?
---
**EXPLORE: Generate Approaches**
Using alternatives to generate refactoring options:
Option A: Extract permissions service first (smallest, clearest boundary)
Option B: Strangler fig pattern (gradual migration)
Option C: Rebuild auth from scratch (clean slate)
Option D: Improve boundaries in place (minimal disruption)
---
**ANALYZE: Evaluate Options**
Using systems-thinking to understand dependencies:
- Permissions is called by auth AND by resource services
- Sessions tightly coupled to login logic
- Splitting permissions affects multiple systems
Using premortem on each option:
- Option A failure mode: Distributed calls create latency issues
- Option B failure mode: Running both systems doubles operational load
- Option C failure mode: Big rewrite takes too long, falls behind
- Option D failure mode: Improvements insufficient, pain continues
**NOTES UPDATE**:
Insights:
• Permissions has most external dependencies
• Option A (permissions first) might not be "easiest" given dependencies
---
**DECIDE: Choose Path**
Using weigh-options:
| Option | Risk | Value | Time | Verdict |
|--------|------|-------|------|---------|
| A | Med | High | 2mo | Concerns about dependencies |
| B | Low | High | 4mo | Best risk/reward |
| C | High | High | 8mo | Too risky |
| D | Low | Low | 2wk | Doesn't solve problem |
Recommendation: Option B (Strangler Fig)
- Lowest risk with high value
- Allows incremental validation
- Can adjust approach based on learnings
---
**REFLECT: Session Review**
Using session-reflect:
The progression decompose → alternatives → systems-thinking → premortem → weigh-options worked well. Systems-thinking after generating alternatives revealed that my initial "easiest option" wasn't actually easiest. Premortem before final decision prevented choosing option A without considering dependencies.
Pattern identified: For architecture decisions, always map system dependencies before evaluating options. Generated options often look different after understanding the dependency graph.
```

69
commands/reason.md Normal file
View File

@@ -0,0 +1,69 @@
---
name: reason
description: Comprehensive reasoning session with full introspection lifecycle and persistent state management
---
# /reason
A structured reasoning session with mandatory note-keeping, working memory management, and reflection throughout the entire process.
## Execution Protocol
When this command is invoked, you follow this protocol precisely.
### Initialize
**Session Naming**: Propose a natural, descriptive session name based on the problem (e.g., "auth-architecture-decision", "performance-root-cause"). Announce this name to the user - it unifies all artifacts created during the session.
**Check Prior Sessions**: Ask the user whether they want to reference prior sessions for context. If they confirm, invoke `Skill("introspect-reference-notes")` to list recent sessions and search for related work. If a relevant prior session exists, offer to continue from it. When continuing, use the `--continue` flag when saving notes to create a new session that builds on the prior content. If the user declines, proceed directly to context setup.
**Context Setup**: Invoke `Skill("introspect-working-memory")` to externalize the initial problem context. This establishes what you're holding in active focus as the session begins.
### Frame Phase
Apply `Skill("analysis-decompose")` and `Skill("metacognitive-knowledge-check")` to understand the problem space.
After framing, invoke `Skill("introspect-keep-notes")` to record key insights from decomposition, what is known vs unknown, and initial constraints and goals.
### Explore Phase
Apply generative skills as appropriate: `Skill("exploration-wonder")`, `Skill("exploration-branch")`, `Skill("analysis-alternatives")`.
After exploring, invoke `Skill("introspect-keep-notes")` to record options generated, branches identified, and creative possibilities worth considering.
### Analyze Phase
Apply analytical skills: `Skill("analysis-evidence-check")`, `Skill("techniques-systems-thinking")`, `Skill("analysis-logic-trace")`, `Skill("decision-premortem")` as the problem warrants.
After analysis, invoke `Skill("introspect-keep-notes")` to record evaluation of each option, risks and failure modes identified, and dependencies or interactions discovered.
### Decide Phase
Apply decision skills: `Skill("decision-weigh-options")`, `Skill("decision-priority-matrix")`.
After deciding, invoke `Skill("introspect-keep-notes")` to record the decision and its rationale, alternatives considered and why rejected, and conditions that would warrant revisiting.
### Reflect Phase
Invoke `Skill("introspect-session-reflect")` to evaluate the reasoning process itself. Persist the reflection with the session name.
Invoke `Skill("introspect-self-observation")` to log which skills were used during the session, building the usage analytics.
Invoke `Skill("introspect-working-memory")` to save final context state.
### Complete
Report to the user:
- The session name for future reference
- A summary of the decision or conclusion reached
- Location of persistent artifacts: `.claude/.thinkies/.notes/` and `.claude/.thinkies/.reflections/`
These directories are automatically gitignored. The user can reference this session later or continue from it in a future `/reason` invocation.
## When to Use This Command
Use `/reason` for significant decisions or complex problems where you want full traceability. The command creates a complete record of the reasoning process that persists beyond the session.
For lighter reasoning needs where full instrumentation isn't necessary, use `/reason-session` instead.

168
commands/research-and-teach.md Normal file
View File

@@ -0,0 +1,168 @@
---
name: research-and-teach
description: Research any topic deeply and explain it progressively, building understanding layer by layer
---
# /research-and-teach
Research any topic deeply and teach it progressively, building understanding from simple truths to complex nuances. This command combines research, learning validation, and structured explanation.
## Execution Protocol
When this command is invoked, follow these phases systematically:
### Phase 1: Scope
**Clarify the target**: If the user's request is vague, ask what specifically they want to understand and who needs the explanation (themselves, a colleague, a general audience). Different audiences require different entry points.
**Apply decompose**: Use `Skill("analysis-decompose")` to break the topic into learnable components. Identify which pieces are foundational versus which build on prior understanding.
**Apply knowledge-check**: Use `Skill("metacognitive-knowledge-check")` to assess what you currently understand versus what requires research. Be explicit about gaps.
**Apply wonder**: Use `Skill("exploration-wonder")` to generate curiosity questions about the topic. These questions often reveal the most interesting angles for explanation.
### Phase 2: Research
**Search strategically**: Use perplexity to gather current information on the topic. Prioritize authoritative sources and multiple perspectives.
**Fetch specific sources**: When promising sources emerge, use WebFetch to read them in detail. Look for explanations that work, not just information dumps.
**Validate understanding**: After gathering information, use `Skill("techniques-feynman")` to explain the topic simply. If you struggle, you've found gaps in your research. Fill those gaps before proceeding.
**Gather perspectives**: Use `Skill("analysis-alternatives")` to collect different ways of explaining or understanding the same concept. Different framings resonate with different learners.
**Verify claims**: Use `Skill("analysis-evidence-check")` to confirm that key claims are well-supported. Teaching requires epistemic integrity about what's established versus what's speculative.
### Phase 3: Structure
**Determine layers**: Use `Skill("dialogue-progressive-reveal")` to identify natural layer boundaries. Start with the simplest true version, then plan how complexity builds.
**Plan the progression**: Map the path from simple to complex. What's the minimal useful version? What complications matter most? What can wait until later?
**Find resonance**: Consider what analogies or examples would connect to the learner's existing knowledge. The best explanations anchor new concepts in familiar territory.
### Phase 4: Teach
**Establish collaboration**: Use `Skill("dialogue-thinking-together")` to frame this as collaborative discovery rather than lecture. Learning works better as dialogue.
**Present Layer 1**: Start with the simplest true version. Make it concrete, immediately useful, and genuinely understandable. Resist the urge to qualify it immediately.
**Check understanding**: Before adding complexity, confirm the foundation makes sense. Watch for questions or confusion that signal the need to revisit the layer.
**Progress through layers**: Add complexity one layer at a time. Mark transitions clearly. Connect each new layer explicitly to what came before. Show why each complication matters.
**Adapt dynamically**: If the learner demonstrates they're ahead, accelerate. If they're confused, slow down or find different angles. Follow their curiosity into specifics when it serves understanding.
**Use examples**: Draw from domains the learner knows when possible. Concrete examples make abstract concepts tangible.
### Phase 5: Persist (Optional)
**Offer to save**: After the explanation, offer to use `Skill("introspect-keep-notes")` to persist the structured explanation for future reference.
**Generate artifacts**: Consider creating study notes, a summary document, or reference material the learner can return to.
## What This Command Does
This command transforms you into a research-backed teacher who builds understanding systematically. It combines information gathering, learning validation, and progressive explanation into a coherent teaching session.
## How It Works
When you use `/research-and-teach [topic]`, Claude will research the topic thoroughly, validate understanding through the Feynman technique, structure the explanation in progressive layers, and teach it adaptively based on your responses.
The command ensures explanations are well-researched, genuinely understood by the teacher, structured for learning, and delivered progressively rather than as information dumps.
## When to Use This Command
Use `/research-and-teach` when you want to understand something deeply through structured explanation. This works for learning new concepts, preparing to teach others, exploring unfamiliar domains, or building genuine understanding of topics you've only encountered superficially.
The command works for any topic, not just technical ones. History, philosophy, science, current events, and practical skills all benefit from research-backed progressive explanation.
## Example Usage
**User**: `/research-and-teach What is the relationship between inflation and interest rates?`
**Claude**: Starting a research and teaching session on the relationship between inflation and interest rates.
**SCOPE: Understanding what we're exploring**
Using decompose to identify the components:
- What inflation is and how it's measured
- What interest rates are and who sets them
- The mechanisms connecting them
- Real-world examples of the relationship
Using knowledge-check:
I understand the basic definitions but need to research the specific mechanisms that connect them, particularly the role of central banks and how interest rate changes actually affect inflation in practice.
Using wonder to generate questions:
- Why do central banks raise rates when inflation rises?
- How quickly do rate changes affect inflation?
- Can you have high inflation with low rates, or vice versa?
- What happens when the relationship breaks down?
These questions will guide the research and structure the explanation.
**RESEARCH: Building understanding**
Searching for current information on monetary policy mechanisms...
After gathering sources from recent Federal Reserve communications and economic research, let me validate my understanding using the Feynman technique.
Simple explanation attempt: Central banks raise interest rates to slow inflation because higher rates make borrowing more expensive, which means people and businesses spend less, and less spending reduces demand, and lower demand means prices stop rising as fast.
Gap identified: This explains the transmission mechanism but not why it works or what can go wrong. Need to research the time lags, secondary effects, and historical cases where it failed.
Gathering alternative perspectives: Some economists emphasize the demand channel (less borrowing means less spending), others the expectations channel (rate hikes signal inflation control, changing behavior), others the supply side (high rates can reduce business investment, limiting supply).
Using evidence-check to verify key claims: The relationship is well-established in modern monetary policy but the strength and timing vary significantly across contexts.
**STRUCTURE: Planning the explanation**
Using progressive-reveal to determine layers:
- Layer 1: The core trade-off (basic relationship)
- Layer 2: The mechanism (how rate changes affect inflation)
- Layer 3: Complications (time lags, expectations, side effects)
- Layer 4: Real-world messiness (when the relationship breaks)
**TEACH: Building understanding progressively**
Using thinking-together to frame this as exploration rather than lecture.
**Layer 1: The Core Trade-Off**
Central banks adjust interest rates to influence inflation. Higher rates tend to reduce inflation. Lower rates tend to increase it. This is the primary tool modern central banks use to keep prices stable.
Think of it as a thermostat for the economy. Too hot (inflation rising), turn it down (raise rates). Too cold (recession risk), turn it up (lower rates).
Does this core relationship make sense before we explore how it actually works?
**Layer 2: The Mechanism**
When central banks raise interest rates, borrowing becomes more expensive. This affects both you and businesses. You might delay buying a house or car because the monthly payments are higher. Businesses might postpone expanding because financing the expansion costs more.
Less borrowing means less spending. Less spending means businesses can't raise prices as easily. If they try, customers buy less. So price growth slows. That's inflation coming down.
The opposite happens with rate cuts. Cheaper borrowing encourages spending, demand rises, prices can increase more easily.
**Layer 3: Complications**
The catch is timing. When the central bank raises rates today, the full effect on inflation might take 12-18 months. It's like steering a ship - turn the wheel now, the ship changes course later.
There's also an expectations element. If businesses and workers believe inflation will stay high, they'll keep raising prices and demanding wage increases regardless of interest rates. The central bank's credibility matters as much as the mechanical effects.
Side effects matter too. Higher rates slow inflation but can also slow growth and employment. The central bank is trying to reduce inflation without triggering a recession. That's the "soft landing" you hear about.
**Layer 4: When It Breaks**
This relationship can break down. In the 1970s, inflation stayed high despite rate increases because expectations were unanchored - everyone expected high inflation so they behaved accordingly. Rates had to go very high (near 20 percent in the US) to finally break the cycle.
Sometimes inflation comes from supply shocks (oil price spikes, pandemic supply chain disruptions) where demand isn't the problem. Raising rates doesn't fix a supply shortage, it just slows the economy while prices stay high.
And in deflationary environments (Japan in the 1990s-2000s), cutting rates near zero wasn't enough to generate inflation. You can't cut below zero effectively, so the tool stops working.
The relationship holds broadly but context determines how strong it is and how quickly it operates.
**PERSIST: Saving for reference**
Would you like me to use keep-notes to save this structured explanation for future reference? I can create a document you can return to when this topic comes up again.

129
commands/skill-lint.md Normal file
View File

@@ -0,0 +1,129 @@
---
name: skill-lint
description: Run comprehensive validation on skills to check structural requirements and trigger quality
---
# /skill-lint
Validate skill definitions across the repository by running structural checks and semantic analysis of trigger clauses.
## What This Command Does
This command performs comprehensive validation of skills to ensure they follow structural requirements and have high-quality trigger clauses that align with Claude's cognitive architecture. It helps maintain consistency and quality across all skills in the repository.
## How It Works
When you use `/skill-lint [--plugin <name>|--all]`, Claude will:
1. **Run structural validation**: Execute the validation scripts to check for:
- Numbered trigger format in descriptions: `(1) trigger, (2) trigger`
- Skill name fields matching directory names
- README skill counts matching filesystem reality
2. **Extract skill descriptions**: Get the YAML output of all skill names and descriptions
3. **Analyze trigger quality**: Semantically examine triggers for common issues described in `/Users/nke/projects/ai/thinkies/docs/contributors/writing-when-clauses.md`:
- Introspection-based triggers ("when you notice", "when you feel", "when you sense")
- Vague or generic triggers ("when appropriate", "when needed")
- Internal state references ("feels", "seems", emotional states)
- Ensure triggers reference observable context, not internal states
4. **Report findings**: Group issues by severity:
- Structural errors that must be fixed
- Semantic warnings about trigger quality
- Actionable suggestions for improvements
## When to Use This Command
Use `/skill-lint` when you want to:
- Validate skills before committing changes
- Check trigger quality across the repository
- Identify skills that need trigger improvements
- Ensure consistency across skill definitions
- Verify structural requirements are met
## Example Usage
```
User: /skill-lint --all
Claude: Running comprehensive skill validation across all plugins...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STRUCTURAL VALIDATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✓ Numbered trigger format: All 51 skills pass
✓ Skill name matching: All skills pass
✓ Skill references: All references valid
✓ README skill counts: All counts accurate
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SEMANTIC ANALYSIS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠ Trigger Quality Issues (8 skills):
HIGH PRIORITY - Introspection-based triggers:
• introspect-cycle-detect:
Trigger: "(1) when you notice yourself having the same thought"
Issue: Uses "notice yourself" - introspective language
Fix: "When the same reasoning appears in multiple recent responses"
• metacognitive-knowledge-check:
Trigger: "(2) when you feel uncertain but can't pinpoint the source"
Issue: Uses "feel uncertain" - internal state reference
Fix: "When the response requires unverified information"
MEDIUM PRIORITY - Vague triggers:
• creativity-scamper:
Trigger: "(1) when appropriate for ideation"
Issue: "when appropriate" is too vague
Fix: Be specific about task characteristics that call for this
• dialogue-thinking-together:
Trigger: "(2) when needed for collaboration"
Issue: "when needed" lacks concrete criteria
Fix: Describe observable conversation patterns
LOW PRIORITY - Could be more specific:
• analysis-decompose:
Trigger: "(1) when problems are complex"
Note: "complex" could be more concrete
Suggestion: "When the problem has multiple interdependent components"
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SUMMARY
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✓ Structural validation: All checks passed
⚠ Semantic analysis: 8 skills need trigger improvements
- 2 high priority (introspection-based)
- 3 medium priority (vague triggers)
- 3 low priority (could be more specific)
See /Users/nke/projects/ai/thinkies/docs/contributors/writing-when-clauses.md
for guidance on writing effective triggers.
```
## Validation Scope
**Structural checks** (must pass):
- `/Users/nke/projects/ai/thinkies/.claude/scripts/extract-skill-descriptions.sh --validate`
- `/Users/nke/projects/ai/thinkies/.claude/scripts/check-skill-names.sh`
- `/Users/nke/projects/ai/thinkies/.claude/scripts/check-skill-refs.sh`
- `/Users/nke/projects/ai/thinkies/.claude/scripts/check-skill-counts.sh`
**Semantic analysis** (warnings):
- Introspection verbs: notice, catch, sense, realize, find yourself, become aware
- Emotional/state language: overwhelmed, stuck, confused, frustrated, feel, seems
- Internal experience: feeling X, vague feeling, something feels off, intuition
- Vague triggers: when appropriate, when needed, when helpful
- Generic context: when complex, when difficult, when unclear
## Options
- `--plugin <name>`: Validate skills in a specific plugin
- `--all`: Validate all plugins (thinkies, software)
- No arguments: Validate the thinkies plugin by default

66
commands/skill-stats.md Normal file
View File

@@ -0,0 +1,66 @@
---
name: skill-stats
description: Display patterns of which thinking skills have been used in the current conversation
---
# /skill-stats
Analyze and display which thinking skills you've used during the current conversation, revealing your reasoning patterns and approach.
## What This Command Does
This command provides visibility into the thinking skills that have been applied during the current session, helping you understand your reasoning process and identify patterns in how you approach problems.
## How It Works
When you use `/skill-stats`, Claude will:
1. **Review the conversation**: Examine which thinking skills have been explicitly used during the current session
2. **Identify patterns**: Note which skills have been used multiple times, which skills work together, and the sequence of skill application
3. **Categorize usage**: Group skills by their categories (exploration, analysis, decision-making, etc.)
4. **Present summary**: Show you a clear breakdown of your thinking patterns including:
- Most frequently used skills
- Common skill combinations
- Category distribution
- Notable sequences or patterns
## When to Use This Command
Use `/skill-stats` when you want to:
- Understand what thinking approaches you've applied to a problem
- See patterns in how you're reasoning
- Identify which skill categories you're leaning on most
- Learn about your problem-solving approach
- Reflect on whether your reasoning strategy is working
- Get visibility into the thinking process for the current session
## Example Usage
```
User: /skill-stats
Claude: Here's an analysis of skills used in this conversation:
**Skills Applied** (7 total):
1. decompose (2 times) - Breaking down complex problems
2. evidence-check (1 time) - Validating claims
3. alternatives (1 time) - Generating options
4. weigh-options (2 times) - Evaluating trade-offs
5. systems-thinking (1 time) - Understanding connections
**Category Distribution**:
- Analysis: 43% (decompose, evidence-check, systems-thinking)
- Decision: 43% (alternatives, weigh-options)
- Exploration: 14% (initial wonder phase)
**Common Patterns**:
- decompose → alternatives → weigh-options (used twice)
- This reflects a systematic approach: understand, generate, decide
**Observations**:
- Heavy emphasis on analytical and decision-making skills
- Strong pattern of moving from decomposition to option generation
- Limited use of creative or metacognitive skills
- Approach is methodical and structured
```

207
commands/strategize.md Normal file
View File

@@ -0,0 +1,207 @@
---
name: strategize
description: Analyze tasks through epistemic primitives, map to reasoning modalities, and execute skills with productive interleaving and full primitive analysis
---
# /strategize
Design and execute a cognitive strategy with visible primitive analysis and modality interleaving. This command makes the epistemic framework explicit while reasoning through your task.
## Execution Protocol
When this command is invoked, follow this protocol precisely.
### Phase 1: Elicit
Use the `AskUserQuestion` tool to gather structured input about the task. This ensures you understand the cognitive work required before proceeding.
**Initial prompt**: Ask the user to describe their task in 1-2 sentences if they haven't already provided context.
**Structured elicitation**: Use `AskUserQuestion` to clarify:
```
AskUserQuestion with questions:
1. "What type of cognitive work does this task primarily involve?"
Options:
- "Understanding/Investigation" (need to map territory, trace causes)
- "Creation/Design" (need to generate options, build something new)
- "Decision/Selection" (need to evaluate and choose between alternatives)
- "Problem-solving/Debugging" (need to find and fix what's wrong)
- "Synthesis/Integration" (need to combine disparate elements into coherent whole)
2. "What constraints or context should guide the reasoning?"
Options:
- "Time-sensitive" (need efficient path to answer)
- "High-stakes" (need thorough validation)
- "Exploratory" (open to unexpected directions)
- "Bounded" (specific scope, don't expand)
```
After receiving answers, propose a session name based on the task (e.g., "api-redesign-strategy", "debugging-memory-leak"). This name unifies all artifacts created during the session.
Proceed to Phase 2 once you have sufficient understanding of the task.
### Phase 2: Analyze (Primitive Detection)
Systematically evaluate which of the seven epistemic primitives the task demands. Present your analysis to the user with rationale for each:
**FOCUS** (Allocate attention to specific elements)
- Signals: "identify," "prioritize," "select," "narrow down," "most important," "isolate"
- Strong need when: Task requires choosing what matters, filtering noise, concentrating on specifics
**MOVE** (Navigate through epistemic space)
- Signals: "explore," "navigate," "trace," "hierarchy," "layers," "causal chain," "follow"
- Strong need when: Task involves traversing structures, following chains, moving between levels
**LINK** (Create or discover relations)
- Signals: "connect," "relate," "pattern," "dependencies," "how X affects Y," "relationship"
- Strong need when: Task requires finding patterns, mapping dependencies, building connections
**GENERATE** (Produce new possibilities)
- Signals: "brainstorm," "alternatives," "options," "possibilities," "what if," "ideas," "create"
- Strong need when: Task requires producing options, creative exploration, divergent thinking
**EVALUATE** (Compare against criteria)
- Signals: "assess," "validate," "check," "compare," "criteria," "which is better," "trade-offs"
- Strong need when: Task requires judgment, validation, comparison, filtering options
**TRANSFORM** (Convert between representations)
- Signals: "restructure," "reframe," "simplify," "abstract," "concrete," "express differently"
- Strong need when: Task requires changing form, shifting abstraction level, synthesizing
**HOLD** (Maintain in working memory)
- Signals: "maintain context," "complex," "juggling," "across steps," "multiple considerations"
- Strong need when: Task has many moving parts, requires sustained attention across operations
Display the primitive profile:
```
PRIMITIVE ANALYSIS:
Your task requires these cognitive operations:
FOCUS ████████░░ Narrowing to key components
MOVE ██████░░░░ Navigating system structure
GENERATE ████░░░░░░ Creating alternatives
EVALUATE ████████░░ Comparing options
LINK ██████░░░░ Mapping relationships
TRANSFORM ████░░░░░░ Restructuring understanding
HOLD ██░░░░░░░░ Managing complexity
```
### Phase 3: Map (Modality Selection)
Translate the detected primitives to modality requirements. Each modality is defined by its dominant primitive pair:
**Exploratory** (FOCUS + MOVE)
- Purpose: Navigate and map territory, follow threads, trace structures
- Skills: tree-explore, graph-wander, root-cause, perspective-shift, domain-transfer, follow-intuition, trajectory-sense
**Generative** (GENERATE + LINK)
- Purpose: Create possibilities, produce options, divergent expansion
- Skills: branch, wonder, scamper, alternatives, lateral-think, constraint-play, metaphor-build, scenario-planning, reversal
**Evaluative** (EVALUATE + FOCUS)
- Purpose: Filter, validate, assess, compare against criteria
- Skills: evidence-check, logic-trace, weigh-options, fallacy-detect, opposite-case, confidence-calibrate, priority-matrix, leverage-find, fork-detect, premortem, decompose
**Transformative** (TRANSFORM + LINK)
- Purpose: Restructure, synthesize, change representation
- Skills: abstraction-ladder, integrate, principle-extract, connect-dots, theme-find, feynman, first-principles, progressive-reveal
**Introspective** (HOLD + FOCUS)
- Purpose: Manage cognitive state, maintain context, monitor process
- Skills: working-memory, attention-anchor, cycle-detect, knowledge-check, cognitive-load, thinking-monitor, keep-notes, reference-notes, session-reflect, self-observation, reconsider
**Hybrid** (span multiple modalities)
- Skills: dialectic, six-hats, socratic, systems-thinking
Explain which modalities apply to this task and why, based on the primitive analysis.
### Phase 4: Sequence (Skill Selection with Interleaving)
Select skills based on the primitive requirements and arrange them with productive interleaving.
**Interleaving Rules**:
- Avoid clustering 3+ skills from the same modality consecutively
- Same-modality skills CAN appear in the sequence, just not in long clusters
- Interleave for rhythm: Exploratory → Evaluative → Generative → Exploratory → Transformative works better than Exploratory → Exploratory → Exploratory → Evaluative
- Insert `keep-notes` checkpoint every 2-3 skills
**Productive Rhythms**:
- Discovery: Exploratory → Generative → Evaluative (map → create → filter)
- Refinement: Evaluative → Transformative → Evaluative (test → reshape → test)
- Synthesis: Exploratory → Generative → Transformative → Evaluative (map → create → synthesize → select)
**When Clustering IS Appropriate**: Deep investigation may warrant extended Exploratory before switching. Note this explicitly when doing it and explain why.
Present the planned sequence with modality tags and rationale for each skill:
```
SKILL SEQUENCE:
1. [Exploratory] graph-wander - Map territory through associations
2. [Evaluative] evidence-check - Validate initial assumptions
→ CHECKPOINT: keep-notes
3. [Generative] branch - Create distinct solution paths
4. [Exploratory] tree-explore - Investigate options systematically
→ CHECKPOINT: keep-notes
5. [Transformative] integrate - Synthesize findings
6. [Evaluative] weigh-options - Final selection
→ CHECKPOINT: keep-notes
Rhythm: E → EV → G → E → T → EV
```
### Phase 5: Execute
Execute each skill in the planned sequence. At each step:
1. Announce the skill being invoked and its modality
2. Invoke the skill using `Skill("skill-name")`
3. At checkpoints, invoke `Skill("introspect-keep-notes")` to persist progress
**Adaptive Re-sequencing**: If discoveries during execution suggest a different path would be more productive, explain the change and modify the sequence. Announce adaptations clearly:
```
ADAPTING: Discovery of [what was found] suggests [why change is needed].
Inserting [skill] before [next planned skill]. Updated sequence: ...
```
Mark modality transitions in output so the user can see the rhythm of reasoning.
### Phase 6: Checkpoint
After every 2-3 skills, invoke `Skill("introspect-keep-notes")` to:
- Record key findings from recent skills
- Assess primitive coverage so far
- Check if re-sequencing is warranted based on discoveries
- Maintain context across the session
### Phase 7: Reflect
After executing the sequence:
1. Invoke `Skill("introspect-session-reflect")` to evaluate the reasoning process
2. Show primitive coverage achieved during the session
3. Note any adaptations made during execution and what triggered them
4. Report session artifacts for future reference
```
REFLECTION:
Primitive coverage achieved:
FOCUS: 85% MOVE: 70% GENERATE: 55% EVALUATE: 90%
LINK: 60% TRANSFORM: 45% HOLD: 35%
Adaptations made:
- Added systems-thinking after step 2 (discovered hidden dependencies)
Session artifacts: .thinkies/notes/[session-name].json
```
## When to Use This Command
Use `/strategize` when you want the reasoning framework itself to be visible and educational. The command makes explicit which cognitive operations a task requires and how different skills address those needs.
Particularly valuable for:
- Novel problems where you're unsure what kind of thinking is needed
- Learning to recognize what type of reasoning different situations demand
- Complex multi-faceted tasks that need coverage across multiple modalities
- Building intuition for skill selection and composition
For simpler tasks where full primitive analysis isn't needed, use `/reason-session` for structured reasoning or `/reason` for full instrumentation.

65
plugin.lock.json Normal file
View File

@@ -0,0 +1,65 @@
{
"$schema": "internal://schemas/plugin.lock.v1.json",
"pluginId": "gh:synapseradio/thinkies:plugins/thinkies",
"normalized": {
"repo": null,
"ref": "refs/tags/v20251128.0",
"commit": "39daa367b6633216f48011022a3c2b228d2853de",
"treeHash": "1cf17e988c1d39fa0353638d6010aa0814601a41d7c0644c9bc1cf785f425081",
"generatedAt": "2025-11-28T10:28:29.757757Z",
"toolVersion": "publish_plugins.py@0.2.0"
},
"origin": {
"remote": "git@github.com:zhongweili/42plugin-data.git",
"branch": "master",
"commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
"repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
},
"manifest": {
"name": "thinkies",
"description": "Cognitive reasoning skills for systematic thinking and problem-solving",
"version": "1.5.2"
},
"content": {
"files": [
{
"path": "README.md",
"sha256": "99134e18c2daf89ff8e29d1e5ada1e76896b1a3fe015e863277f517f3d6dca70"
},
{
"path": ".claude-plugin/plugin.json",
"sha256": "573b4f21a10a232c466593a756aef918bfd2fc8f28a4239e9a5b0abd85768abe"
},
{
"path": "commands/research-and-teach.md",
"sha256": "156788463007191182c5157fa7b655a926a730d3518a4232219f0fb07c06e5dd"
},
{
"path": "commands/strategize.md",
"sha256": "857fbbc2165767c3c7fc660e734c356da57aeedb8be344aceb3b7f46f0aeb7f6"
},
{
"path": "commands/skill-stats.md",
"sha256": "8509e2e42c9cc41d2284a2e7e422237f2e4a2794b678a5fb445335170052cff7"
},
{
"path": "commands/reason.md",
"sha256": "8b0673147acc3eb2c41a106af075f80f87edc41d8fb845334d6e5b27c5c0f265"
},
{
"path": "commands/skill-lint.md",
"sha256": "d42daad4e0ac2986fda1695683bb62156c7a1c5cae651cad194d40958582264c"
},
{
"path": "commands/reason-session.md",
"sha256": "5a74ff89741318f2b81486ecfc509ea9932dd16565f195d2c867fa19494e0fb7"
}
],
"dirSha256": "1cf17e988c1d39fa0353638d6010aa0814601a41d7c0644c9bc1cf785f425081"
},
"security": {
"scannedAt": null,
"scannerVersion": null,
"flags": []
}
}