Ai Pair

AI Pair Collaboration

Coordinate heterogeneous AI teams: one creates, two review from different angles. Uses Claude Code's native Agent Teams capability with Codex and Gemini as reviewers.

Why Multiple AI Reviewers?

Different AI models have fundamentally different review tendencies. They don't just find different bugs — they look at completely different dimensions. Using reviewers from different model families maximizes coverage.

Commands

/ai-pair dev-team [project]       # Start dev team (developer + codex-reviewer + gemini-reviewer)
/ai-pair content-team [topic]     # Start content team (author + codex-reviewer + gemini-reviewer)
/ai-pair team-stop                # Shut down the team, clean up resources

Examples:

/ai-pair dev-team HighlightCut        # Dev team for HighlightCut project
/ai-pair content-team AI-Newsletter   # Content team for writing AI newsletter
/ai-pair team-stop                     # Shut down team

Prerequisites

• Claude Code — Team Lead + agent runtime
• Codex CLI (codex) — for codex-reviewer
• Gemini CLI (gemini) — for gemini-reviewer
• Both external CLIs must have authentication configured

Team Architecture

Dev Team (/ai-pair dev-team [project])

User (Commander)
  |
Team Lead (current Claude session)
  |-- developer (Claude Code agent) — writes code, implements features
  |-- codex-reviewer (Claude Code agent) — via codex CLI
  |   Focus: bugs, security, concurrency, performance, edge cases
  |-- gemini-reviewer (Claude Code agent) — via gemini CLI
      Focus: architecture, design patterns, maintainability, alternatives

Content Team (/ai-pair content-team [topic])

User (Commander)
  |
Team Lead (current Claude session)
  |-- author (Claude Code agent) — writes articles, scripts, newsletters
  |-- codex-reviewer (Claude Code agent) — via codex CLI
  |   Focus: logic, accuracy, structure, fact-checking
  |-- gemini-reviewer (Claude Code agent) — via gemini CLI
      Focus: readability, engagement, style consistency, audience fit

Workflow (Semi-Automatic)

Team Lead coordinates the following loop:

1. User assigns task → Team Lead sends to developer/author 2. Developer/author completes → Team Lead shows result to user 3. User approves for review → Team Lead sends to both reviewers in parallel 4. Reviewers report back → Team Lead consolidates and presents:

   ## Codex Review
   {codex-reviewer feedback summary}

   ## Gemini Review
   {gemini-reviewer feedback summary}

5. User decides → "Revise" (loop back to step 1) or "Pass" (next task or end)

The user stays in control at every step. No autonomous loops.

Project Detection

The project/topic is determined by:

1. Explicitly specified → use as-is 2. Current directory is inside a project → extract project name from path 3. Ambiguous → ask user to choose

Team Lead Execution Steps

Step 1: Create Team

TeamCreate: team_name = "{project}-dev" or "{topic}-content"

Step 2: Create Tasks

Use TaskCreate to set up initial task structure: 1. "Awaiting task assignment" — for developer/author, status: pending 2. "Awaiting review" — for codex-reviewer, status: pending, blockedBy task 1 3. "Awaiting review" — for gemini-reviewer, status: pending, blockedBy task 1

Step 3: Pre-flight CLI Check

Before launching agents, verify external CLIs are available:

command -v codex && codex --version || echo "CODEX_MISSING"
command -v gemini && gemini --version || echo "GEMINI_MISSING"

If either CLI is missing, warn the user immediately and ask whether to proceed with degraded mode (Claude-only review, clearly labeled) or abort.

Step 4: Launch Agents

Launch 3 agents using the Agent tool with subagent_type: "general-purpose" and mode: "bypassPermissions" (required because reviewers need to execute external CLI commands and read project files).

See Agent Prompt Templates below for each agent's startup prompt.

Step 5: Confirm to User

Team ready.

Team: {team_name}
Type: {Dev Team / Content Team}
Members:
  - developer/author: ready
  - codex-reviewer: ready
  - gemini-reviewer: ready

Awaiting your first task.

CLI Invocation Protocol (Shared)

All reviewer agents follow this protocol. Team Lead includes it in each reviewer's prompt.

CLI Invocation Protocol:

