External Model Selection

External Model Selection

Purpose: Select the best external AI models for your specific task based on empirical performance data from production bug investigations.

When Claude invokes this Skill: When you need to consult external models, choose between different LLMs, or want diverse perspectives on architectural decisions, code bugs, or design choices.

Quick Reference: Top Models

🥇 Tier 1 - Primary Recommendations (Use First)

1. MiniMax M2 (minimax/minimax-m2)

• Score: 91/100 | Speed: 3 min ⚡⚡⚡ | Cost: $$
• Best for: Fast root cause analysis, production bugs, when you need simple implementable fixes
• Proven: Found exact bug (column calculation error) in 3 minutes during LSP investigation
• Why it wins: Pinpoint accuracy, avoids overengineering, focuses on simplest solution first

2. Grok Code Fast (x-ai/grok-code-fast-1)

• Score: 83/100 | Speed: 4 min ⚡⚡ | Cost: $$
• Best for: Debugging traces, validation strategies, test coverage design
• Proven: Step-by-step execution traces, identified tab/space edge cases
• Why it wins: Excellent debugging methodology, practical validation approach

3. GPT-5.1 Codex (openai/gpt-5.1-codex)

• Score: 80/100 | Speed: 5 min ⚡ | Cost: $$$
• Best for: Architectural redesign, long-term refactoring plans
• Proven: Proposed granular mapping system for future enhancements
• Why it's valuable: Strong architectural vision, excellent for planning major changes

4. Sherlock Think Alpha (openrouter/sherlock-think-alpha) 🎁 FREE

• Score: TBD | Speed: ~5 min ⚡ | Cost: FREE ($0!) 💰
• Context: 1.8M tokens (LARGEST context window available!)
• Best for: Massive codebase analysis, entire project reasoning, long-context planning
• Secret: Big player testing under weird name - don't let the name fool you
• Specialties:
  • Full codebase analysis (1.8M tokens = ~500k lines of code!)
  • Research synthesis across dozens of files
  • Protocol compliance & standards validation
  • Entire project architectural analysis
