Team Collaboration with CCJK: Shared AI Workflows

When multiple developers use AI assistants, consistency becomes crucial. CCJK provides powerful features for team collaboration, ensuring everyone follows the same patterns and practices.

Setting Up Team Configuration

Project-Level Configuration

Create a shared configuration in your repository:

hljs yaml
# .claude/config.yaml
version: "1.0"
team: "your-team-name"

# Shared model settings
model:
  default: claude-sonnet-4-20250514
  fallback: claude-haiku

# Project context
context:
  description: |
    E-commerce platform built with:
    - Next.js 14 (App Router)
    - TypeScript (strict mode)
    - PostgreSQL + Prisma
    - Redis for caching
    - Tailwind CSS

  conventions:
    - Use functional components with hooks
    - Follow Airbnb style guide
    - Write tests for all business logic
    - Use conventional commits

# Shared ignore patterns
ignore:
  - node_modules/
  - .next/
  - coverage/
  - "*.log"
  - .env*

Team Permissions

Define what team members can do:

hljs yaml
# .claude/permissions.yaml
roles:
  developer:
    read: ["src/**", "tests/**", "docs/**"]
    write: ["src/**", "tests/**"]
    execute: ["npm test", "npm run lint", "npm run build"]

  senior:
    extends: developer
    write: ["src/**", "tests/**", "config/**"]
    execute: ["npm run migrate", "npm run deploy:staging"]

  lead:
    extends: senior
    write: ["**"]
    execute: ["**"]

# Default role for team members
default_role: developer

Shared Skills Library

Creating Team Skills

Build a library of team-specific skills:

hljs yaml
# .claude/skills/team/create-feature.yaml
name: create-feature
description: Create a new feature following team conventions
version: 1.0.0
author: Team Lead

parameters:
  - name: name
    description: Feature name (kebab-case)
    required: true
    pattern: "^[a-z][a-z0-9-]*$"

  - name: type
    description: Feature type
    default: page
    options: [page, component, api, service]

prompt: |
  Create a new {{type}} feature called "{{name}}" following our team conventions:

  Project Structure:
  - Pages go in src/app/
  - Components go in src/components/
  - API routes go in src/app/api/
  - Services go in src/services/

  Requirements:
  - TypeScript with strict types
  - Include unit tests
  - Add Storybook story (for components)
  - Follow existing patterns in the codebase

  Reference similar existing features for consistency.

Skill Categories

Organize skills by purpose:

.claude/skills/
├── team/
│   ├── create-feature.yaml
│   ├── create-api-endpoint.yaml
│   └── create-component.yaml
├── review/
│   ├── code-review.yaml
│   ├── security-review.yaml
│   └── performance-review.yaml
├── docs/
│   ├── api-docs.yaml
│   ├── component-docs.yaml
│   └── readme-update.yaml
└── testing/
    ├── unit-test.yaml
    ├── integration-test.yaml
    └── e2e-test.yaml

Onboarding New Team Members

Automated Setup

Create an onboarding skill:

hljs yaml
# .claude/skills/team/onboard.yaml
name: onboard
description: Set up development environment for new team member

steps:
  - name: "Environment Check"
    prompt: |
      Verify the development environment:
      - Node.js 18+ installed
      - npm or pnpm available
      - Git configured
      - Required VS Code extensions

  - name: "Project Setup"
    commands:
      - "npm install"
      - "cp .env.example .env.local"
      - "npm run db:setup"

  - name: "Codebase Tour"
    prompt: |
      Provide a tour of the codebase:
      - Project structure overview
      - Key directories and their purposes
      - Important configuration files
      - Development workflow

  - name: "First Task"
    prompt: |
      Suggest a good first task for a new team member:
      - Something small and well-defined
      - Touches multiple parts of the codebase
      - Has clear acceptance criteria

Knowledge Base

Create a team knowledge base:

hljs yaml
# .claude/knowledge/architecture.yaml
topic: architecture
content: |
  ## System Architecture

  ### Frontend
  - Next.js 14 with App Router
  - React Server Components for data fetching
  - Client components for interactivity
  - Tailwind CSS for styling

  ### Backend
  - API routes in Next.js
  - Prisma ORM for database access
  - Redis for session and cache
  - Background jobs with BullMQ

  ### Infrastructure
  - Vercel for frontend hosting
  - AWS RDS for PostgreSQL
  - AWS ElastiCache for Redis
  - CloudFlare for CDN

Code Review Workflows

Standardized Reviews

Create consistent review processes:

hljs yaml
# .claude/skills/review/pr-review.yaml
name: pr-review
description: Comprehensive PR review following team standards