[Timeout]
- All Bash tool calls to external CLIs MUST set timeout: 600000 (10 minutes).
- External CLIs (codex/gemini) need 10-15 seconds to load skills,
  plus model reasoning time. The default 2-minute timeout is far too short.

[Reasoning Level Degradation Retry]
- Codex CLI defaults to xhigh reasoning level.
- If the CLI call times out or fails, retry with degraded reasoning in this order:
  1. First failure → degrade to high: append "Use reasoning effort: high" to prompt
  2. Second failure → degrade to medium: append "Use reasoning effort: medium"
  3. Third failure → degrade to low: append "Use reasoning effort: low"
  4. Fourth failure → Claude fallback analysis (last resort)
- For Gemini CLI: if timeout, append simplified instructions / reduce analysis dimensions.
- Report the current degradation level to team-lead on each retry.

[File-based Content Passing (no pipes)]
- Before calling the CLI, create a unique temp file: REVIEW_FILE=$(mktemp /tmp/review-XXXXXX.txt)
  Write content to $REVIEW_FILE. This prevents concurrent tasks from overwriting each other.
- Do NOT pipe long content via stdin (cat $FILE | cli ...) — pipes can truncate, mis-encode, or overflow buffers.
- Instead, reference the file path in the prompt and let the CLI read it:
  codex exec "Review the code in $REVIEW_FILE. Focus on ..."
  gemini -p "Review the content in $REVIEW_FILE. Focus on ..."

[Error Handling]
- If the CLI command is not found → report "[CLI_NAME] CLI not installed" to team-lead immediately. Do NOT substitute your own review.
- If the CLI returns an error (auth, rate-limit, empty output, non-zero exit code) → report the exact error message and exit code, then follow the degradation retry flow.
- If the CLI output contains ANSI escape codes or garbled characters → set `NO_COLOR=1` before the CLI call or pipe through `cat -v`.
- NEVER silently skip the CLI call.
- Only use Claude fallback after ALL FOUR degradation retries have failed, clearly labeled "[Claude Fallback — [CLI_NAME] four retries all failed]".

[Cleanup]
- Clean up: rm -f $REVIEW_FILE after capturing output.

Agent Prompt Templates

Developer Agent (Dev Team)

You are the developer in {project}-dev team. You write code.

Project path: {project_path}
Project info: {CLAUDE.md summary if available}

Workflow:
1. Read relevant files to understand context
2. Implement the feature / fix the bug / refactor
3. Report back via SendMessage to team-lead:
   - Which files changed
   - What you did
   - What to watch out for
4. When receiving reviewer feedback, address items and report again
5. Stay active for next task

Rules:
- Understand existing code before changing it
- Keep style consistent
- Don't over-engineer
- Ask team-lead via SendMessage if unsure

Author Agent (Content Team)

You are the author in {topic}-content team. You write content.

Working directory: {working_directory}
Topic: {topic}

Workflow:
1. Understand the writing task and reference materials
2. If style-memory.md exists, read and follow it
3. Write content following the appropriate format
4. Report back via SendMessage to team-lead with full content or summary
5. When receiving reviewer feedback, revise and report again
6. Stay active for next task

Writing principles:
- Concise and direct
- Clear logic and structure
- Use technical terms appropriately
- Follow style preferences from style-memory.md if available
- Ask team-lead via SendMessage if unsure

Codex Reviewer Agent (Dev Team)

You are codex-reviewer in {project}-dev team. Your job is to get CODE REVIEW from the real Codex CLI.

CRITICAL RULE: You MUST use the Bash tool to invoke the `codex` command. You are a dispatcher, NOT a reviewer.
DO NOT review the code yourself. DO NOT role-play as Codex. Your value is that you bring a DIFFERENT model's perspective.
If you skip the CLI call, the entire point of this multi-model team is defeated.

Project path: {project_path}

Review process:
1. Read relevant code changes using Read/Glob/Grep
2. Choose review method (by priority):
   a. If given a specific commit SHA → use `codex review --commit <SHA>`
   b. If reviewing changes against a base branch → use `codex review --base <branch>`
   c. If reviewing uncommitted changes → use `codex review --uncommitted`
   d. If none of the above apply (e.g. reviewing arbitrary code snippets) → use file passing:
      Create temp file: REVIEW_FILE=$(mktemp /tmp/codex-review-XXXXXX.txt)
      Write code/diff to $REVIEW_FILE
      codex exec "Review the code in $REVIEW_FILE for bugs, security issues, concurrency problems, performance, and edge cases. Be specific about file paths and line numbers." 2>&1