• Why it's valuable: FREE + massive context = ideal for comprehensive analysis
• Use case: When you need to analyze entire codebase or massive context (and it's FREE!)

5. Gemini 3 Pro Preview (google/gemini-3-pro-preview) ⭐ NEW

• Score: TBD | Speed: ~5 min ⚡ | Cost: $$$
• Context: 1M tokens (11.4B parameter model)
• Best for: Multimodal reasoning, agentic coding, complex architectural analysis, long-context planning
• Strengths: State-of-the-art on LMArena, GPQA Diamond, MathArena, SWE-Bench Verified
• Specialties:
  • Autonomous agents & coding assistants
  • Research synthesis & planning
  • High-context information processing (1M token window!)
  • Tool-calling & long-horizon planning
  • Multimodal analysis (text, code, images)
• Why it's valuable: Google's flagship frontier model, excels at inferring intent with minimal prompting
• Use case: When you need deep reasoning across massive context (entire codebase analysis)

🥈 Tier 2 - Specialized Use Cases

6. Gemini 2.5 Flash (google/gemini-2.5-flash)

• Score: 73/100 | Speed: 6 min ⚡ | Cost: $
• Best for: Ambiguous problems requiring exhaustive hypothesis exploration
• Caution: Can go too deep - best when truly uncertain about root cause
• Value: Low cost, thorough analysis when you need multiple angles

7. GLM-4.6 (z-ai/glm-4.6)

• Score: 70/100 | Speed: 7 min 🐢 | Cost: $$
• Best for: Adding debug infrastructure, algorithm enhancements
• Caution: Tends to overengineer - verify complexity is warranted
• Use case: When you actually need priority systems or extensive logging

❌ AVOID - Known Reliability Issues

Qwen3 Coder (qwen/qwen3-coder-30b-a3b-instruct)

• Score: 0/100 | Status: FAILED (timeout after 8+ minutes)
• Issue: Reliability problems, availability issues
• Recommendation: DO NOT use for time-sensitive or production tasks

Consultation Strategies

Strategy 1: Fast Parallel Diagnosis (DEFAULT - 90% of use cases)

Models: minimax/minimax-m2 + x-ai/grok-code-fast-1

# Launch 2 models in parallel (single message, multiple Task calls)
Task 1: golang-architect (PROXY MODE) → MiniMax M2
Task 2: golang-architect (PROXY MODE) → Grok Code Fast

Time: ~4 minutes total Success Rate: 95%+ Cost: $$ (moderate)

Use for:

• Bug investigations
• Quick root cause diagnosis
• Production issues
• Most everyday tasks

Benefits:

• Fast diagnosis from MiniMax M2 (simplest solution)
• Validation strategy from Grok Code Fast (debugging trace)
• Redundancy if one model misses something

Strategy 2: Comprehensive Analysis (Critical issues)

Models: minimax/minimax-m2 + openai/gpt-5.1-codex + x-ai/grok-code-fast-1

# Launch 3 models in parallel
Task 1: golang-architect (PROXY MODE) → MiniMax M2
Task 2: golang-architect (PROXY MODE) → GPT-5.1 Codex
Task 3: golang-architect (PROXY MODE) → Grok Code Fast

Time: ~5 minutes total Success Rate: 99%+ Cost: $$$ (high but justified)

Use for:

• Critical production bugs
• Architectural decisions
• High-impact changes
• When you need absolute certainty

Benefits:

• Quick fix (MiniMax M2)
• Long-term architectural plan (GPT-5.1)
• Validation and testing strategy (Grok)
• Triple redundancy

Strategy 3: Deep Exploration (Ambiguous problems)

Models: minimax/minimax-m2 + google/gemini-2.5-flash + x-ai/grok-code-fast-1

# Launch 3 models in parallel
Task 1: golang-architect (PROXY MODE) → MiniMax M2
Task 2: golang-architect (PROXY MODE) → Gemini 2.5 Flash
Task 3: golang-architect (PROXY MODE) → Grok Code Fast

Time: ~6 minutes total Success Rate: 90%+ Cost: $$ (moderate)

Use for:

• Ambiguous bugs with unclear root cause
• Multi-faceted problems
• When initial investigation is inconclusive
• Complex system interactions

Benefits:

• Quick hypothesis (MiniMax M2)
• Exhaustive exploration (Gemini 2.5 Flash)
• Practical validation (Grok)
• Diverse analytical approaches

Strategy 4: Full Codebase Analysis (Massive Context) 🆕

Models: openrouter/sherlock-think-alpha + google/gemini-3-pro-preview

# Launch 2 models in parallel
Task 1: golang-architect (PROXY MODE) → Sherlock Think Alpha
Task 2: golang-architect (PROXY MODE) → Gemini 3 Pro Preview

Time: ~5 minutes total Success Rate: TBD (new strategy) Cost: $$$ (one free, one paid = moderate overall)

Use for:

• Entire codebase architectural analysis
• Cross-file dependency analysis
• Large refactoring planning (50+ files)
• System-wide pattern detection
• Multi-module projects

Benefits:

• Sherlock: 1.8M token context (FREE!) - can analyze entire codebase
• Gemini 3 Pro: 1M token context + multimodal + SOTA reasoning
• Both have massive context windows for holistic analysis
• One free model reduces cost significantly

Prompt Strategy:

Analyze the entire Dingo codebase focusing on [specific aspect].

Context provided:
- All files in pkg/ (50+ files)
- All tests in tests/ (60+ files)
- Documentation in ai-docs/
- Total: ~200k lines of code

Your task: [specific analysis goal]

Strategy 5: Budget-Conscious (Cost-sensitive) 🎁

Models: openrouter/sherlock-think-alpha + x-ai/grok-code-fast-1

# Launch 2 models in parallel
Task 1: golang-architect (PROXY MODE) → Sherlock Think Alpha (FREE!)
Task 2: golang-architect (PROXY MODE) → Grok Code Fast

Time: ~5 minutes total Success Rate: 85%+ Cost: $$ (Sherlock is FREE, only pay for Grok!)

Use for:

• Cost-sensitive projects
• Large context needs on a budget
• Non-critical investigations
• Exploratory analysis
• Learning and experimentation

Benefits:

• Sherlock is completely FREE with 1.8M context!
• Massive context window for comprehensive analysis
• Grok provides debugging methodology
• Lowest cost option with high value

Decision Tree: Which Strategy?

START: Need external model consultation
    ↓
[What type of task?]
    ↓
├─ Bug Investigation (90% of cases)
│  → Strategy 1: MiniMax M2 + Grok Code Fast
│  → Time: 4 min | Cost: $$ | Success: 95%+
│
├─ Critical Bug / Architectural Decision
│  → Strategy 2: MiniMax M2 + GPT-5.1 + Grok
│  → Time: 5 min | Cost: $$$ | Success: 99%+
│
├─ Ambiguous / Multi-faceted Problem
│  → Strategy 3: MiniMax M2 + Gemini + Grok
│  → Time: 6 min | Cost: $$ | Success: 90%+
│
└─ Cost-Sensitive / Exploratory
   → Strategy 4: Gemini + Grok
   → Time: 6 min | Cost: $ | Success: 85%+

Critical Implementation Details

1. ALWAYS Use 10-Minute Timeout

CRITICAL: External models take 5-10 minutes. Default 2-minute timeout WILL fail.

# When delegating to agents in PROXY MODE:
Task tool → golang-architect:

**CRITICAL - Timeout Configuration**:
When executing claudish via Bash tool, ALWAYS use:
```bash
Bash(
    command='cat prompt.md | claudish --model [model-id] > output.md 2>&1',
    timeout=600000,  # 10 minutes (REQUIRED!)
    description='External consultation via [model-name]'
)

Why: Qwen3 Coder failed due to 2-minute timeout. 10 minutes prevents this.

2. Launch Models in Parallel (Single Message)

CORRECT (6-8x speedup):

# Single message with multiple Task calls
Task 1: golang-architect (PROXY MODE) → Model A
Task 2: golang-architect (PROXY MODE) → Model B
Task 3: golang-architect (PROXY MODE) → Model C
# All execute simultaneously

WRONG (sequential, slow):

# Multiple messages
Message 1: Task → Model A (wait...)
Message 2: Task → Model B (wait...)
Message 3: Task → Model C (wait...)
# Takes 3x longer

3. Agent Return Format (Keep Brief!)

Agents in PROXY MODE MUST return MAX 3 lines:

[Model-name] analysis complete
Root cause: [one-line summary]
Full analysis: [file-path]

DO NOT return full analysis in agent response (causes context bloat).

4. File-Based Communication

Input: Write investigation prompt to file

ai-docs/sessions/[timestamp]/input/investigation-prompt.md

Output: Agents write full analysis to files

ai-docs/sessions/[timestamp]/output/[model-name]-analysis.md

Main chat: Reads ONLY summaries, not full files

Evidence: What Made Top Models Win

Based on LSP Source Mapping Bug Investigation (Session 20251118-223538):

✅ Success Patterns

MiniMax M2 (91/100):

• Identified exact bug: qPos calculation produces column 15 instead of 27
• Proposed simplest fix: Change strings.Index() to strings.LastIndex()
• Completed in 3 minutes
• Key insight: "The bug is entirely in source map generation"

Grok Code Fast (83/100):

• Provided step-by-step execution trace
• Identified tab vs spaces edge case
• Proposed validation strategy with debug logging
• Key insight: "Generated_column values don't match actual positions due to prefix length"

GPT-5.1 Codex (80/100):

• Identified architectural limitation (coarse-grained mappings)
• Proposed long-term solution: granular mapping segments
• Excellent testing strategy
• Key insight: "Single coarse-grained mapping per error propagation"

❌ Failure Patterns

Gemini 2.5 Flash (73/100):

• Went too deep into fallback logic (not the root cause)
• Explored 10+ hypotheses
• Missed the simple bug (qPos calculation)
• Issue: Too thorough, lost focus on simplest explanation

GLM-4.6 (70/100):

• Focused on MapToOriginal algorithm (which was correct)
• Proposed complex enhancements (priority system, debug logging)
• Overengineered the solution
• Issue: Added complexity when simple data fix was needed

Sherlock Think (65/100):

• Focused on 0-based vs 1-based indexing (secondary issue)
• Proposed normalization (helpful but not main fix)
• Expensive at $$$ for limited value
• Issue: Fixed symptoms, not root cause

Qwen3 Coder (0/100):

• Timed out after 8+ minutes
• No output produced
• Reliability issues
• Issue: Complete failure, avoid entirely

Performance Benchmarks (Empirical Data)

Test: LSP Source Mapping Bug (diagnostic underlining wrong code) Methodology: 8 models tested in parallel on real production bug

Key Finding: Faster models (3-5 min) delivered better results than slower ones (6-8 min).

Correlation: Speed ↔ Simplicity (faster models prioritize simple explanations first)

When to Use Each Model

Use MiniMax M2 when:

• ✅ Need fast, accurate diagnosis (3 minutes)
• ✅ Want simplest solution (avoid overengineering)
• ✅ Production bug investigation
• ✅ Most everyday tasks (90% of use cases)

Use Grok Code Fast when:

• ✅ Need detailed debugging trace
• ✅ Want validation strategy
• ✅ Designing test coverage
• ✅ Understanding execution flow

Use GPT-5.1 Codex when:

• ✅ Planning major architectural changes
• ✅ Need long-term refactoring strategy
• ✅ Want comprehensive testing approach
• ✅ High-level design decisions

Use Gemini 2.5 Flash when:

• ✅ Problem is genuinely ambiguous
• ✅ Need exhaustive hypothesis exploration
• ✅ Budget is constrained (low cost)
• ✅ Multiple potential root causes

Avoid using when:

• ❌ Problem is simple/obvious (just fix it)
• ❌ Sonnet 4.5 internal can answer (use internal first)
• ❌ Already-solved problem (check docs first)
• ❌ Time-critical (Qwen3 unreliable)

Example: Invoking External Models

Step 1: Create Session

SESSION=$(date +%Y%m%d-%H%M%S)
mkdir -p ai-docs/sessions/$SESSION/{input,output}

Step 2: Write Investigation Prompt

# Write clear, self-contained prompt
echo "Problem: LSP diagnostic underlining wrong code..." > \
  ai-docs/sessions/$SESSION/input/investigation-prompt.md

Step 3: Choose Strategy

Based on decision tree:

• Bug investigation → Strategy 1 (MiniMax M2 + Grok)

Step 4: Launch Agents in Parallel

Single message with 2 Task calls:

Task 1 → golang-architect (PROXY MODE):

You are operating in PROXY MODE to investigate bug using MiniMax M2.

INPUT FILES:
- ai-docs/sessions/$SESSION/input/investigation-prompt.md

YOUR TASK (PROXY MODE):
1. Read investigation prompt
2. Use claudish to consult minimax/minimax-m2
3. Write full response to output file

**CRITICAL - Timeout**:
Bash(timeout=600000)  # 10 minutes!

OUTPUT FILES:
- ai-docs/sessions/$SESSION/output/minimax-m2-analysis.md

RETURN (MAX 3 lines):
MiniMax M2 analysis complete
Root cause: [one-line]
Full analysis: [file-path]

Task 2 → golang-architect (PROXY MODE):

[Same structure for Grok Code Fast]

Step 5: Consolidate

After receiving both summaries:

1. Review 1-line summaries from each model
2. Identify consensus vs disagreements
3. Optionally read full analyses if needed
4. Decide on action based on recommendations

Supporting Files

• BENCHMARKS.md - Detailed performance metrics and test methodology
• STRATEGIES.md - Deep dive into each consultation strategy with examples

Validation & Maintenance

Last Validated: 2025-11-18 (Session 20251118-223538) Next Review: 2025-05 (6 months) Test Task: LSP Source Mapping Bug

Re-validation Schedule:

• Every 3-6 months
• After new models become available
• When model performance changes significantly

Track:

• Model availability/reliability
• Speed improvements
• Accuracy changes
• Cost fluctuations

Summary: Quick Decision Guide

Most common use case (90%): → Use Strategy 1: MiniMax M2 + Grok Code Fast → Time: 4 min | Cost: $$ | Success: 95%+

Critical issues: → Use Strategy 2: MiniMax M2 + GPT-5.1 + Grok → Time: 5 min | Cost: $$$ | Success: 99%+

Ambiguous problems: → Use Strategy 3: MiniMax M2 + Gemini + Grok → Time: 6 min | Cost: $$ | Success: 90%+

Cost-sensitive: → Use Strategy 4: Gemini + Grok → Time: 6 min | Cost: $ | Success: 85%+

Remember:

• ⏱️ Always use 10-minute timeout
• 🚀 Launch models in parallel (single message)
• 📝 Communication via files (not inline)
• 🎯 Brief summaries only (MAX 3 lines)

Full Reports:

• Comprehensive comparison: ai-docs/sessions/20251118-223538/01-planning/comprehensive-model-comparison.md
• Model ranking analysis: ai-docs/sessions/20251118-223538/01-planning/model-ranking-analysis.md