second-opinion

Second Opinion — external AI CLI reference

This skill teaches how to drive other AI coding assistants from the shell, in non-interactive (headless) mode, so Claude Code can collect independent opinions and synthesize them. The companion /second-opinion command orchestrates the flow; this file is the per-tool detail.

Golden rules

1. Probe before use: command -v <tool>. Only use what's installed.
2. Verify flags live: flags change between versions — run <tool> --help before composing the real call. Treat the tables below as the expected form.
3. Stay headless: always use the one-shot/print/exec flag so the tool answers and exits. Never drop into an interactive REPL from within a command.
4. Self-contained prompts: external tools don't see this conversation. Put the question + code/diff + desired output format in the prompt.
5. Guard the call: wrap with timeout, handle missing API keys gracefully, and never let one tool's failure abort the others.
6. Attribute: in the synthesis, say which tool said what, and keep your own independent judgment.

---

Tool: Gemini CLI (gemini)

Google's open-source terminal agent for the Gemini models.

• Headless / non-interactive: gemini -p "PROMPT" (also --prompt). Piping works: cat diff.txt | gemini -p "Review this diff for bugs".
• Model: -m gemini-2.5-pro (or -m gemini-2.5-flash for speed/cost).
• Auto-approve tools (use with care): -y / --yolo.
• Auth: GEMINI_API_KEY env var (AI Studio key), or an interactive Google login the user has already done. If unauthenticated it will error — report and skip.
• Install: npm install -g @google/gemini-cli then run gemini.

Good for: fast general second opinions, large-context reasoning, and reading files you point it at.

Tool: OpenAI Codex CLI (codex)

OpenAI's open-source coding agent.

• Headless / non-interactive: codex exec "PROMPT" (the exec subcommand runs to completion and prints, no TUI). On older builds the flag was -q/--quiet: codex -q "PROMPT". Confirm with codex exec --help.
• Model: -m <model> (e.g. a current GPT/o-series coding model).
• Sandbox/approvals: exec runs non-interactively; review its --help for --full-auto / approval and sandbox flags before granting write access.
• Auth: codex login, or OPENAI_API_KEY in the environment.
• Install: npm install -g @openai/codex (or brew install codex).

Good for: strong code reasoning and an opinion from a non-Google, non-Anthropic model — valuable independence for consensus.

Tool: Grok CLI — Grok Build (grok)

xAI's official terminal coding agent, Grok Build (binary grok), an agentic CLI in the same class as Claude Code / Codex. Prefer this over third-party Grok CLIs (e.g. @vibe-kit/grok-cli).

• Headless / non-interactive: grok -p "PROMPT" runs one-shot without the TUI and prints the result. Add --output-format text|json|streaming-json for machine-readable output. Verify with grok --help as flags evolve.
• CI-friendly flags: --no-auto-update (skip background update checks) and --always-approve (skip interactive approvals) for scripts/CI.
• Model: runs on xAI's purpose-built grok-build-0.1 by default; a --model flag may be available — check grok --help.
• Auth: interactive browser sign-in on first grok launch (SuperGrok / X Premium+). For headless servers / CI, set GROK_CODE_XAI_API_KEY="xai-..." (an XAI_API_KEY from the xAI developer console).
• Install: curl -fsSL https://x.ai/cli/install.sh | bash — puts a grok binary on your PATH.
• Fallback: if the CLI is absent but XAI_API_KEY is set, you may call the xAI REST API with curl (OpenAI-compatible /v1/chat/completions on api.x.ai).

Good for: a third independent model family; Grok often has a distinct style/opinion.

Tool: Aider (aider)

Open-source AI pair programmer that edits files in your git repo.

• Opinion only (no edits) — preferred: aider --message "PROMPT" --chat-mode ask. The ask chat mode answers questions and discusses without touching files, and --message runs once and exits. This is the right mode for a second opinion.
• One-shot message: aider --message "PROMPT" (alias -m) runs once and exits. Add --yes-always to auto-confirm prompts.
• Model: --model <name> (Aider supports many providers via LiteLLM).
• ⚠ Aider edits files. Without --chat-mode ask, even a single --message can change the working tree and (unless disabled) commit. If you want Aider's actual proposed implementation as its "opinion":
  • add --no-auto-commits (review with git diff, then revert if unwanted), or
  • run it against a throwaway copy of the repo.
• Auth: provider key for the chosen model (OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, …).
• Install: python -m pip install aider-install && aider-install, or pipx install aider-chat.

Good for: "show me how you would implement/refactor this" — Aider returns an actual concrete diff as its opinion.

Tool: Warp — Oz CLI (oz)

Warp is an agentic development environment with built-in AI agents. Its headless command-line interface is the Oz CLI (oz), made for running agents from scripts, CI, and remote machines.

• Headless / non-interactive: oz agent run --prompt "PROMPT".
• Output format: --output-format text or --output-format json for machine-readable results.
• Remote execution: oz agent run-cloud --prompt "PROMPT" runs the agent on a standardized remote machine instead of locally.
• Auth: interactive Warp login, or WARP_API_KEY="wk-..." in the environment for headless/CI use.
• Note: the binary is oz, not warp. If command -v oz fails (older Warp, or Oz CLI not installed), skip Warp rather than guessing flags.

Good for: a second opinion from Warp's agent, especially when the user already lives in Warp.

Tool: vibe-tools / cursor-tools (vibe-tools)

vibe-tools (formerly cursor-tools) is purpose-built to let an agent ask other providers — it's almost tailor-made for second opinions.

• Ask any provider: vibe-tools ask "PROMPT" --provider openai --model <m> (providers include openai, anthropic, gemini, perplexity, xai, …).
• Repo-aware (whole-codebase context): vibe-tools repo "PROMPT" — sends repo context (commonly via Gemini's large context window) so the opinion is grounded in real code. Great for "review my architecture" questions.
• Web research: vibe-tools web "PROMPT" for an internet-grounded answer.
• Plan: vibe-tools plan "PROMPT" to get an implementation plan from another model.
• Auth: keys for whichever providers you target (OPENAI_API_KEY, GEMINI_API_KEY, PERPLEXITY_API_KEY, XAI_API_KEY, …), configured via its .vibe-tools.env / cursor-tools.env.
• Install: npm install -g vibe-tools then vibe-tools install to set up keys.

Good for: one wrapper that fans out to several providers, and for repo-grounded second opinions without manually pasting code.

---

Other fallbacks

• llm (Simon Willison's CLI): llm -m <model> "PROMPT" — supports many providers via plugins. Handy generic second-opinion source.
• ollama: ollama run <model> "PROMPT" — a local model second opinion, no API key/network needed (quality depends on the local model).
• Raw API via curl: if a vendor CLI is missing but its key is present, call the OpenAI-compatible endpoint directly.

Synthesis checklist

After collecting responses:

• Note each tool + model and its core take.
• Separate agreement (strong signal) from disagreement (investigate).
• Compare against your own analysis — independence is the whole value.
• Give a clear recommendation + confidence, and flag unverifiable claims.