3. MANDATORY — Use Bash tool to call Codex CLI:
   ⚠️ Bash tool MUST set timeout: 600000 (10 minutes)

   Prefer `codex review` (dedicated code review command):
   codex review --commit {SHA} 2>&1
   or codex review --base {branch} 2>&1
   or codex review --uncommitted 2>&1

   Note: `codex review --base` cannot be combined with a PROMPT argument.

4. If timeout, follow degradation retry flow (see CLI Invocation Protocol: xhigh → high → medium → low → Claude fallback)
5. Capture the FULL CLI output. Do not summarize or rewrite it.
6. If temp file was used: rm -f $REVIEW_FILE
7. Report to team-lead via SendMessage:

   ## Codex Code Review

   **Source: Codex CLI [reasoning level]** (or "Source: Claude Fallback — four retries all failed" if all failed)
   **Review command**: {actual codex command used}

   ### CLI Raw Output
   {paste the actual codex CLI output here}

   ### Consolidated Assessment

   #### CRITICAL (blocking issues)
   - {description + file:line + suggested fix}

   #### WARNING (important issues)
   - {description + suggestion}

   #### SUGGESTION (improvements)
   - {suggestion}

   ### Summary
   {one-line quality assessment}

Focus: bugs, security vulnerabilities, concurrency/race conditions, performance, edge cases.

Follow the shared CLI Invocation Protocol (timeout + degradation retry). Stay active for next review task.

Codex Reviewer Agent (Content Team)

You are codex-reviewer in {topic}-content team. Your job is to get CONTENT REVIEW from the real Codex CLI.

CRITICAL RULE: You MUST use the Bash tool to invoke the `codex` command. You are a dispatcher, NOT a reviewer.
DO NOT review the content yourself. DO NOT role-play as Codex. Your value is that you bring a DIFFERENT model's perspective.
If you skip the CLI call, the entire point of this multi-model team is defeated.

Review process:
1. Understand the content and context
2. Create a unique temp file and write the content to it:
   REVIEW_FILE=$(mktemp /tmp/codex-review-XXXXXX.txt)
3. MANDATORY — Use Bash tool to call Codex CLI (file passing, no pipes):
   ⚠️ Bash tool MUST set timeout: 600000 (10 minutes)
   codex exec "Review the content in $REVIEW_FILE for logic, accuracy, structure, and fact-checking. Be specific." 2>&1
4. If timeout, follow degradation retry flow (see CLI Invocation Protocol: xhigh → high → medium → low → Claude fallback)
5. Capture the FULL CLI output.
6. Clean up: rm -f $REVIEW_FILE
7. Report to team-lead via SendMessage:

   ## Codex Content Review

   **Source: Codex CLI [reasoning level]** (or "Source: Claude Fallback — four retries all failed" if all failed)

   ### CLI Raw Output
   {paste the actual codex CLI output here}

   ### Consolidated Assessment

   #### Logic & Accuracy
   - {issues or confirmations}

   #### Structure & Organization
   - {issues or confirmations}

   #### Fact-Checking
   - {items needing verification}

   ### Summary
   {one-line assessment}

Focus: logical coherence, factual accuracy, information architecture, technical terminology.

Follow the shared CLI Invocation Protocol (timeout + degradation retry). Stay active for next review task.

Gemini Reviewer Agent (Dev Team)

You are gemini-reviewer in {project}-dev team. Your job is to get CODE REVIEW from the real Gemini CLI.

CRITICAL RULE: You MUST use the Bash tool to invoke the `gemini` command. You are a dispatcher, NOT a reviewer.
DO NOT review the code yourself. DO NOT role-play as Gemini. Your value is that you bring a DIFFERENT model's perspective.
If you skip the CLI call, the entire point of this multi-model team is defeated.

Project path: {project_path}

Review process:
1. Read relevant code changes using Read/Glob/Grep
2. Create a unique temp file and write the code/diff to it:
   REVIEW_FILE=$(mktemp /tmp/gemini-review-XXXXXX.txt)
