Team Collaboration - robwhite4/claude-memory GitHub Wiki

Team Collaboration

This guide covers how teams can effectively use Claude Memory for shared AI context and knowledge management.

Overview

Claude Memory can enhance team development by maintaining shared project knowledge, decisions, and patterns. However, it requires coordination to avoid conflicts and maintain useful context.

Team Setup Strategies

Strategy 1: Designated Memory Keeper

Best for: Small teams, clear hierarchy

One team member manages all memory updates:

# Memory Keeper updates after team discussions
cmem decision "Use PostgreSQL" "Team agreed on ACID compliance" "MongoDB"
cmem knowledge add "db_connection" "postgresql://..." --category infrastructure

Pros:

  • No merge conflicts
  • Consistent memory style
  • Clear responsibility

Cons:

  • Single point of failure
  • Keeper must attend all meetings
  • Potential bottleneck

Strategy 2: PR-Based Memory

Best for: Open source projects, distributed teams

Memory updates happen via pull requests:

## PR Description
Implemented user authentication system using JWT tokens.

### Memory Updates
- Decision: JWT over sessions (stateless architecture)
- Pattern: Middleware for auth validation
- Knowledge: Auth endpoints documented

Pros:

  • Memory changes reviewed
  • Clear audit trail
  • No direct conflicts

Cons:

  • Manual process
  • Memory might lag behind code

Strategy 3: Shared Context Files

Best for: Collaborative teams, frequent pairing

All team members update memory:

# .gitignore configuration
.claude/sessions/
.claude/backups/
.claude/memory.json
.claude/config.json
!.claude/context/

Pros:

  • Real-time knowledge sharing
  • Distributed responsibility
  • Rich context

Cons:

  • Merge conflicts possible
  • Requires discipline
  • Can become cluttered

Team Conventions

1. Prefix Patterns

Use prefixes to identify context source:

# Team-wide patterns
cmem pattern add "[TEAM] Code review required" "All PRs need approval"

# Personal patterns
cmem pattern add "[JOHN] Debug with logs" "Add console.logs first"

# Component-specific
cmem pattern add "[AUTH] Token expiry" "Set to 24 hours"

2. Category Standards

Agree on knowledge categories:

# Standard categories
- architecture
- infrastructure  
- security
- performance
- decisions
- conventions

# Usage
cmem knowledge add "api_rate_limit" "100 req/min" --category performance

3. Decision Templates

Standardize decision format:

cmem decision "<WHAT>" "<WHY>" "<ALTERNATIVES>"

# Examples
cmem decision "React over Vue" "Team expertise, ecosystem" "Vue,Angular,Svelte"
cmem decision "Monorepo structure" "Shared code, easier deployment" "Multirepo"

Workflow Examples

Sprint Planning

# Start of sprint
cmem session start "Sprint 23 - User Dashboard"

# Add sprint goals as tasks
cmem task add "Dashboard layout component" --priority high --assignee Sarah
cmem task add "User metrics API" --priority high --assignee John
cmem task add "Dashboard tests" --priority medium --assignee Mike

Code Review

During code reviews, capture patterns:

# Reviewer finds issue
cmem pattern add "[REVIEW] Unhandled promise rejection" \
  "Always use try-catch with async operations" \
  --effectiveness 0.9 \
  --priority high

Architecture Decisions

Document major decisions:

# After architecture meeting
cmem decision "Microservices architecture" \
  "Scale teams independently, service isolation" \
  "Monolith,Modular monolith"

cmem knowledge add "service_boundaries" \
  "Auth, Users, Orders, Payments, Notifications" \
  --category architecture

Knowledge Sharing

Share discoveries and learnings:

# After debugging session
cmem knowledge add "memory_leak_cause" \
  "Event listeners not removed in useEffect cleanup" \
  --category debugging

cmem pattern add "React hook cleanup" \
  "Always return cleanup function from useEffect" \
  --effectiveness 1.0

Conflict Resolution

Merge Conflicts

When conflicts occur in context files:

# Option 1: Meeting to resolve
git status  # See conflicts
# Team discusses conflicting updates
# Manually merge maintaining both insights

# Option 2: Temporal resolution
git checkout --theirs .claude/context/  # Take newer
cmem knowledge add "merge_conflict_note" "Merged from main, see PR #123"

# Option 3: Reset and rebuild
git checkout --ours .claude/context/
cmem export team-backup.json  # Save current state
# Team reviews and re-adds important items

Preventing Conflicts

  1. Pull frequently

    git pull origin main

  2. Small, focused updates

    # Not this
cmem knowledge add "everything" "long multi-topic update..."

# But this
cmem knowledge add "api_auth" "Bearer token in header"
cmem knowledge add "api_base" "https://api.example.com/v2"

  3. Coordinate major updates

    • Announce in team chat before big memory updates
    • Do memory cleanup sessions together

Team Guidelines

Do's

  • ✅ Document decisions promptly
  • ✅ Use clear, descriptive keys
  • ✅ Remove outdated information
  • ✅ Share useful patterns
  • ✅ Keep knowledge factual

Don'ts

  • ❌ Store personal preferences as team patterns
  • ❌ Commit sensitive information
  • ❌ Make breaking changes without discussion
  • ❌ Use memory for task management (use proper tools)
  • ❌ Let memory grow unbounded

Integration with Team Tools

CI/CD Integration

# .github/workflows/memory-check.yml
name: Memory Check
on: [pull_request]

jobs:
  check-memory:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - run: |
          npm install -g claude-memory
          cmem stats
          cmem context --dry-run

Slack/Discord Notifications

# Post daily memory stats
cmem stats | slack-cli post "#dev-team"

# Share new decisions
DECISION=$(cmem decision "..." "..." "...")
echo "New decision: $DECISION" | discord-webhook send

Onboarding New Developers

Create an onboarding checklist:

  1. Read CLAUDE.md for project overview
  2. Review recent decisions 
    cmem decision list --recent 10
  3. Understand current patterns 
    cmem pattern list --priority high
  4. Check active tasks 
    cmem task list
  5. Browse knowledge base 
    cmem knowledge list --category architecture

Best Practices

1. Regular Cleanup

Schedule monthly memory cleanup:

# Review and resolve old patterns
cmem pattern list --age 90d

# Archive completed decisions
cmem decision list --resolved

# Clean up outdated knowledge
cmem knowledge list --category deprecated

2. Memory Reviews

Include in sprint retrospectives:

  • What patterns emerged?
  • What decisions were made?
  • What knowledge was gained?
  • What should be cleaned up?

3. Documentation

Keep team memory guide updated:

  • Agreed categories
  • Naming conventions
  • Update procedures
  • Conflict resolution

Metrics and Monitoring

Track memory health:

# Create team dashboard
cmem stats --json > stats.json

# Monitor growth
cmem export | wc -l  # Track size over time

# Pattern effectiveness
cmem pattern list --sort effectiveness

See also:

⚠️ **GitHub.com Fallback** ⚠️