Team Presets & Workflows

• 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

// .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!

<h2>Your Setup</h2>

Claude Code: Installed ✅
Team Plugins: Installed ✅
Git Hooks: Configured ✅
Repositories: Cloned ✅


<h2>Next Steps</h2>

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


<h2>Quick Commands</h2>

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


<h2>Team Contacts</h2>

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
');

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('
⚙️  Setting up your environment...
');

// 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('
✅ Onboarding complete!
');
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('------------------------------------------
');

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:

${code}

Context: ${context}

Provide:
1. Immediate feedback
2. Suggestions for improvement
3. Potential bugs
4. Best practices`
});

return response;
}

async endSession(session: PairSession): Promise<void> {
const duration = Date.now() - session.startTime;
console.log(`
✅ 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:

• [ ] Create team configuration file
• [ ] Define plugin bundle for team
• [ ] Document workflows (code review, hotfix, feature)
• [ ] Write onboarding script
• [ ] Set up configuration repository
• [ ] Configure Git hooks
• [ ] Establish coding standards
• [ ] Create workflow templates
• [ ] Train team on workflows
• [ ] Schedule quarterly config reviews

Last Updated: 2025-12-24

Author: Jeremy Longshore

Related Playbooks: Cost Caps & Budget Management, Compliance & Audit Guide