Team Presets & Workflows: Standardized Team Configurations

Production Playbook for Team Leads and Engineering Managers

Standardizing Claude Code configurations across engineering teams accelerates onboarding, ensures consistency, and enables collaborative development. This playbook provides team plugin bundles, workflow templates, configuration management strategies, and automation for distributed teams.

Team Configuration Strategy
Plugin Bundles
Workflow Templates
Onboarding Automation
Configuration Management
Collaborative Development
Best Practices
Tools & Resources
Summary

Team Configuration Strategy

Configuration Layers

graph TB
    A[Organization Config] --> B[Team Config]
    B --> C[Project Config]
    C --> D[Individual Config]

    A --> E[Global Plugins]
    B --> F[Team-Specific Plugins]
    C --> G[Project Plugins]
    D --> H[Personal Preferences]

Configuration Precedence:

Organization - Security policies, approved plugins, compliance settings
Team - Team-specific workflows, shared plugins, coding standards
Project - Project dependencies, custom agents, specific tools
Individual - Personal preferences, API keys, editor settings

Team Configuration File

// .claude/team-config.json
{
  "teamId": "engineering-team-backend",
  "organization": "acme-corp",
  "version": "1.0.0",

  "plugins": {
    "required": [
      "code-reviewer@claude-code-plugins-plus",
      "test-automator@claude-code-plugins-plus",
      "security-auditor@claude-code-plugins-plus"
    ],
    "recommended": [
      "performance-engineer@claude-code-plugins-plus",
      "database-optimizer@claude-code-plugins-plus"
    ],
    "forbidden": [
      "untrusted-plugin"  // Security risk
    ]
  },

  "workflows": {
    "default": "code-review-workflow",
    "available": [
      "code-review-workflow",
      "hotfix-workflow",
      "feature-development-workflow"
    ]
  },

  "standards": {
    "coding": {
      "linter": "eslint",
      "formatter": "prettier",
      "typeChecker": "typescript"
    },
    "security": {
      "scanOnCommit": true,
      "preventSecrets": true
    },
    "review": {
      "minReviewers": 2,
      "requireTests": true
    }
  },

  "onboarding": {
    "steps": [
      "install-required-plugins",
      "configure-git-hooks",
      "setup-local-environment",
      "run-first-workflow"
    ],
    "documentation": "https://wiki.acme.com/claude-code-setup"
  }
}

Plugin Bundles

Team-Specific Plugin Packs

Backend Engineering Team:

{
  "name": "backend-engineering-pack",
  "version": "1.0.0",
  "plugins": [
    "code-reviewer@claude-code-plugins-plus",
    "test-automator@claude-code-plugins-plus",
    "database-optimizer@claude-code-plugins-plus",
    "security-auditor@claude-code-plugins-plus",
    "api-documenter@claude-code-plugins-plus",
    "performance-engineer@claude-code-plugins-plus"
  ],
  "skills": [
    "typescript-pro",
    "nodejs-expert",
    "postgresql-optimizer",
    "rest-api-designer"
  ]
}

Frontend Engineering Team:

{
  "name": "frontend-engineering-pack",
  "version": "1.0.0",
  "plugins": [
    "code-reviewer@claude-code-plugins-plus",
    "ui-visual-validator@claude-code-plugins-plus",
    "frontend-security-coder@claude-code-plugins-plus",
    "seo-content-auditor@claude-code-plugins-plus"
  ],
  "skills": [
    "react-expert",
    "css-architect",
    "accessibility-specialist",
    "responsive-design"
  ]
}

DevOps Team:

{
  "name": "devops-pack",
  "version": "1.0.0",
  "plugins": [
    "cloud-architect@claude-code-plugins-plus",
    "kubernetes-architect@claude-code-plugins-plus",
    "terraform-specialist@claude-code-plugins-plus",
    "observability-engineer@claude-code-plugins-plus",
    "deployment-engineer@claude-code-plugins-plus"
  ],
  "skills": [
    "kubernetes-ops",
    "terraform-infra",
    "prometheus-monitoring",
    "docker-containerization"
  ]
}

Bundle Installation Script

#!/bin/bash
# install-team-bundle.sh - Install team plugin bundle

BUNDLE=$1