3. MANDATORY — Use Bash tool to call Gemini CLI (file passing, no pipes):
   ⚠️ Bash tool MUST set timeout: 600000 (10 minutes)
   gemini -p "Review the code in $REVIEW_FILE focusing on architecture, design patterns, maintainability, and alternative approaches. Be specific about file paths and line numbers." 2>&1
4. If timeout, follow degradation retry flow (see CLI Invocation Protocol: simplify prompt → reduce analysis dimensions → Claude fallback)
5. Capture the FULL CLI output. Do not summarize or rewrite it.
6. Clean up: rm -f $REVIEW_FILE
7. Report to team-lead via SendMessage:

   ## Gemini Code Review

   **Source: Gemini CLI** (or "Source: Claude Fallback — four retries all failed" if all failed)

   ### CLI Raw Output
   {paste the actual gemini CLI output here}

   ### Consolidated Assessment

   #### Architecture Issues
   - {description + suggestion}

   #### Design Patterns
   - {appropriate? + alternatives}

   #### Maintainability
   - {issues or confirmations}

   #### Alternative Approaches
   - {better implementations if any}

   ### Summary
   {one-line assessment}

Focus: architecture, design patterns, maintainability, alternative implementations.

Follow the shared CLI Invocation Protocol (timeout + degradation retry). Stay active for next review task.

Gemini Reviewer Agent (Content Team)

You are gemini-reviewer in {topic}-content team. Your job is to get CONTENT REVIEW from the real Gemini CLI.

CRITICAL RULE: You MUST use the Bash tool to invoke the `gemini` command. You are a dispatcher, NOT a reviewer.
DO NOT review the content yourself. DO NOT role-play as Gemini. Your value is that you bring a DIFFERENT model's perspective.
If you skip the CLI call, the entire point of this multi-model team is defeated.

Review process:
1. Understand the content and context
2. Create a unique temp file and write the content to it:
   REVIEW_FILE=$(mktemp /tmp/gemini-review-XXXXXX.txt)
3. MANDATORY — Use Bash tool to call Gemini CLI (file passing, no pipes):
   ⚠️ Bash tool MUST set timeout: 600000 (10 minutes)
   gemini -p "Review the content in $REVIEW_FILE for readability, engagement, style consistency, and audience fit. Be specific." 2>&1
4. If timeout, follow degradation retry flow (see CLI Invocation Protocol: simplify prompt → reduce analysis dimensions → Claude fallback)
5. Capture the FULL CLI output.
6. Clean up: rm -f $REVIEW_FILE
7. Report to team-lead via SendMessage:

   ## Gemini Content Review

   **Source: Gemini CLI** (or "Source: Claude Fallback — four retries all failed" if all failed)

   ### CLI Raw Output
   {paste the actual gemini CLI output here}

   ### Consolidated Assessment

   #### Readability & Flow
   - {issues or confirmations}

   #### Engagement & Hook
   - {issues or suggestions}

   #### Style Consistency
   - {consistent? + specific deviations}

   #### Audience Fit
   - {appropriate? + adjustment suggestions}

   ### Summary
   {one-line assessment}

Focus: readability, content appeal, style consistency, target audience fit.

Follow the shared CLI Invocation Protocol (timeout + degradation retry). Stay active for next review task.

team-stop Flow

When user calls /ai-pair team-stop or chooses "end" in the workflow:

1. Send shutdown_request to all agents 2. Wait for all agents to confirm shutdown 3. Call TeamDelete to clean up team resources 4. Output:

   Team shut down.
   Closed members: developer/author, codex-reviewer, gemini-reviewer
   Resources cleaned up.

Content Team Example

Scenario: Review a Newsletter Article

You've drafted a newsletter about AI memory systems and want multi-perspective feedback before publishing.

Start the team

/ai-pair content-team AI-Newsletter

Output:

Team ready.

Team: AI-Newsletter-content
Type: Content Team
Members:
  - author: ready
  - codex-reviewer: ready
  - gemini-reviewer: ready

Awaiting your first task.

Assign a task

Review this draft newsletter article about why AI memory
(like MEMORY.md in Claude Code) isn't actually "memory" in the
way most people think. The article argues that it's closer to
a post-it note than a brain.

[paste your draft or provide file path]

The author agent reads the draft and prepares it for review. You approve sending to reviewers.

Review results

## Codex Review

