Ever wished you could get a second AI opinion on your implementation plans before writing code? PlanCollab makes this possible by orchestrating collaborative planning sessions between Claude Code 🐶 and Codex 🐱.

🎯 What is PlanCollab?

PlanCollab is an agent skill that enables adversarial collaboration between two different AI model families. One agent creates an implementation plan, the other reviews it, and they iterate automatically until reaching consensus - or escalate disagreements to you for final decision.

Why Two AIs Are Better Than One

A single AI can have blind spots - it won't challenge its own decisions. By bringing in a second AI with a different model architecture, you get:

• Alternative approaches that weren't initially considered
• Missing steps or incorrect dependency ordering caught early
• Risk assessment from a fresh perspective
• Test coverage gaps identified before coding

The greater the difference between model families (Claude vs GPT), the more valuable the review becomes.

🚀 Quick Start

Prerequisites

• claude CLI (Claude Code)
• codex CLI (for cross-agent communication)

Basic Usage

# Start a collaborative planning session
/plancollab implement user authentication module

# List all sessions
/plancollab list

# Check current status
/plancollab status

# Resume an interrupted session
/plancollab resume

# Delete sessions
/plancollab delete

Auto-Review Mode

When you generate a complex implementation plan in conversation, PlanCollab can automatically ask:

"I just generated an implementation plan. Would you like the other agent to review it?"

Choose "Yes, always" to enable auto-review for all future plans.

🔄 How It Works

User provides task
    ↓
Baseline check (first-time project scan, reused later)
    ↓
┌─ 🐶 Creates plan ──────────────────────────────┐
│    ↓                                            │
│ 🐱 Reviews (automatic)                          │
│    ↓                                            │
│ Agreed sections locked, disputed sections continue │
│    ↓                                            │
│ Communication sends only disputed sections      │
│    ↓                                            │
│ Next round focuses on disagreements ────────────┘
    ↓
Result: Consensus reached / Conflicts escalated to user

Key Design Principles

Projection Communication: Each round sends a "projection" to the other agent - agreed sections become one-liners, only disputed sections are sent in full. As consensus grows, communication shrinks, preventing context overflow.

Consensus Tracking: After each review, a consensus file records which sections are agreed and which are still disputed. This drives the projection and conflict resolution.

Discussion Log: Tracks what was discussed each round, what was resolved, and what remains. The reviewer uses this to avoid re-raising already-addressed issues.

⚡ Conflict Resolution

If consensus isn't reached after 3 rounds (default), PlanCollab:

1. Extracts specific disagreement points
2. Shows both positions in a structured table
3. Lists reasoning from both agents
4. References source files for verification

Example conflict summary:

🐶 ⚡ 🐱 3 rounds without full consensus. Your decision needed.

1. Token Storage Method

|        | 🐶 Claude              | 🐱 Codex                          |
|--------|------------------------|
| Position | httpOnly cookie       | localStorage                       |
| Concession | Round 2 added SameSite | Round 3 acknowledged security |

🐶 Reasoning:
1. XSS cannot read cookies, natural protection
2. Combined with SameSite=Strict prevents CSRF
3. Server-controlled expiry, reliable forced logout

🐱 Reasoning:
1. Simpler implementation, no backend coordination needed
2. Cross-domain scenarios have SameSite restrictions
3. Short expiry + refresh token makes risk manageable

You can then:

• Decide each point - Make a call on each disagreement
• Continue discussion - Let them negotiate more rounds
• Accept current version - Use the latest plan as-is

🔧 Bidirectional Support

PlanCollab works from both Claude Code and Codex:

The skill auto-detects the environment via $CLAUDECODE variable. Roles can be swapped anytime by saying "swap roles" or "let the other agent plan".

📊 Review Criteria

Plans are evaluated on 6 dimensions:

1. Completeness - Covers all aspects of the task
2. Correctness - Technically sound for this codebase
3. Feasibility - Each step is implementable as described
4. Step ordering - Correct dependency order
5. Risk coverage - Edge cases addressed
6. Testing - Adequate verification strategy

Verdict: APPROVED (no critical/major issues) or NEEDS_REVISION (any critical/major issue).

📁 File Structure

Each collaboration creates a session directory with complete history:

.plancollab/
├── config.json                    # User preferences (auto_review)
├── baseline.md                    # Project architecture baseline
├── 2026-04-25-lru-cache/          # A collaboration session
│   ├── state.json                 # State (rounds, consensus, timestamps)
│   ├── plan.md                    # Final approved plan
│   ├── plans/
│   │   ├── round-1-cc.md          # 🐶 Claude round 1 plan
│   │   └── round-2-cc.md          # 🐶 Claude round 2 plan (revised)
│   └── reviews/
│       ├── round-1-cx.md          # 🐱 Codex round 1 review
│       ├── round-1-consensus-cx.md # Consensus: agreed/disputed
│       └── round-2-cx.md
└── 2026-04-25-auth/               # Another session
    └── ...

File naming: -cc = Claude created, -cx = Codex created.

🎨 Identity System

Clear visual markers throughout:

• 🐶 = Claude (always)
• 🐱 = Codex (always)

Session output examples:

🐶 🐱 PlanCollab Started
Task:     Implement user authentication module
Planner:  🐶 Claude
Reviewer: 🐱 Codex
Rounds:   max 3

🐶 🐱 PlanCollab Ended
Result:  ✅ approved
Rounds:  2/3
Final:   .plancollab/2026-04-25-auth/plan.md

📦 Installation

Using npx skills (Recommended)

npx skills add conanttu/skills/plancollab -g -y

Manual Installation

# Clone the skills repository
git clone https://github.com/conanttu/skills.git
cd skills

# Symlink to Claude Code
ln -s $(pwd)/plancollab ~/.claude/skills/plancollab

# Also symlink to Codex for bidirectional support
ln -s $(pwd)/plancollab ~/.agents/skills/plancollab

Prerequisites: Both codex CLI and claude CLI must be installed and in PATH.

🆚 vs Traditional Code Review

🌟 Use Cases

Perfect for:

• Complex features with multiple implementation approaches
• Architectural decisions that need validation
• Refactoring plans that affect many files
• Security-sensitive implementations
• Performance-critical code paths

Not ideal for:

• Simple bug fixes
• Single-file changes
• Well-established patterns in your codebase

💡 Tips for Best Results

1. Be specific in your task description - The clearer the task, the better the plan
2. Keep baseline updated - Rescan after major architectural changes
3. Review conflict summaries carefully - Both agents often have valid points
4. Use auto-review for non-trivial plans - Catches issues early
5. Archive approved plans - They serve as implementation documentation

📚 Learn More

• GitHub Repository
• Full Documentation
• Chinese Guide

Ready to level up your implementation planning? Try PlanCollab today and experience the power of AI-to-AI collaboration!

🐶 🐱 Happy Collaborating!

What are your thoughts on AI-to-AI collaboration? Have you tried similar approaches? Share your experiences in the comments below!