checklist:
  code_quality:
    - "Follows TypeScript best practices"
    - "No any types without justification"
    - "Proper error handling"
    - "No console.log statements"

  testing:
    - "Unit tests for new functions"
    - "Integration tests for API changes"
    - "Test coverage maintained or improved"

  security:
    - "No hardcoded secrets"
    - "Input validation present"
    - "SQL injection prevention"
    - "XSS prevention"

  documentation:
    - "JSDoc for public functions"
    - "README updated if needed"
    - "API docs updated for endpoints"

  performance:
    - "No N+1 queries"
    - "Appropriate caching"
    - "Bundle size impact considered"

output_format: |
  ## PR Review: {{pr_title}}

  ### Summary
  {{summary}}

  ### Checklist Results
  {{checklist_results}}

  ### Issues Found
  {{issues}}

  ### Suggestions
  {{suggestions}}

  ### Approval Status
  {{status}}

Review Assignment

hljs yaml
# .claude/workflows/review-assignment.yaml
name: review-assignment
trigger: pr_opened

rules:
  - condition: "files.any(f => f.path.startsWith('src/api/'))"
    reviewers: ["backend-team"]

  - condition: "files.any(f => f.path.startsWith('src/components/'))"
    reviewers: ["frontend-team"]

  - condition: "files.any(f => f.path.includes('security'))"
    reviewers: ["security-team"]
    required: true

Shared Prompts and Templates

Prompt Library

hljs yaml
# .claude/prompts/debugging.yaml
name: debug-production-issue
description: Systematic approach to production debugging

template: |
  A production issue has been reported:

  **Issue**: {{issue_description}}
  **Impact**: {{impact_level}}
  **First Reported**: {{timestamp}}

  Please help debug this issue:

  1. **Gather Information**
     - Check error logs
     - Review recent deployments
     - Identify affected users/requests

  2. **Form Hypotheses**
     - List possible causes
     - Rank by likelihood

  3. **Investigate**
     - For each hypothesis, describe how to verify
     - Suggest diagnostic queries/commands

  4. **Propose Fix**
     - Immediate mitigation
     - Long-term solution
     - Prevention measures

Response Templates

hljs yaml
# .claude/templates/api-response.yaml
success:
  status: 200
  body:
    success: true
    data: "{{data}}"
    meta:
      timestamp: "{{timestamp}}"
      requestId: "{{requestId}}"

error:
  status: "{{statusCode}}"
  body:
    success: false
    error:
      code: "{{errorCode}}"
      message: "{{userMessage}}"
    meta:
      timestamp: "{{timestamp}}"
      requestId: "{{requestId}}"

Metrics and Analytics

Usage Tracking

hljs yaml
# .claude/analytics.yaml
tracking:
  enabled: true
  anonymous: true  # No personal data

metrics:
  - skill_usage        # Which skills are used most
  - task_completion    # Success rate of AI tasks
  - time_saved         # Estimated time savings
  - error_rate         # AI suggestion error rate

reports:
  weekly:
    recipients: ["team-lead@company.com"]
    include: [skill_usage, task_completion]

  monthly:
    recipients: ["engineering@company.com"]
    include: [all]

Team Dashboard

Track team AI usage:

┌─────────────────────────────────────────────────────────┐
│                  CCJK Team Dashboard                     │
├─────────────────────────────────────────────────────────┤
│                                                          │
│  This Week's Stats                                       │
│  ─────────────────                                       │
│  Tasks Completed: 147                                    │
│  Skills Used: 23 unique                                  │
│  Time Saved: ~18 hours                                   │
│  Success Rate: 94%                                       │
│                                                          │
│  Top Skills                                              │
│  ──────────                                              │
│  1. /review      - 45 uses                               │
│  2. /test        - 38 uses                               │
│  3. /commit      - 32 uses                               │
│  4. /docs        - 18 uses                               │
│  5. /refactor    - 14 uses                               │
│                                                          │
│  Team Members                                            │
│  ────────────                                            │
│  Alice: 42 tasks | Bob: 38 tasks | Carol: 35 tasks      │
│                                                          │
└─────────────────────────────────────────────────────────┘

Best Practices

1. Version Control Configuration

hljs bash
# Include in repository
.claude/config.yaml
.claude/skills/**
.claude/prompts/**
.claude/knowledge/**

# Exclude personal settings
.claude/local.yaml  # Add to .gitignore

2. Regular Skill Reviews

Schedule monthly reviews of team skills:

• Are skills still relevant?
• Can any be improved?
• Are there gaps to fill?

3. Documentation

Document your team's AI workflows:

• How to use shared skills
• When to create new skills
• Review and approval process

4. Feedback Loop

Create a channel for AI feedback:

• What's working well?
• What needs improvement?
• New skill requests

Conclusion

Team collaboration with CCJK multiplies the benefits of AI assistance. By sharing configurations, skills, and best practices, you ensure consistency while allowing individual productivity gains.

Start with basic shared configuration, then gradually build your team's skill library based on common needs.

Next: Learn about CI/CD Integration to automate AI-assisted workflows.