if [ -z "$BUNDLE" ]; then
  echo "Usage: ./install-team-bundle.sh <backend|frontend|devops>"
  exit 1
fi

BUNDLE_FILE="team-bundles/${BUNDLE}-engineering-pack.json"

if [ ! -f "$BUNDLE_FILE" ]; then
  echo "Bundle not found: $BUNDLE_FILE"
  exit 1
fi

# Parse plugins from bundle
PLUGINS=$(jq -r '.plugins[]' $BUNDLE_FILE)

# Install each plugin
for plugin in $PLUGINS; do
  echo "Installing: $plugin"
  /plugin install $plugin
done

# Verify installation
/plugin list

echo "✓ Team bundle installed: $BUNDLE"

Workflow Templates

Code Review Workflow

<!-- .claude/workflows/code-review-workflow.md -->
# Code Review Workflow

## Steps

1. **Pre-Review Analysis**
   - Run linter: `npm run lint`
   - Run tests: `npm test`
   - Check types: `npm run typecheck`

2. **Automated Code Review**
   - Activate: `code-reviewer` plugin
   - Scan for security issues: `security-auditor`
   - Check performance: `performance-engineer`

3. **Generate Review Report**
   - Create summary of findings
   - Categorize issues by severity (critical, major, minor)
   - Suggest fixes with code examples

4. **Submit for Human Review**
   - Create GitHub PR with AI review in description
   - Assign to team members
   - Link Jira ticket if applicable

## Triggers

- **Manual**: `/review-pr <pr-number>`
- **Automated**: Git hook on `git push origin <branch>`
- **CI/CD**: GitHub Actions on PR creation

## Success Criteria

- ✅ No critical security issues
- ✅ Test coverage >= 80%
- ✅ All tests passing
- ✅ Linter passing
- ✅ Performance within acceptable range

Hotfix Workflow

<!-- .claude/workflows/hotfix-workflow.md -->
# Hotfix Workflow

## Steps

1. **Create Hotfix Branch**
   ```bash
   git checkout -b hotfix/issue-description main

Implement Fix
- Make minimal changes
- Focus on immediate issue
- Defer refactoring to follow-up
Expedited Testing
- Run affected tests only
- Manual verification in staging
Deploy
- Deploy to staging
- Verify fix
- Deploy to production
Post-Deployment
- Monitor metrics (error rate, latency)
- Create postmortem (if SEV-1/SEV-2)
- Schedule follow-up refactoring

Approval

SEV-1: Single approver required (on-call engineer)
SEV-2: Two approvers required
SEV-3: Standard review process

Rollback Plan

Keep previous version ready
Monitor for 30 minutes post-deploy
Auto-rollback if error rate > 5%


### Feature Development Workflow

```typescript
// .claude/workflows/feature-development.ts

interface FeatureWorkflow {
  name: string;
  steps: Step[];
  approvals: string[];
  testing: TestRequirement[];
}

const featureDevelopmentWorkflow: FeatureWorkflow = {
  name: 'feature-development',
  steps: [
    {
      name: 'Requirements Gathering',
      duration: '1-2 days',
      deliverables: ['PRD', 'Technical spec', 'UX mockups'],
      agents: ['product-manager', 'architect-reviewer']
    },
    {
      name: 'Design Review',
      duration: '0.5 days',
      deliverables: ['Architecture diagram', 'API contracts'],
      agents: ['backend-architect', 'database-optimizer']
    },
    {
      name: 'Implementation',
      duration: '3-5 days',
      deliverables: ['Code', 'Unit tests', 'Integration tests'],
      agents: ['code-reviewer', 'test-automator']
    },
    {
      name: 'Code Review',
      duration: '0.5 days',
      deliverables: ['Approved PR', 'Security scan', 'Performance review'],
      agents: ['code-reviewer', 'security-auditor', 'performance-engineer']
    },
    {
      name: 'QA Testing',
      duration: '1 day',
      deliverables: ['Test plan', 'Bug reports', 'Sign-off'],
      agents: ['test-automator']
    },
    {
      name: 'Deployment',
      duration: '0.5 days',
      deliverables: ['Production deployment', 'Monitoring setup'],
      agents: ['deployment-engineer', 'observability-engineer']
    }
  ],
  approvals: [
    'tech-lead',
    'product-manager',
    'security-reviewer'
  ],
  testing: [
    { type: 'unit', coverage: 0.8 },
    { type: 'integration', coverage: 0.6 },
    { type: 'e2e', coverage: 0.4 }
  ]
};

