AI Discussion Partner

VerifiedCaution

Query another AI model (OpenAI, Anthropic, or Google) with extended thinking to get an outside perspective on a difficult problem. Use when you are stuck, spinning your wheels, or suspect an unconsidered angle. One message out, one message back — include all necessary context because the partner has zero context about your work.

Sby Skills Guide Bot
DevelopmentIntermediate
406/2/2026
Claude Code
#ai-assistance#external-models#problem-solving#thinking-models

Recommended for

Our review

Lets you query another AI model (OpenAI, Anthropic, Google) for an external perspective on a difficult problem.

Strengths

  • Provides a fresh, unbiased viewpoint from a different model
  • Supports multiple models with extended thinking (GPT-5.2, Claude Opus 4.6, Gemini 3.1 Pro)
  • Guides the user to frame a precise, contextual question
  • Single-shot interaction, ideal for unblocking a stalled situation

Limitations

  • Requires the user to include all context in one message (no follow-up)
  • Depends on external API keys that must be set up beforehand
  • Potentially high cost for the most advanced models
When to use it

When you are stuck on a hard problem, spinning your wheels, or suspect there is an angle you haven't considered.

When not to use it

For routine tasks you can handle directly, or if you can solve the problem with local resources.

Security analysis

Caution
Quality score85/100

The skill instructs the agent to execute a Python script via Bash to query external AI models. While it does not contain obfuscation, destructive commands, or exfiltration, the use of network calls and passing user-provided strings as shell arguments introduces moderate risk. Proper quoting is used, but caution is warranted.

Findings
  • Uses Bash to run arbitrary Python scripts with uv run, which involves network calls to external AI APIs.
  • User-supplied questions are passed as command-line arguments; special characters could cause injection if not properly handled by the script, though quoting mitigates this.
  • Instructs agent to echo part of the API key for verification, which could be displayed in logs.

Examples

Debugging auth middleware
Here is my auth middleware code: [Paste code]. Users with expired tokens get a 500 instead of 401. I have verified the token validation logic is correct and the error handler is registered. The 500 comes from this stack trace: [Paste trace]. What could cause the error handler to be bypassed?
Architecture review
I'm designing a microservices system for a video processing pipeline. The current design uses a message queue to distribute tasks to workers, but I'm concerned about latency spikes when a large video arrives. Here are the details: [Paste context]. What alternative architecture or batching strategy would you recommend? Give me pros and cons.

name: discussion_partners description: > Ask a question to another AI model (OpenAI, Anthropic, or Google) with extended thinking enabled. Use when you are stuck on a difficult problem, suspect you are spinning your wheels, or sense there is an angle you have not considered. Do NOT use for routine tasks you can handle directly. allowed-tools: Bash(uv run *)

Query another AI model for an outside perspective on a difficult problem. One message out, one message back — make it count.

Recommended Models

Always use the script default (openai:gpt-5.2) unless you have a specific reason to change. Do NOT override with older models like o3 — they are expensive and superseded.

| Model | When to use | API key needed | |-------|-------------|----------------| | openai:gpt-5.2 (default) | Primary partner. xhigh thinking, exceptional detail | OPENAI_API_KEY | | google-gla:gemini-3.1-pro-preview | Second opinion, brilliantly intelligent reasoning | GOOGLE_API_KEY | | anthropic:claude-opus-4-6 | Third perspective, different reasoning style | ANTHROPIC_API_KEY |

Before calling, verify the required API key is set: echo $OPENAI_API_KEY | head -c 8 (should show sk-...).

Framing Your Question

You get one message out and one message back. There is no follow-up. Your partner has ZERO context about what you're working on — they see only what you send. The context window is finite and expensive, so treat it like a skill prompt: include everything needed, nothing that isn't.

Your partner needs all context to answer your question. They cannot read your files, see your conversation, or infer your situation. If you don't include it, they don't know it. But context is limited, so be surgical:

  1. Include all relevant context: code, errors, constraints, what you tried. Use mental_models to structure your thinking before asking.
  2. State what you're stuck on: "I tried A, B, C and none work because D" — not just "help me with X"
  3. Ask a specific question and set the frame: what kind of answer you need (diagnosis, alternative approach, code review).
  4. Never include secrets: API keys, credentials, tokens, or private repo URLs. Your question goes to an external API.

Bad: "How do I fix this auth bug?" Good: "Here is my auth middleware [code]. Users with expired tokens get a 500 instead of 401. I have verified the token validation logic is correct and the error handler is registered. The 500 comes from [stack trace]. What could cause the error handler to be bypassed?"

Usage

uv run --directory SKILL_DIR python scripts/ask_model.py -m <model> "Your detailed question with full context"

Where SKILL_DIR is the directory containing this skill. The -m flag takes a full pydantic-ai model string — the provider prefix determines which API key and thinking settings to use.

Models

The default is openai:gpt-5.2. Thinking effort is automatically set to maximum for each provider.

# GPT-5.2 with xhigh reasoning (default — just omit -m)
uv run --directory SKILL_DIR python scripts/ask_model.py "question"

# Claude Opus 4.6 with adaptive thinking at max effort
uv run --directory SKILL_DIR python scripts/ask_model.py -m anthropic:claude-opus-4-6 "question"

# Gemini 3.1 Pro with thinking enabled
uv run --directory SKILL_DIR python scripts/ask_model.py -m google-gla:gemini-3.1-pro-preview "question"

# Codex models (via OpenAI Responses API)
uv run --directory SKILL_DIR python scripts/ask_model.py -m openai-responses:gpt-5-codex "question"
uv run --directory SKILL_DIR python scripts/ask_model.py -m openai-responses:codex-mini-latest "question"

API Key Setup

Add keys to your shell profile (~/.zshrc or ~/.bashrc):

export OPENAI_API_KEY="your-key"      # Required for openai: and openai-responses: models
export ANTHROPIC_API_KEY="your-key"   # Required for anthropic: models
export GOOGLE_API_KEY="your-key"      # Required for google-gla: models

The script checks for the key before calling the API. If missing, it tells you which variable to set. If the key exists but the call fails, common errors:

  • insufficient_quota (429): Billing issue — add credits at the provider's dashboard.
  • invalid_api_key (401): Wrong key — check you exported the correct one and ran source ~/.zshrc.
  • rate_limit (429): Too many requests — wait and retry.

Options

  • --model / -m: Full pydantic-ai model string (default: openai:gpt-5.2)
  • --system / -s: Optional system prompt override
  • --list-models / -l: List known model names, optionally filtered by prefix (e.g. -l openai, -l anthropic). Codex models appear under openai: but must be called with openai-responses: prefix.

Multiple Calls

Each call gets zero context from previous calls. For follow-ups, include the prior exchange: "I asked X, you answered Y, help me understand Z."

Related skills