consider

<objective> Analyze problems, decisions, and questions using proven mental frameworks. This skill: 1. Recalls relevant past analyses from memory (if MCP memory available) 2. Classifies problems by type and characteristics 3. Assesses information requirements (local, web, user) 4. Gathers context efficiently using subagent coordination 5. Selects and executes optimal mental model(s) 6. Synthesizes actionable insights 7. Stores analysis to memory for future recall </objective>

<quick_start>

/consider [problem statement]

The command will analyze, gather required information, then apply the right model(s). </quick_start>

<problem_classification>

<problem_types>

Type	Signals	Description
DIAGNOSIS	"why", "cause", "root"	Understanding why something happened
DECISION	"should I", "decide", "choose"	Choosing between options
PRIORITIZATION	"overwhelmed", "too many", "first"	Determining what matters most
INNOVATION	"stuck", "nothing works", "assume"	Breaking through barriers
RISK	"fail", "risk", "wrong"	Assessing potential failures
FOCUS	"focus", "leverage", "important"	Finding highest-impact actions
OPTIMIZATION	"simplify", "remove", "reduce"	Improving by subtraction
STRATEGY	"strategy", "position", "compete"	Assessing competitive position
DELIBERATION	"perspectives", "group", "meeting", "angles"	Exploring from multiple viewpoints
SYSTEMIC	"symptoms", "causes", "constraint", "bottleneck"	Complex system diagnosis (TOC)
</problem_types>

<classification_dimensions> Temporal Focus: PAST | PRESENT | FUTURE Complexity: SIMPLE | COMPLICATED | COMPLEX Emotional Loading: HIGH | LOW Information State: OVERLOAD | SPARSE | CONFLICTING </classification_dimensions>

</problem_classification>

<approach_selection>

<selection_matrix>

Problem Type	Focus Area	Primary Model	Supporting Model
DIAGNOSIS	Root cause	5-Whys	First Principles
DIAGNOSIS	Assumptions	First Principles	Occam's Razor
DIAGNOSIS	Simplest explanation	Occam's Razor	5-Whys
DECISION	Time horizons	10-10-10	Second-Order
DECISION	Tradeoffs	Opportunity Cost	10-10-10
DECISION	Failure prevention	Inversion	Second-Order
PRIORITIZATION	Urgency/importance	Eisenhower Matrix	Pareto
PRIORITIZATION	Impact ranking	Pareto	One Thing
PRIORITIZATION	Single leverage	One Thing	Pareto
INNOVATION	Challenge assumptions	First Principles	Inversion
INNOVATION	Flip perspective	Inversion	First Principles
INNOVATION	Subtract complexity	Via Negativa	One Thing
RISK	Failure modes	Inversion	Second-Order
RISK	Consequence chains	Second-Order	Inversion
FOCUS	Highest leverage	One Thing	Pareto
FOCUS	Vital few	Pareto	One Thing
FOCUS	What to eliminate	Via Negativa	Pareto
OPTIMIZATION	Remove bloat	Via Negativa	Pareto
OPTIMIZATION	Efficiency	Pareto	Via Negativa
STRATEGY	Position	SWOT	Second-Order
STRATEGY	Competition	SWOT	Inversion
STRATEGY	Long-term	Second-Order	SWOT
DELIBERATION	Perspectives	Six Hats	SWOT
DELIBERATION	Emotions vs logic	Six Hats	10-10-10
SYSTEMIC	Constraint	TOC	5-Whys
SYSTEMIC	Conflict resolution	TOC	Six Hats
</selection_matrix>

</approach_selection>

<available_models>

Model	Best For	Core Question
5-Whys	Root cause analysis	"Why did this happen?" (iterate 5x)
10-10-10	Decisions with emotional bias	"How will I feel in 10 min/months/years?"
Eisenhower	Task prioritization	"Is this urgent AND important?"
First Principles	Challenging assumptions	"What is fundamentally true?"
Inversion	Risk prevention	"What would guarantee failure?"
Occam's Razor	Competing explanations	"Which requires fewest assumptions?"
One Thing	Finding leverage	"What makes everything else easier?"
Opportunity Cost	Tradeoff analysis	"What am I giving up?"
Pareto	Impact prioritization	"Which 20% drives 80% of results?"
Second-Order	Consequence analysis	"And then what happens?"
SWOT	Strategic position	"Strengths/Weaknesses/Opportunities/Threats?"
Via Negativa	Simplification	"What should I remove?"
Six Hats	Parallel perspectives	"What are all the angles?"
TOC	Systemic root cause + conflict resolution	"What constraint is blocking the system?"

Full model templates: See references/ directory for complete execution frameworks.

