collab-session

Collab Session

Async collaborative thinking between multiple human+Claude pairs. Each participant works in their own Claude Code session, saving progress to a shared workspace. No merge conflicts by design — and the journey is preserved, not just the conclusion.

How it works

Two people (each with their own Claude Code session) work on the same topic asynchronously. Every /collab save writes a uniquely-named markdown file — nobody edits anyone else's files. When a colleague runs /collab join, all files are assembled into a narrative handoff brief so they can pick up where you left off.

Simon + Claude                         Dan + Claude
     │                                      │
     ├─ /collab save                        │
     │  → simon_20260314T142001Z.md         │
     │  → git push                          │
     │                                      │
     │                    /collab join ──────┤
     │                    ← git pull         │
     │                    ← handoff brief    │   (resolves [[wikilinks]] inline)
     │                                      │
     │                        /collab save ──┤
     │                        → dan_...Z.md  │
     │                        → git push     │
     │                                      │
     ├─ /collab refresh                     │
     │  ← sees Dan's new block              │
     │                                      │
     ├─ /collab compress                    │   journey-style _summary.md
     │                                      │
     ├─ /collab reflect skill-project       │   cross-session _patterns.md
     │                                      │   (only after 2+ closed sessions)

On launch, a SessionStart hook nudges each participant about active sessions they've touched — no more "which session was I in?" at the start of the day.

Why no vector DB, no RAG

Cross-session recall is done via markdown primitives, not embeddings: [[session-NNN#phase-N]] wikilinks between summaries for graph navigation, /collab reflect to extract patterns from closed sessions into _patterns.md, and tiered retrieval in /collab catchup (compact index → timeline → full block) for bounded token cost. No vector DB, no index to rebuild, no model lock-in. If you'd rather run embeddings yourself, the folder is plain markdown — point any RAG tool at it.

What this is good for

Not just coding. Any topic two or more people want to think through together, asynchronously, with Claude as a partner in each seat.

Research and analysis

• Two researchers reviewing papers on a topic, each with Claude pulling threads
• Market or competitor analysis where each person covers a segment
• Literature review split across a team, assembled into one journey summary

Design and decision-making (pre-code)

• Co-designing an API, schema, or system architecture before anyone writes code
• Writing an RFC or design doc where each reviewer's reasoning is preserved, not just their verdict
• Weighing product direction or pricing options with the trade-offs captured

Coding work where the why matters

• Architecture choices where future teammates need to know what was rejected and why
• Bug investigations where the dead ends are as valuable as the fix
• Refactoring decisions — the discussion that led to the final diff, preserved next to it

What sets it apart for coding: a finished branch tells you what two colleagues agreed on. Collab Session captures why — the decisions, the disagreements, the approaches tried and abandoned. /collab compress writes a journey-style narrative with contributor attribution; /collab reflect surfaces patterns across closed sessions. Six months later, the next person on the codebase can read the lineage, not just the commit.

Install

claude plugin add AI-Collab-Skill/collab-session-skill

Quick start

# 1. Set your identity (once per machine)
/collab whoami simon

# 2. Set up a shared workspace (once per team)
/collab init my-project
# Choose: drive (network/cloud folder) or mini-repo (dedicated git repo)

# 3. Start a session
/collab new my-project api-design
# Answer: goal, prior session?

# 4. Brainstorm with Claude, then save
/collab save
# Secrets in the chat? Wrap them in <private>...</private> — redacted on save.

# 5. Colleague joins from their machine
/collab join my-project api-design
# Gets a narrative handoff brief, picks up where you left off.

# 6. After several saves, compress into a journey summary
/collab compress

# 7. Topic done — freeze the session
/collab close

# 8. After 2+ closed sessions, extract recurring patterns
/collab reflect my-project
# Writes _patterns.md: recurring themes, repeated dead ends, chronic blockers.

Commands