Onboarding Automation

New Team Member Setup Script

#!/bin/bash
# onboard-team-member.sh - Automated onboarding

MEMBER_NAME=$1
TEAM=$2

if [ -z "$MEMBER_NAME" ] || [ -z "$TEAM" ]; then
  echo "Usage: ./onboard-team-member.sh <name> <team>"
  exit 1
fi

echo "🚀 Onboarding: $MEMBER_NAME to $TEAM team"

# 1. Install Claude Code
echo "Installing Claude Code..."
npm install -g claude-code

# 2. Configure team settings
echo "Configuring team settings..."
mkdir -p ~/.claude
cp team-configs/$TEAM/config.json ~/.claude/config.json

# 3. Install team plugin bundle
echo "Installing team plugins..."
./install-team-bundle.sh $TEAM

# 4. Set up Git hooks
echo "Setting up Git hooks..."
cp team-configs/$TEAM/hooks/* .git/hooks/
chmod +x .git/hooks/*

# 5. Install Beads (task tracker)
echo "Installing Beads..."
npm install -g @beads/cli

# 6. Clone team repositories
echo "Cloning team repositories..."
while read repo; do
  git clone git@github.com:acme-corp/$repo.git
done < team-configs/$TEAM/repositories.txt

# 7. Generate welcome document
cat > ONBOARDING_$MEMBER_NAME.md <<EOF
# Welcome to the $TEAM Team!

## Your Setup
- Claude Code: Installed ✅
- Team Plugins: Installed ✅
- Git Hooks: Configured ✅
- Repositories: Cloned ✅

## Next Steps
1. Read team docs: https://wiki.acme.com/$TEAM
2. Join Slack: #team-$TEAM
3. Attend standup: Daily at 9:30 AM
4. Review team workflows: .claude/workflows/

## Quick Commands
- Review code: /review-pr <number>
- Run tests: npm test
- Deploy to staging: npm run deploy:staging

## Team Contacts
- Tech Lead: @tech-lead
- Product Manager: @product-manager
- DevOps: @devops

Happy coding! 🎉
EOF

echo "✅ Onboarding complete!"
echo "Review: ONBOARDING_$MEMBER_NAME.md"

Interactive Onboarding CLI

// onboard-cli.ts
import inquirer from 'inquirer';

interface OnboardingAnswers {
  name: string;
  team: string;
  role: string;
  projects: string[];
}

async function runOnboarding(): Promise<void> {
  console.log('🎯 Claude Code Team Onboarding\n');

  const answers = await inquirer.prompt<OnboardingAnswers>([
    {
      type: 'input',
      name: 'name',
      message: 'Your name:',
      validate: (input) => input.length > 0
    },
    {
      type: 'list',
      name: 'team',
      message: 'Select your team:',
      choices: ['backend', 'frontend', 'devops', 'mobile', 'qa']
    },
    {
      type: 'list',
      name: 'role',
      message: 'Your role:',
      choices: ['engineer', 'senior-engineer', 'staff-engineer', 'manager']
    },
    {
      type: 'checkbox',
      name: 'projects',
      message: 'Projects you\'ll work on:',
      choices: ['api-server', 'web-app', 'mobile-app', 'analytics', 'infrastructure']
    }
  ]);

  console.log('\n⚙️  Setting up your environment...\n');

  // Install team bundle
  console.log('📦 Installing plugins...');
  await installTeamBundle(answers.team);

  // Configure projects
  console.log('📂 Configuring projects...');
  for (const project of answers.projects) {
    await configureProject(project);
  }

  // Set up workflows
  console.log('🔧 Setting up workflows...');
  await setupWorkflows(answers.team);

  console.log('\n✅ Onboarding complete!\n');
  console.log('Next steps:');
  console.log('1. Read team docs: https://wiki.acme.com/' + answers.team);
  console.log('2. Join Slack: #team-' + answers.team);
  console.log('3. Run your first workflow: /code-review');
}

runOnboarding().catch(console.error);

Configuration Management

Centralized Configuration Repository

team-configs/
├── backend/
│   ├── config.json
│   ├── plugins.json
│   ├── workflows/
│   ├── hooks/
│   └── repositories.txt
├── frontend/
│   ├── config.json
│   ├── plugins.json
│   └── ...
└── devops/
    ├── config.json
    └── ...

Configuration Sync

// sync-team-config.ts
import { execSync } from 'child_process';
import { readFileSync, writeFileSync } from 'fs';

class TeamConfigSync {
  private readonly configRepo = 'git@github.com:acme-corp/team-configs.git';

  async syncFromCentral(team: string): Promise<void> {
    // Clone/pull config repo
    execSync(`git clone ${this.configRepo} /tmp/team-configs || (cd /tmp/team-configs && git pull)`);

    // Copy team config
    const teamConfig = readFileSync(`/tmp/team-configs/${team}/config.json`, 'utf-8');
    writeFileSync(`${process.env.HOME}/.claude/config.json`, teamConfig);

    // Copy workflows
    execSync(`cp -r /tmp/team-configs/${team}/workflows/* ${process.env.HOME}/.claude/workflows/`);

    // Copy hooks
    execSync(`cp /tmp/team-configs/${team}/hooks/* .git/hooks/`);

    console.log(`✓ Synced configuration for ${team} team`);
  }

  async pushLocalChanges(team: string, message: string): Promise<void> {
    // Copy local config back to central repo
    execSync(`cp ${process.env.HOME}/.claude/config.json /tmp/team-configs/${team}/config.json`);

    // Commit and push
    execSync(`
      cd /tmp/team-configs &&
      git add ${team}/ &&
      git commit -m "${message}" &&
      git push origin main
    `);

    console.log(`✓ Pushed changes to central repository`);
  }
}

// Usage
const sync = new TeamConfigSync();
await sync.syncFromCentral('backend');

Collaborative Development

Pair Programming with AI

// pair-programming.ts

interface PairSession {
  driver: string;  // Human writing code
  navigator: string;  // AI agent providing guidance
  task: string;
  startTime: number;
}

class AIPairProgramming {
  async startSession(task: string): Promise<PairSession> {
    const session: PairSession = {
      driver: 'user-123',
      navigator: 'code-reviewer-agent',
      task,
      startTime: Date.now()
    };

    console.log(`🎯 Pair Programming Session Started`);
    console.log(`Task: ${task}`);
    console.log(`Navigator: ${session.navigator}`);
    console.log('------------------------------------------\n');

    return session;
  }

  async provideGuidance(code: string, context: string): Promise<string> {
    // AI agent analyzes code and provides real-time feedback
    const response = await callClaude({
      agent: 'code-reviewer',
      prompt: `As a pair programming navigator, review this code:\n\n${code}\n\nContext: ${context}\n\nProvide:\n1. Immediate feedback\n2. Suggestions for improvement\n3. Potential bugs\n4. Best practices`
    });

    return response;
  }

  async endSession(session: PairSession): Promise<void> {
    const duration = Date.now() - session.startTime;
    console.log(`\n✅ Pair Programming Session Complete`);
    console.log(`Duration: ${Math.floor(duration / 60000)} minutes`);
  }
}

Code Review Automation

// automated-code-review.ts

interface ReviewResult {
  approved: boolean;
  issues: Issue[];
  suggestions: string[];
  score: number;  // 0-100
}

interface Issue {
  severity: 'critical' | 'major' | 'minor';
  file: string;
  line: number;
  description: string;
  suggestion?: string;
}

class AutomatedCodeReview {
  async reviewPullRequest(prNumber: number): Promise<ReviewResult> {
    // Get PR diff
    const diff = await getPRDiff(prNumber);

    // Run parallel reviews
    const [
      securityReview,
      performanceReview,
      styleReview,
      testCoverage
    ] = await Promise.all([
      this.securityAudit(diff),
      this.performanceAnalysis(diff),
      this.styleCheck(diff),
      this.checkTestCoverage(diff)
    ]);

    // Aggregate results
    const issues = [
      ...securityReview.issues,
      ...performanceReview.issues,
      ...styleReview.issues
    ];

    const score = this.calculateScore(issues, testCoverage);

    // Auto-approve if score >= 85 and no critical issues
    const criticalIssues = issues.filter(i => i.severity === 'critical');
    const approved = score >= 85 && criticalIssues.length === 0;

    return {
      approved,
      issues,
      suggestions: this.generateSuggestions(issues),
      score
    };
  }

  private calculateScore(issues: Issue[], testCoverage: number): number {
    let score = 100;

    // Deduct points for issues
    score -= issues.filter(i => i.severity === 'critical').length * 20;
    score -= issues.filter(i => i.severity === 'major').length * 10;
    score -= issues.filter(i => i.severity === 'minor').length * 5;

    // Factor in test coverage
    score = Math.min(score, testCoverage);

    return Math.max(0, score);
  }

  private async securityAudit(diff: string): Promise<{ issues: Issue[] }> {
    // Use security-auditor plugin
    return { issues: [] };
  }

  private async performanceAnalysis(diff: string): Promise<{ issues: Issue[] }> {
    // Use performance-engineer plugin
    return { issues: [] };
  }

  private async styleCheck(diff: string): Promise<{ issues: Issue[] }> {
    // Run linter
    return { issues: [] };
  }

  private async checkTestCoverage(diff: string): Promise<number> {
    // Calculate test coverage
    return 85;
  }

  private generateSuggestions(issues: Issue[]): string[] {
    return issues
      .filter(i => i.suggestion)
      .map(i => i.suggestion!);
  }
}

Best Practices

DO ✅

Standardize configurations

{
  "team": "backend",
  "plugins": [...],
  "workflows": [...]
}

Automate onboarding
```
./onboard-team-member.sh alice backend
```

Version control team configs

git commit -m "Update team workflow templates"

Document workflows

# Code Review Workflow
1. Run linter
2. Run tests
...

DON'T ❌

Don't hardcode credentials

// ❌ Hardcoded API key
{ "apiKey": "sk-..." }

// ✅ Environment variable
{ "apiKey": "${ANTHROPIC_API_KEY}" }

Don't skip testing workflows

# ❌ Deploy untested workflow
# ✅ Test first
./test-workflow.sh code-review

Tools & Resources

Configuration Management

Git: Version control for configs
Ansible: Configuration automation
Terraform: Infrastructure as code

Collaboration Tools

GitHub: Code review, PRs
Slack: Team communication
Jira: Task tracking

Summary

Key Takeaways:

Standardize configurations - Team-wide consistency
Create plugin bundles - Backend, frontend, DevOps packs
Define workflows - Code review, hotfix, feature development
Automate onboarding - Scripts for new team members
Version control configs - Git repo for team settings
Enable collaboration - Pair programming, automated reviews
Document everything - Workflows, standards, processes

Team Setup Checklist:

Last Updated: 2025-12-24 Author: Jeremy Longshore Related Playbooks: Cost Caps & Budget Management, Compliance & Audit Guide

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Team Presets & Workflows: Standardized Team Configurations

Table of Contents

Team Configuration Strategy

Configuration Layers

Team Configuration File

Plugin Bundles

Team-Specific Plugin Packs

Bundle Installation Script

Workflow Templates

Code Review Workflow

Hotfix Workflow

Approval

Rollback Plan

Onboarding Automation

New Team Member Setup Script

Interactive Onboarding CLI

Configuration Management

Centralized Configuration Repository

Configuration Sync

Collaborative Development

Pair Programming with AI

Code Review Automation

Best Practices

DO ✅

DON'T ❌

Tools & Resources

Configuration Management

Collaboration Tools

Summary

FilesExpand file tree

197-DR-SOPS-08-team-presets.md

Latest commit

History

197-DR-SOPS-08-team-presets.md

File metadata and controls

Team Presets & Workflows: Standardized Team Configurations

Table of Contents

Team Configuration Strategy

Configuration Layers

Team Configuration File

Plugin Bundles

Team-Specific Plugin Packs

Bundle Installation Script

Workflow Templates

Code Review Workflow

Hotfix Workflow

Approval

Rollback Plan

Onboarding Automation

New Team Member Setup Script

Interactive Onboarding CLI

Configuration Management

Centralized Configuration Repository

Configuration Sync

Collaborative Development

Pair Programming with AI

Code Review Automation

Best Practices

DO ✅

DON'T ❌

Tools & Resources

Configuration Management

Collaboration Tools

Summary