Performs exhaustive multi-lens analysis through human, structural, inclusivity, and sustainability perspectives with domain-specific augmentation. Use when the user says "ULTRATHINK" (case-insensitive), uses /ultrathink, or faces complex decisions requiring maximum reasoning depth.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Performs exhaustive multi-lens analysis through human, structural, inclusivity, and sustainability perspectives with domain-specific augmentation. Use when the user says "ULTRATHINK" (case-insensitive), uses /ultrathink, or faces complex decisions requiring maximum reasoning depth.
license
MIT
Ultrathink
Upon activation:
1. Prioritise depth over brevity -- expand reasoning until the logic is complete
2. Engage maximum reasoning depth -- no shortcuts, no "good enough"
3. Detect the domain and load the relevant reference file (see Domain Detection)
4. Apply the universal analysis framework (4 universal lenses + domain augmentation)
5. Document logical steps such that each conclusion follows explicitly from stated premises
Domain Detection
Before applying the analysis framework, identify the primary domain of the request.
Analyze every request through these four universal lenses:
When ULTRATHINK is active, structure responses as:
Before delivering analysis, verify:
**Prompt:** ULTRATHINK: Our deployment pipeline fails every Friday but works Monday-Thursday.
**Prompt:** ULTRATHINK: Should we enter the European market this year or double down on US growth?
**Prompt:** ULTRATHINK: This blog post loses the reader at paragraph 4. Help me restructure it.
If user explicitly states the domain ("ULTRATHINK from a legal perspective"): use that domain
Otherwise: scan request for signal keywords, select domain with most matches
If two domains match closely: load both reference files, apply composability rules below
If no domain matches clearly: apply universal lenses only (no augmentation)
If uncertain: state the detected domain and ask user to confirm before proceeding
Multi-Domain Composability
When a request spans two domains:
Apply all 4 universal lenses (always)
Load augmentation lenses from both domains (up to 4 augmentation lenses total)
Use the primary domain's deliverable format
State which domains were detected and why
When three or more domains match:
Use the two strongest matches only
Note the third as secondary context without adding its augmentation lenses
Analysis Framework
Human (who is affected?)
Identify stakeholder sentiment (frustrated/curious/confused/expert) and adjust depth
Assess cognitive load—will this solution overwhelm or underwhelm the audience?
Check mental model alignment—does the solution match how people think about this problem?
Evaluate adoption friction—is the complexity justified by the benefits?
Structural (how does it work?)
Mechanics: What are the moving parts, dependencies, and constraints?
Resource impact: What does this consume (time, money, compute, attention)?
Complexity budget: Is the complexity proportional to the value delivered?
Dependencies: What must exist or be true for this to work?
Inclusivity (who might be excluded?)
Access barriers: Who cannot use or benefit from this solution? Why?
Representation: Whose perspective is missing from the analysis?
Communication clarity: Is it understandable across skill levels, cultures, languages?
Failure equity: When this fails, does it fail harder for some groups than others?
Sustainability (does it last?)
Maintenance burden: Who maintains this and at what cost?
Extensibility: What changes require rework vs. configuration?
Knowledge transfer: Can someone new take this over?
Scale behavior: Does this work at 10x? At 0.1x?
Domain Augmentation: After applying universal lenses, load the detected domain's reference file and apply its augmentation lens(es). These add analytical dimensions genuinely orthogonal to the universal four.
Response Structure
1. Deep Reasoning Chain
Detailed breakdown of decisions:
State the problem precisely—what are we solving and what constraints exist?
Identify the domain and state which lenses apply (4 universal + augmentation)
Enumerate all viable approaches (minimum 3)
Analyze each approach through all applicable lenses with explicit scores or tradeoffs
Build a logical chain: "Because X, therefore Y, which implies Z"
Justify every decision—if a choice has 2+ valid alternatives, explain why this one wins
2. Edge Case Analysis
Comprehensive failure mode exploration:
What could go wrong (enumerate specific scenarios, not vague risks)
How each risk is mitigated (specific mechanism, not hand-waving)
Fallback strategies when mitigations fail
Recovery mechanisms—how does the system return to healthy state?
3. The Deliverable
Production-ready output appropriate to the domain:
Optimized for the specific context discussed in reasoning chain
Leverages existing conventions (do not introduce new paradigms without justification)
Addresses failure modes enumerated in edge case analysis
Inline commentary for any decision where 2+ valid alternatives existed
The Deliverable adapts to the domain: code for software engineering, polished prose for writing, decision recommendation for strategy, research design for research, design specification for design, lesson plan for learning, ethical analysis for ethics, analysis report for data, legal brief for legal, diagnosis report for problem-solving.
Quality Gate
All 4 universal lenses explicitly addressed with specific observations?
At least 3 approaches enumerated before selecting one?
Edge cases are concrete scenarios, not vague "something might fail"?
Each recommendation states what is sacrificed (no free lunches)?
Logical chain is traceable—can a reviewer follow premise to conclusion?
If any box is unchecked, revisit that section before delivering.
Surface-level reasoning is prohibited. If the analysis feels easy, dig deeper until the logic is irrefutable.
Indicator
Action
First obvious solution
Challenge it with 3+ edge cases before accepting
Single perspective
Apply the remaining lenses explicitly
Missing tradeoffs
State what is sacrificed for each benefit claimed
Assumption made
State it, then validate or flag as risk
Domain unclear
State detected domain, ask user to confirm
Examples
Three compact examples below. See references/examples.md for full worked examples. Each domain reference file contains 2-3 additional domain-specific examples.
Deep Reasoning Chain: Three approaches investigated (environment diff, temporal analysis, load analysis). Root cause found via 5 Whys: log aggregation job runs Thursday night, fills /tmp, causing disk exhaustion before Friday builds.
Deep Reasoning Chain: Three approaches (full EU launch, US-only with EU pilot, deferred partnership). Probability-weighted: P(full launch ROI in 18mo) ~25%, P(pilot validates demand) ~70%. Pre-mortem: "Burned $600K with 3 customers because we underestimated localisation." Runway constraint eliminates full launch.
Edge Cases: Pilot churn from incomplete localisation, board interpreting pilot as lack of ambition, regulatory surprise (Digital Markets Act).
Deliverable: Recommendation table with assumptions, confidence levels, and falsification signals. Phased action plan with gate review at $100K ARR from pilot cohort. Explicit sacrifice stated: 6 months slower than full launch.
Deep Reasoning Chain: Three approaches (inverted pyramid, problem-solution-evidence, narrative arc). Diagnosis: paragraphs 1-3 are throat-clearing with no stakes. The author's sharpest observation is buried in paragraph 5. Problem-solution-evidence fits the time-poor tech manager audience.
Edge Cases: Author resists restructuring (attached to chronological setup), multiple audiences (managers and ICs), SEO vs. readability tension.
Deliverable: Restructured outline with editorial annotations. Hook moved to paragraph 1. Each paragraph earns the next. Closing echoes the opening for structural completeness.
Scope
ULTRATHINK applies to reasoning depth and analysis structure only. It does not change:
Tool selection or file operations
Communication with external services
Git operations or other side effects
For simple factual questions where the answer is clear and unambiguous, state the answer directly and note that ULTRATHINK was invoked but full multi-lens analysis is unnecessary—depth should match the complexity of the problem.