### Logic & Accuracy
- The claim "LLMs have no persistent state between sessions" is technically
  correct but oversimplified. Some systems do maintain vector stores that
  persist. Consider qualifying with "by default" or "natively".
- The analogy to post-it notes breaks down: post-it notes don't have
  retrieval logic. MEMORY.md is more like a briefing document.

### Fact-Checking
- The reference to "context window limits of 200K tokens" should specify
  this is Claude's limit. GPT-4 Turbo is 128K.

### Summary
Solid argument, but two factual claims need tightening.

## Gemini Review

### Readability & Flow
- The opening paragraph uses three technical terms before the reader
  gets the hook. Consider leading with the relatable scenario first.

### Engagement & Hook
- The "post-it note" metaphor is strong but introduced too late (paragraph 4).
  Move it to the opening for immediate impact.

### Audience Fit
- Tone shifts between casual (paragraphs 1-3) and academic (paragraphs 4-6).
  The casual tone matches the target audience better — maintain it throughout.

### Summary
Good content, needs structural reorganization for maximum impact.

Codex caught factual precision issues. Gemini caught readability and structure issues. Zero overlap.

Iterate

You tell Team Lead:

Fix the factual claims Codex flagged.
Move the post-it metaphor to the opening as Gemini suggested.
Keep the casual tone throughout.
Don't change the core argument.

The author revises. You can send for another round of review or pass.

End the session

/ai-pair team-stop

Tips for Content Team

1. Provide context about your audience — reviewers give better feedback when they know who's reading 2. Don't fix everything — you decide which feedback matters. Codex tends to over-index on precision; Gemini tends to over-index on accessibility 3. Use iteratively — first round for big issues, second round for polish 4. Style memory — if you have a style-memory.md file, the author agent will automatically follow your style preferences

Dev Team Example

Scenario: Review a Pull Request

You're working on a project and want multiple AI perspectives on your code changes.

Start the team

/ai-pair dev-team my-web-app

Output:

Team ready.

Team: my-web-app-dev
Type: Dev Team
Members:
  - developer: ready
  - codex-reviewer: ready
  - gemini-reviewer: ready

Awaiting your first task.

Assign a task

Implement rate limiting for the /api/login endpoint.
Max 5 attempts per IP per 15 minutes.

The developer agent reads the codebase, implements the feature, and reports back.

Review results

After you approve sending for review, both reviewers analyze in parallel:

## Codex Review

### WARNING
- Rate limit key uses only IP address. Behind a proxy, all users share one IP.
  Consider combining IP + user-agent or using X-Forwarded-For.
- No cleanup mechanism for expired entries in the rate limit store.

### SUGGESTION
- Add a header (X-RateLimit-Remaining) so clients know their status.

### Summary
Functional implementation, but proxy scenario needs attention.

## Gemini Review

### Architecture Issues
- In-memory store won't work with multiple server instances.
  Consider Redis or a shared store.

### Design Patterns
- Rate limiter is tightly coupled to the route handler.
  Extract as middleware for reuse on other endpoints.

### Summary
Works for single-instance deployment. Needs abstraction for production scale.

Notice how Codex found a security edge case (proxy IP sharing) while Gemini found an architecture limitation (single-instance only). Different dimensions, both valuable.

Decide

You can say:

• "Revise" — feedback gets sent to developer, loop continues
• "Pass" — move to next task or end team
• "Revise, but only fix the proxy issue and Redis. Skip the middleware refactor for now." — you control the scope

End the session

/ai-pair team-stop

AI-Pair: Heterogeneous AI Team Collaboration

AI-Pair：异构 AI 团队协作

  

Coordinate multiple AI models to work together as a team. One creates, two review — not for redundancy, but because different models naturally focus on different dimensions.

让不同 AI 模型组成团队协作。一个创作，两个审查 — 不是为了冗余，而是因为不同模型天然关注不同维度。

Next Step: Want to turn Skills from demo to asset? Check out Agent Skills Resource Library (includes slides, PDF, diagnostics)

Status

Status: Experimental | 状态：实验性

>

- This is a public prototype that works for real workflows, but does not yet cover all edge cases. | 公开原型，可用于实际工作流，但未覆盖所有边界情况。

- Requires Claude Code + Codex CLI + Gemini CLI

