Conan

Posted on May 26

Introducing PlanCollab: AI-Powered Cross-Agent Code Planning & Review

#ai #claude #codex #collaboration

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:

Extracts specific disagreement points
Shows both positions in a structured table
Lists reasoning from both agents
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:

Environment	Default Role	Calls Other Agent
In Claude Code	🐶 plans, 🐱 reviews	`codex exec`
In Codex	🐱 plans, 🐶 reviews	`claude -p`

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:

Completeness - Covers all aspects of the task
Correctness - Technically sound for this codebase
Feasibility - Each step is implementable as described
Step ordering - Correct dependency order
Risk coverage - Edge cases addressed
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

	Traditional Code Review	PlanCollab
Review Target	Code	Implementation plan (before code)
Reviewer	Human	Another AI Agent
Iteration	Manual back-and-forth	Automatic multi-round discussion
Consensus Management	Mental notes	File-based consensus tracking
Conflict Resolution	Offline communication	Structured display + user arbitration
History	In PR comments	Independent session directory, fully preserved

🌟 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

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

📚 Learn More

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!

DEV Community