Reference for invoking external AI coding CLIs non-interactively (Gemini CLI, OpenAI Codex CLI, Grok CLI, Aider, Warp, vibe-tools/cursor-tools) to gather an independent second opinion, plus install hints and auth requirements. Use when the user wants cross-model review, consensus, an alternative approach, or to "ask another AI".
Reference for invoking external AI coding CLIs non-interactively (Gemini CLI, OpenAI Codex CLI, Grok CLI, Aider, Warp, vibe-tools/cursor-tools) to gather an independent second opinion, plus install hints and auth requirements. Use when the user wants cross-model review, consensus, an alternative approach, or to "ask another AI".
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
Probe before use:command -v <tool>. Only use what's installed.
Verify flags live: flags change between versions — run <tool> --help
before composing the real call. Treat the tables below as the expected form.
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.
Self-contained prompts: external tools don't see this conversation. Put the
question + code/diff + desired output format in the prompt.
Guard the call: wrap with timeout, handle missing API keys gracefully, and
never let one tool's failure abort the others.
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.
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.
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, …).
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.