- My primary focus is demonstrating how tools and systems work together, not maintaining this codebase. | 重点是展示工具和系统如何协作，而非维护这个代码库。

- If you encounter issues, please submit a reproducible case (input + output + steps to reproduce). | 如遇问题，请提交可复现的案例。

Why This Exists | 为什么做这个

Most people use multiple AI subscriptions by asking the same question to each and comparing answers. That's useful sometimes, but it only uses one dimension of what different models can do — you get multiple answers to the same question, instead of multiple perspectives on the same work.

大部分人用多个 AI 的方式是：同一个问题分别问一遍，然后对比答案。这有时候有用，但只用到了不同模型能力的一个维度 — 你得到的是同一个问题的多个回答，而不是同一份工作的多个视角。

AI-Pair turns model differences into a structured workflow: assign each model a role that matches its strength, and let them review the same work from different angles. It's a Claude Code Skill — a reusable instruction set that extends Claude Code's capabilities.

AI-Pair 把模型差异变成结构化的工作流：给每个模型分配匹配其特长的角色，让它们从不同角度审查同一份工作。它是一个 Claude Code Skill — 一组可复用的指令，扩展 Claude Code 的能力。

How It Works | 工作原理

User (you) | 用户（你）
  |
Team Lead (Claude Code session) | 团队领导（Claude Code 会话）
  |-- creator (Claude Code agent) — writes code or content | 创作者 — 写代码或内容
  |-- codex-reviewer (agent → Codex CLI) — analytical review | 分析型审查
  |-- gemini-reviewer (agent → Gemini CLI) — editorial review | 编辑型审查

The workflow is semi-automatic — you stay in control at every step:

工作流是半自动的 — 每一步你都保持控制权：

1. You assign a task → creator executes | 你下达任务 → 创作者执行 2. Creator reports back → you decide whether to send for review | 创作者回报 → 你决定是否送审 3. Both reviewers analyze in parallel → consolidated report | 两个审查者并行分析 → 汇总报告 4. You decide: revise or pass → loop or next task | 你决定：修改还是通过 → 循环或下一个任务

Prerequisites | 前置条件

All three are command-line tools that run in your terminal (Terminal, iTerm2, etc.), not desktop apps.

三个都是命令行工具，在终端中运行（Terminal、iTerm2 等），不是桌面应用。

All three CLIs must have authentication configured before use.

三个 CLI 使用前都需要配置好认证。

Quick check | 快速检查: Run claude --version, codex --version, and gemini --version to verify all three are installed.

Installation | 安装

Option A: Direct Install (Recommended) | 直接安装（推荐）

# Clone to your global Claude Code skills directory
# 克隆到 Claude Code 全局 skills 目录
git clone https://github.com/axtonliu/ai-pair.git ~/.claude/skills/ai-pair

For project-level installation, clone into .claude/skills/ai-pair within your project directory instead.

如需项目级安装，克隆到项目目录下的 .claude/skills/ai-pair。

Option B: Manual | 手动安装

1. Download SKILL.md from this repo | 下载本仓库的 SKILL.md 2. Place it in ~/.claude/skills/ai-pair/SKILL.md | 放到 ~/.claude/skills/ai-pair/SKILL.md 3. Restart Claude Code | 重启 Claude Code

Usage | 使用

Dev Team — for code, bugs, refactoring | 开发团队 — 写代码、修 bug、重构

/ai-pair dev-team MyProject

Team Lead creates | 团队领导创建:

• developer — writes code | 写代码
• codex-reviewer — checks bugs, security, performance, edge cases | 审查 bug、安全、性能、边界条件
• gemini-reviewer — checks architecture, design patterns, maintainability | 审查架构、设计模式、可维护性

Content Team — for articles, scripts, newsletters | 内容团队 — 写文章、脚本、Newsletter

/ai-pair content-team AI-Newsletter

Team Lead creates | 团队领导创建:

• author — writes content | 写内容
• codex-reviewer — checks logic, accuracy, structure, fact-checking | 审查逻辑、准确性、结构、事实核查
• gemini-reviewer — checks readability, engagement, style, audience fit | 审查可读性、吸引力、风格、受众适配

Stop Team | 关闭团队

/ai-pair team-stop

Real-World Example | 真实案例

We used content-team to review a newsletter article. The three AIs found completely different issues:

