# ultrathink > UltraThink activates **Tier 3 Maximum Reasoning**: - Everything from Tier 1 + Tier 2 - PLUS agent swarm (6+ parallel agents) - PLUS ALL Superpowers skills - PLUS Chrome live monitoring - PLUS full code review suite - PLUS web search for external knowledge - PLUS memory write-back for learnings - PLUS multi-phase verification - Author: YOUSSEFELJAYAD - Repository: YOUSSEFELJAYAD/claude-payment-orchestrator - Version: 20260120215533 - Stars: 0 - Forks: 0 - Last Updated: 2026-02-07 - Source: https://github.com/YOUSSEFELJAYAD/claude-payment-orchestrator - Web: https://mule.run/skillshub/@@YOUSSEFELJAYAD/claude-payment-orchestrator~ultrathink:20260120215533 --- # Skill: UltraThink **Role:** Maximum Reasoning Engine (Tier 3) **Domain:** Comprehensive Analysis, Full Tool Orchestration & Knowledge Synthesis **Objective:** Activate MAXIMUM reasoning power by deploying ALL available MCP tools, ALL agents in parallel swarm, ALL Superpowers skills, live browser monitoring, full code review suite, web search, and persistent memory storage. ## Activation **Trigger:** User says "ultrathink" or task requires maximum analytical power **Mode:** Full autonomous orchestration with comprehensive reporting ## What This Enables UltraThink activates **Tier 3 Maximum Reasoning**: - Everything from Tier 1 + Tier 2 - PLUS agent swarm (6+ parallel agents) - PLUS ALL Superpowers skills - PLUS Chrome live monitoring - PLUS full code review suite - PLUS web search for external knowledge - PLUS memory write-back for learnings - PLUS multi-phase verification ## Execution Protocol ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ ULTRATHINK PROTOCOL │ │ ═══════════════════ │ │ Tier 3 Maximum Reasoning │ │ │ │ "When you need to understand EVERYTHING before acting" │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ ══════════════════════════════════════════════════════════════════════ │ │ PHASE 0: BRAINSTORMING (Pre-Analysis) │ │ ══════════════════════════════════════════════════════════════════════ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ Skill: superpowers:brainstorming │ │ │ │ Purpose: Fully understand requirements before ANY action │ │ │ │ Output: Clear problem definition, constraints, success criteria │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ ↓ │ │ ══════════════════════════════════════════════════════════════════════ │ │ PHASE 1: COMPREHENSIVE KNOWLEDGE GATHERING │ │ ══════════════════════════════════════════════════════════════════════ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ PARALLEL EXECUTION BLOCK 1: │ │ │ │ │ │ │ │ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ │ │ │ │ │ Episodic Memory │ │ Context7 │ │ Web Search │ │ │ │ │ │ ─────────────── │ │ ──────────────── │ │ ──────────────── │ │ │ │ │ │ search past │ │ get library docs │ │ search external │ │ │ │ │ │ conversations │ │ for ALL relevant │ │ knowledge, │ │ │ │ │ │ for decisions │ │ libraries │ │ latest patterns │ │ │ │ │ └──────────────────┘ └──────────────────┘ └──────────────────┘ │ │ │ │ │ │ │ │ ┌──────────────────┐ ┌──────────────────┐ │ │ │ │ │ Serena Memory │ │ Serena Analysis │ │ │ │ │ │ ──────────────── │ │ ──────────────── │ │ │ │ │ │ read all project │ │ get_symbols + │ │ │ │ │ │ memories │ │ find_symbol + │ │ │ │ │ │ │ │ search_pattern │ │ │ │ │ └──────────────────┘ └──────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ ↓ │ │ ══════════════════════════════════════════════════════════════════════ │ │ PHASE 2: AGENT SWARM DEPLOYMENT │ │ ══════════════════════════════════════════════════════════════════════ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ PARALLEL AGENT SWARM (6+ agents): │ │ │ │ │ │ │ │ ┌────────────────────────────────────────────────────────────────┐ │ │ │ │ │ EXPLORATION AGENTS │ │ │ │ │ │ • Explore (very thorough): Full codebase understanding │ │ │ │ │ │ • code-explorer: Execution path tracing │ │ │ │ │ │ • code-architect: Architecture analysis │ │ │ │ │ └────────────────────────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ ┌────────────────────────────────────────────────────────────────┐ │ │ │ │ │ PLANNING AGENTS │ │ │ │ │ │ • Plan: Implementation strategy │ │ │ │ │ │ • sequential-reasoner: Step-by-step logic validation │ │ │ │ │ └────────────────────────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ ┌────────────────────────────────────────────────────────────────┐ │ │ │ │ │ REVIEW AGENTS │ │ │ │ │ │ • code-reviewer: Quality and standards check │ │ │ │ │ │ • silent-failure-hunter: Error handling analysis │ │ │ │ │ │ • type-design-analyzer: Type safety review │ │ │ │ │ └────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ ↓ │ │ ══════════════════════════════════════════════════════════════════════ │ │ PHASE 3: ALL SUPERPOWERS SKILLS │ │ ══════════════════════════════════════════════════════════════════════ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ Invoke ALL relevant Superpowers: │ │ │ │ │ │ │ │ PROCESS SKILLS (in order): │ │ │ │ ✓ brainstorming - Design exploration │ │ │ │ ✓ writing-plans - Detailed implementation plan │ │ │ │ ✓ systematic-debugging - Root cause methodology │ │ │ │ ✓ test-driven-development - Write tests first │ │ │ │ │ │ │ │ EXECUTION SKILLS: │ │ │ │ ✓ subagent-driven-development - Parallel task execution │ │ │ │ ✓ executing-plans - Follow plans with checkpoints │ │ │ │ │ │ │ │ QUALITY SKILLS: │ │ │ │ ✓ requesting-code-review - Get thorough review │ │ │ │ ✓ receiving-code-review - Address feedback rigorously │ │ │ │ ✓ verification-before-completion - Verify with commands │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ ↓ │ │ ══════════════════════════════════════════════════════════════════════ │ │ PHASE 4: DUAL BROWSER VERIFICATION │ │ ══════════════════════════════════════════════════════════════════════ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ PLAYWRIGHT (Automated Testing): │ │ │ │ • browser_navigate, browser_fill_form, browser_click │ │ │ │ • browser_snapshot, browser_take_screenshot │ │ │ │ • browser_console_messages, browser_network_requests │ │ │ │ • browser_evaluate for custom checks │ │ │ │ │ │ │ │ CHROME (Live Monitoring): │ │ │ │ • use_browser: navigate to dashboards │ │ │ │ • use_browser: extract live data │ │ │ │ • use_browser: screenshot current state │ │ │ │ • use_browser: eval for debugging │ │ │ │ • Multi-tab monitoring for parallel systems │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ ↓ │ │ ══════════════════════════════════════════════════════════════════════ │ │ PHASE 5: FULL CODE REVIEW SUITE │ │ ══════════════════════════════════════════════════════════════════════ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ pr-review-toolkit agents (parallel): │ │ │ │ │ │ │ │ • code-reviewer: Style, patterns, best practices │ │ │ │ • code-simplifier: Reduce complexity │ │ │ │ • comment-analyzer: Documentation accuracy │ │ │ │ • pr-test-analyzer: Test coverage gaps │ │ │ │ • silent-failure-hunter: Error handling issues │ │ │ │ • type-design-analyzer: Type safety and invariants │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ ↓ │ │ ══════════════════════════════════════════════════════════════════════ │ │ PHASE 6: MULTI-PHASE VERIFICATION │ │ ══════════════════════════════════════════════════════════════════════ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ VERIFICATION CHECKLIST: │ │ │ │ │ │ │ │ □ Run all tests: mcp_serena.execute_shell_command │ │ │ │ □ Type check: mcp_serena.execute_shell_command │ │ │ │ □ Lint check: mcp_serena.execute_shell_command │ │ │ │ □ Build verification: mcp_serena.execute_shell_command │ │ │ │ □ E2E test: Playwright full flow │ │ │ │ □ Live check: Chrome dashboard monitoring │ │ │ │ □ Console errors: browser_console_messages │ │ │ │ □ Network health: browser_network_requests │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ ↓ │ │ ══════════════════════════════════════════════════════════════════════ │ │ PHASE 7: KNOWLEDGE SYNTHESIS & STORAGE │ │ ══════════════════════════════════════════════════════════════════════ │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ SYNTHESIS: │ │ │ │ • Collect ALL agent outputs │ │ │ │ • Cross-validate findings │ │ │ │ • Resolve conflicts │ │ │ │ • Identify consensus │ │ │ │ │ │ │ │ MEMORY STORAGE: │ │ │ │ • mcp_serena.write_memory: Store project learnings │ │ │ │ • Document: Decisions made │ │ │ │ • Document: Trade-offs considered │ │ │ │ • Document: Patterns discovered │ │ │ │ • Document: Gotchas and warnings │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ ↓ │ │ DELIVER MAXIMUM ANALYSIS │ │ • Comprehensive understanding from all sources │ │ • Validated by multiple agents │ │ • Verified by actual execution │ │ • Stored for future reference │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` ## ALL MCP Tools Activated ### Episodic Memory | Tool | Purpose | |------|---------| | `search` | Find past conversations (vector + text) | | `read` | Read full conversation context | ### Context7 | Tool | Purpose | |------|---------| | `resolve_library_id` | Get library identifiers | | `get_library_docs` | Retrieve latest documentation | ### Serena (Full Suite) | Tool | Purpose | |------|---------| | `find_symbol` | Semantic symbol search | | `get_symbols_overview` | File structure analysis | | `find_referencing_symbols` | Dependency tracing | | `replace_symbol_body` | Safe refactoring | | `insert_after_symbol` | Add code | | `replace_content` | Regex replacement | | `rename_symbol` | Cross-reference rename | | `search_for_pattern` | Pattern search | | `list_dir` | Directory exploration | | `read_file` | File reading | | `create_text_file` | File creation | | `write_memory` | Store learnings | | `read_memory` | Retrieve memories | | `list_memories` | List all memories | | `execute_shell_command` | Run commands | ### Playwright (Full Suite) | Tool | Purpose | |------|---------| | `browser_navigate` | Load pages | | `browser_snapshot` | Accessibility tree | | `browser_fill_form` | Form testing | | `browser_click` | Interaction testing | | `browser_type` | Text input | | `browser_select_option` | Dropdown selection | | `browser_console_messages` | Error checking | | `browser_network_requests` | API verification | | `browser_take_screenshot` | State documentation | | `browser_evaluate` | JavaScript execution | | `browser_run_code` | Async page code | | `browser_tabs` | Tab management | | `browser_resize` | Viewport testing | | `browser_press_key` | Keyboard input | | `browser_wait_for` | Wait conditions | ### Chrome (Full Suite) | Tool | Purpose | |------|---------| | `use_browser:navigate` | Load URLs with auto-capture | | `use_browser:click` | Click elements | | `use_browser:type` | Type text | | `use_browser:extract` | Extract content | | `use_browser:screenshot` | Capture state | | `use_browser:eval` | Execute JavaScript | | `use_browser:new_tab` | Open tabs | | `use_browser:list_tabs` | Tab management | | `use_browser:await_element` | Wait for elements | | `use_browser:await_text` | Wait for text | ### Web Search | Tool | Purpose | |------|---------| | `WebSearch` | Search for external knowledge | ## ALL Agents Activated ### Exploration Swarm | Agent | Purpose | |-------|---------| | `Explore` (very thorough) | Full codebase understanding | | `feature-dev:code-explorer` | Execution path tracing | | `feature-dev:code-architect` | Architecture design | ### Planning Agents | Agent | Purpose | |-------|---------| | `Plan` | Implementation strategy | | `general-purpose` | Complex multi-step tasks | ### Review Swarm | Agent | Purpose | |-------|---------| | `pr-review-toolkit:code-reviewer` | Quality check | | `pr-review-toolkit:code-simplifier` | Complexity reduction | | `pr-review-toolkit:comment-analyzer` | Documentation check | | `pr-review-toolkit:pr-test-analyzer` | Test coverage | | `pr-review-toolkit:silent-failure-hunter` | Error handling | | `pr-review-toolkit:type-design-analyzer` | Type safety | ## ALL Superpowers Skills Activated | Skill | Purpose | |-------|---------| | `brainstorming` | Requirements exploration | | `writing-plans` | Detailed implementation plans | | `systematic-debugging` | Root cause analysis | | `test-driven-development` | Tests first approach | | `subagent-driven-development` | Parallel execution | | `executing-plans` | Plan execution with checkpoints | | `requesting-code-review` | Get review | | `receiving-code-review` | Address feedback | | `verification-before-completion` | Command verification | | `using-git-worktrees` | Isolated workspaces | | `finishing-a-development-branch` | Completion workflow | ## Example Usage ``` User: ultrathink about redesigning the payment orchestration system Claude (activating ULTRATHINK): ═══════════════════════════════════════════════════════════════ ULTRATHINK MODE ACTIVATED - MAXIMUM REASONING POWER ═══════════════════════════════════════════════════════════════ [PHASE 0: BRAINSTORMING] Invoking superpowers:brainstorming... - Understanding requirements... - Defining constraints... - Establishing success criteria... [PHASE 1: KNOWLEDGE GATHERING - PARALLEL] ├─ Episodic Memory: Searching "payment orchestration design"... ├─ Context7: Getting docs for Stripe, Adyen, payment patterns... ├─ Web Search: Latest payment architecture patterns 2024... ├─ Serena Memory: Reading project decisions... └─ Serena Analysis: Mapping current architecture... [PHASE 2: AGENT SWARM - 8 AGENTS DEPLOYED] ├─ Explore: Deep codebase analysis... ├─ Plan: Designing migration strategy... ├─ code-architect: Architecture blueprint... ├─ code-explorer: Tracing payment flows... ├─ code-reviewer: Current code quality... ├─ silent-failure-hunter: Error handling gaps... ├─ type-design-analyzer: Type safety issues... └─ sequential-reasoner: Logic validation... [PHASE 3: SUPERPOWERS SKILLS] ├─ writing-plans: Creating detailed plan... ├─ systematic-debugging: Analyzing current issues... └─ test-driven-development: Test strategy... [PHASE 4: BROWSER VERIFICATION] ├─ Playwright: Testing current checkout flow... └─ Chrome: Monitoring payment dashboard... [PHASE 5: CODE REVIEW SUITE] ├─ Full review of payment module... ├─ Test coverage analysis... └─ Error handling audit... [PHASE 6: VERIFICATION] ├─ Running test suite... ├─ Type checking... ├─ Build verification... └─ E2E tests... [PHASE 7: SYNTHESIS & STORAGE] ├─ Combining 8 agent insights... ├─ Resolving conflicts... ├─ Writing to Serena memory... └─ Generating comprehensive report... ═══════════════════════════════════════════════════════════════ ULTRATHINK COMPLETE - FULL ANALYSIS DELIVERED ═══════════════════════════════════════════════════════════════ [Comprehensive redesign proposal with architecture, migration plan, risk analysis, test strategy, and implementation roadmap] ``` ## When to Use - Major architecture redesigns - Complex system debugging - Critical production issues - Multi-team coordination planning - Security incident response - Performance optimization - Migration planning - Technical debt analysis - Major feature planning ## Full Capability Matrix | Capability | think-hard | think-harder | ultrathink | |------------|:----------:|:------------:|:----------:| | Episodic Memory Search | ✅ | ✅ | ✅ | | Context7 Docs | ✅ | ✅ | ✅ | | Serena Code Analysis | ✅ | ✅ | ✅ | | TodoWrite Planning | ✅ | ✅ | ✅ | | Single Explore Agent | ✅ | ✅ | ✅ | | Writing-Plans Skill | ❌ | ✅ | ✅ | | Systematic-Debugging | ❌ | ✅ | ✅ | | Parallel Agents (3+) | ❌ | ✅ | ✅ | | Playwright Testing | ❌ | ✅ | ✅ | | Verification Skill | ❌ | ✅ | ✅ | | **Brainstorming Skill** | ❌ | ❌ | ✅ | | **ALL Superpowers** | ❌ | ❌ | ✅ | | **Chrome Live Monitoring** | ❌ | ❌ | ✅ | | **Full Code Review Suite** | ❌ | ❌ | ✅ | | **Agent Swarm (6+)** | ❌ | ❌ | ✅ | | **Web Search** | ❌ | ❌ | ✅ | | **Memory Write-Back** | ❌ | ❌ | ✅ | | **Multi-Phase Verification** | ❌ | ❌ | ✅ | ## Cost-Benefit Note UltraThink uses significant resources: - Multiple parallel agents - Multiple MCP server calls - Browser automation - External web searches Use when the task justifies maximum analysis. For simpler tasks, "think hard" or "think harder" are more efficient.