</available_models>

<information_requirements>

<model_information_needs>

Model	Local Sources	Web Research	User Clarification
5-Whys	Logs, history, docs	Rarely needed	Root symptoms, timeline
10-10-10	Past decisions	Rarely needed	Values, priorities
Eisenhower	Task lists, deadlines	Rarely needed	Urgency criteria
First Principles	Technical docs	Industry fundamentals	Core assumptions
Inversion	Failure history	Industry failure cases	Success definition
Occam's Razor	Available evidence	Rarely needed	Competing hypotheses
One Thing	Goals, metrics	Rarely needed	Primary objective
Opportunity Cost	Project docs, budgets	Market rates, benchmarks	Budget constraints
Pareto	Metrics, analytics	Industry benchmarks	Success metrics
Second-Order	Codebase, history	Industry trends, precedents	Time horizon
SWOT	Internal docs, capabilities	Market/competitor data	Strategic goals
Via Negativa	Current state docs	Best practices	What to preserve
</model_information_needs>

<information_source_decision> Before executing any model, classify each information need:

Need Type	Source	Tool/Method
Historical context	Local	Read (logs, docs, git history)
Codebase patterns	Local	Task(Explore) with constraints
Current metrics	Local	Read analytics, logs
Market data	Web	Task + WebSearch
Competitor info	Web	Task + WebSearch
Industry benchmarks	Web	Task + WebSearch
User preferences	User	AskUserQuestion
Success criteria	User	AskUserQuestion
Constraints/limits	User	AskUserQuestion
Technical specs	Local/User	Read docs OR AskUserQuestion
</information_source_decision>

</information_requirements>

<research_coordination>

When information gathering is needed, use Task tool with structured prompts for token efficiency.

<local_context_gathering> For codebase/local file analysis:

@type: AnalyzeAction
about: "[specific question about codebase/docs]"

@return Answer:
- text: string (direct answer, max 200 chars)
- evidence: string[] (file:line references, max 5)
- confidence: string (high|medium|low)

@constraints:
  maxTokens: 2000
  format: JSON object

Return ONLY the specified structure. No preamble or explanations.

Use subagent_type: Explore with thoroughness based on scope:

• Single file/function: quick
• Module/feature: medium
• Cross-cutting concern: thorough </local_context_gathering>

<web_research_gathering> For market/competitor/industry research:

@type: AnalyzeAction
query: "[specific research query]"

@return ItemList (max 5 items):
- position: integer
- name: string (source name)
- url: string (if available)
- summary: string (max 150 chars, key finding)
- relevance: string (high|medium|low)

@constraints:
  maxTokens: 3000
  format: markdown table

Return ONLY the specified structure. No commentary.

Use WebSearch or WebFetch for:

• Current market conditions
• Competitor analysis
• Industry benchmarks
• Recent trends or news </web_research_gathering>

<parallel_gathering> When multiple independent information needs exist:

Invoke multiple Task calls in a single message:

• Codebase analysis (Task/Explore)
• Web research (Task with WebSearch)
• These run in parallel, reducing latency

Example parallel invocation:

Task 1: Explore codebase for error handling patterns
Task 2: WebSearch for "industry error handling best practices 2024"

Both return focused, structured responses within token budgets. </parallel_gathering>

</research_coordination>

<combination_patterns>

<serial_chains> Use when output of one model feeds the next:

Diagnostic Chain: 5-Whys → First Principles → Inversion (find root → verify assumptions → prevent recurrence)

Decision Chain: Opportunity Cost → Second-Order → 10-10-10 (what you give up → consequences → time horizons)

Priority Chain: Pareto → One Thing → Via Negativa (vital few → single leverage → remove rest)

Strategic Chain: SWOT → Inversion → Second-Order (position → failure modes → consequences) </serial_chains>

<parallel_triangulation> Use multiple lenses simultaneously for validation:

High-stakes decision: 10-10-10 + Inversion + Second-Order Strategic pivot: SWOT + First Principles + Opportunity Cost Simplification: Via Negativa + Pareto + One Thing </parallel_triangulation>

</combination_patterns>

<memory_recall>

At analysis start, if MCP memory tools are available:

<step_0_recall> Recall Past Context

Use mcp__memory__search_nodes to find relevant prior analyses:

search_nodes("{key problem terms}")

Look for:

• Similar Problem entities (entityType: "Problem")
• Related RootCause entities (entityType: "RootCause")
• Applicable Insight entities (entityType: "Insight")

If matches found, use mcp__memory__open_nodes to get details:

open_nodes(["problem-similar-issue", "insight-relevant-finding"])

Present to user:

## Prior Context (from memory)

**Similar problems analyzed:**
- [problem name]: [key observations]

**Relevant insights:**
- [insight]: [content, outcome]

**Recurring root causes in this area:**
- [root cause]: [occurrence count]

Use prior context to:

• Suggest models that worked well before
• Highlight root causes that recur
• Avoid repeating failed approaches
• Build on validated insights

Skip memory recall if:

• MCP memory tools not available
• User requests fresh analysis
• No relevant matches found </step_0_recall>

</memory_recall>

<process>

<step_1_analyze> Analyze Problem

• Read problem statement
• Detect signal words (see problem_types table)
• Classify: type, temporal focus, complexity, emotional loading, information state </step_1_analyze>

<step_2_confirm> Confirm Classification

• Use AskUserQuestion to verify:
  • Problem type classification
  • Focus area within type
  • Any constraints or preferences
• Refine classification based on response </step_2_confirm>

<step_3_assess_information> Assess Information Needs For selected model(s), determine:

1. Available locally?

   • Conversation history
   • Codebase/project files
   • User-provided documents

2. Requires web research?

   • Market/competitor data
   • Industry benchmarks
   • Current trends

3. Must ask user?

   • Personal values/priorities
   • Constraints not documented
   • Success criteria </step_3_assess_information>

<step_4_gather> Gather Information

Execute information gathering based on assessment:

• Local: Use Read or Task(Explore) with token constraints
• Web: Use Task with WebSearch, structured return format
• User: Use AskUserQuestion with specific, focused questions

Parallel execution: If needs are independent, invoke multiple Task calls in single message.

Token budget guidance:

• Simple lookup: 1000-2000 tokens
• Moderate analysis: 2000-3000 tokens
• Complex research: 3000-5000 tokens </step_4_gather>

<step_5_execute> Execute Model(s)

With gathered context:

1. Load full model template from references/[model-name].md
2. Apply model systematically using template structure
3. For serial chains: complete each model before starting next
4. For parallel triangulation: apply all models, then compare </step_5_execute>

<step_6_synthesize> Synthesize Insights

Deliver:

• Key Insight: Single most important finding (1-2 sentences)
• Recommended Action: Specific next step
• Confidence Level: High/Medium/Low with reasoning
• Information Gaps: What couldn't be determined (if any) </step_6_synthesize>

</process> <validation>

Before proceeding to execution, verify:

• Problem type confirmed with user
• Model selection appropriate for type + focus
• Information needs classified (local/web/user)
• Required information gathered with structured responses
• Token budgets respected in subagent calls
• No open-ended research (all queries focused)

Red flags requiring user clarification:

• Problem fits multiple types equally
• Critical information unavailable
• High emotional loading detected
• Conflicting constraints identified

</validation>

<success_criteria>

Analysis is successful when:

• Problem correctly classified and confirmed
• Required information gathered efficiently (minimal tokens)
• Model(s) applied with full rigor using templates
• Insight is specific and actionable
• Confidence level justified
• User can take immediate action on recommendation

</success_criteria>

<output_format>

Classification Output Format

For the problem classification section (step 1), use TOON structured format:

@type: AnalyzeAction
name: problem-classification
object: [problem statement text]
actionStatus: CompletedActionStatus

classification:
primaryType: [DIAGNOSIS|DECISION|PRIORITIZATION|INNOVATION|RISK|FOCUS|OPTIMIZATION|STRATEGY]
temporalFocus: [PAST|PRESENT|FUTURE]
complexity: [SIMPLE|COMPLICATED|COMPLEX]
emotionalLoading: [HIGH|LOW]

signals[N]: [key,signal,words]

Note: Keep all reasoning, framework selection, model execution, and synthesis as markdown prose. Only use TOON for the structured classification output at the beginning of the analysis.

</output_format>

<references>

Model execution templates (read when applying specific model):

• references/5-whys.md - Root cause drilling
• references/10-10-10.md - Time horizon analysis
• references/eisenhower.md - Urgency/importance matrix
• references/first-principles.md - Assumption challenging
• references/inversion.md - Failure mode analysis
• references/occams-razor.md - Simplest explanation
• references/one-thing.md - Leverage identification
• references/opportunity-cost.md - Tradeoff analysis
• references/pareto.md - 80/20 analysis
• references/second-order.md - Consequence chains
• references/swot.md - Strategic position
• references/via-negativa.md - Improvement by subtraction
• references/six-hats.md - Parallel perspective exploration
• references/toc.md - Theory of Constraints logical thinking

</references>

<memory_reference>

For memory schema details, see mcp/memory-schema.md.

</memory_reference>