我们用 content-team 审查了一篇 Newsletter 文章。三个 AI 发现的问题完全不同：

• Claude (Team Lead): spotted an overreach in interpreting a cited source | 发现对引用来源的过度解读
• GPT (Codex): dissected the argument chain and challenged a logical leap | 拆解论证链，质疑逻辑跳跃
• Gemini: suggested the opening was too academic for the target audience | 建议开头对目标读者来说太学术化

None of these overlapped. That's the point. See `examples/` for step-by-step walkthrough scenarios.

三者零重叠。这就是意义所在。查看 `examples/` 获取分步演示场景。

File Structure | 文件结构

ai-pair/
├── SKILL.md       # Claude Code skill definition | Skill 定义文件
├── README.md      # This file | 本文件
├── LICENSE         # MIT
└── examples/      # Usage examples | 使用示例
    ├── dev-team.md
    └── content-team.md

Troubleshooting | 常见问题

Reviewers not actually calling Codex/Gemini CLI | 审查者没有真正调用 Codex/Gemini CLI

Symptom: Reviews complete but only Claude Code's usage decreases; Codex/Gemini CLI usage stays flat. The sub-agents are role-playing as Codex/Gemini instead of actually invoking them.

症状： 审查完成但只有 Claude Code 的用量在下降；Codex/Gemini CLI 用量没有任何变化。Sub-agent 在角色扮演而非真正调用外部 CLI。

How to verify | 如何验证: Check the review output for the **Source: Codex CLI** / **Source: Gemini CLI** label and the ### CLI Raw Output section. If these are missing, the CLI was not called.

如何验证： 检查审查输出中是否有 **Source: Codex CLI** / **Source: Gemini CLI** 标签和 ### CLI Raw Output 部分。如果缺失，说明 CLI 没有被调用。

Fix | 解决方案: This was addressed in v1.1.0 with mandatory CLI invocation rules. If you're on an older version, update your SKILL.md. If the issue persists, ensure both CLIs are installed and authenticated (codex --version, gemini --version).

解决方案： 此问题已在 v1.1.0 中通过强制 CLI 调用规则修复。如果你使用旧版本，请更新 SKILL.md。如果问题仍然存在，确认两个 CLI 都已安装并完成认证（codex --version、gemini --version）。

What's Not Included | 未包含的功能

This open-source version includes the Agent Teams mode only. The full private version also has:

开源版仅包含 Agent Teams 模式。完整私有版还包括：

• Manual mode — two CLI instances communicating via shared file | 手动模式 — 两个 CLI 通过共享文件通信
• iTerm2 orchestration — automated Author/Reviewer relay with file watchers | iTerm2 编排 — 自动化的创作/审查中继

These require specific local setup and are maintained separately.

这些需要特定的本地配置，单独维护。

Evolution | 演变

AI-Pair evolved from AI Roundtable, a Chrome extension that lets multiple AI web interfaces discuss and cross-review in the same panel. AI-Pair moves this concept to the command line with structured role assignments, making it more practical for daily workflows.

AI-Pair 从 AI Roundtable 演变而来。AI Roundtable 是一个 Chrome 扩展，让多个 AI 的网页版在同一个面板里讨论和互评。AI-Pair 把这个概念搬到了命令行，加入了结构化的角色分工，更适合日常工作流。

Contributing | 贡献

Contributions welcome (low-maintenance project):

欢迎贡献（低维护项目）：

• Reproducible bug reports (input + output + steps + environment) | 可复现的 bug 报告
• Documentation improvements | 文档改进
• Small PRs (fixes/docs) | 小型 PR（修复/文档）

Note: Feature requests may not be acted on due to limited maintenance capacity. | 功能需求可能因维护精力有限而无法响应。

License | 许可证

MIT - Axton Liu

---

Author | 作者

Axton Liu — AI Educator & Creator

• Website: axtonliu.ai
• YouTube: @AxtonLiu
• Twitter/X: @axtonliu

Learn More

• MAPS™ AI Agent Course - Systematic AI agent skills training
• Claude Skills: A Systematic Guide - Complete methodology
• AI Elite Weekly Newsletter - Weekly AI insights
• Free AI Course - Get started with AI

---

© AXTONLIU™ & AI 精英学院™ 版权所有