Claude Code for Teams: How to Set Up AI-Powered Development Workflows

Individual developers using Claude Code get a productivity boost. Teams using Claude Code get a multiplier. The difference is that teams can standardize how Claude works across the entire codebase: shared conventions via CLAUDE.md, automated quality gates via hooks, consistent code review workflows, and security policies that apply to every developer's session.

But most teams adopt Claude Code the wrong way. Each developer installs it, configures it differently (or not at all), and uses it for whatever feels convenient. There is no shared configuration. No agreed-upon workflows. No security policy. The result is inconsistent code quality and missed potential.

This guide covers how to set up Claude Code for a team properly: the plans, the shared configuration, the CI/CD integration, the security guardrails, and the workflows that make the investment worthwhile.

Key Takeaways

Claude Code Team plan costs $25/person/month (Standard seat) or $150/person/month (Premium seat with Claude Code access)
Enterprise plans include Claude Code for all seats with SSO, SCIM, audit logs, and centralized admin controls
A shared CLAUDE.md committed to your repository is the foundation of team-wide consistency
Hooks enforce code quality standards automatically: formatting, linting, testing, and security checks
Agent Teams allows multiple Claude instances to work in parallel on the same codebase with coordination
Central configuration via .claude/settings.json ensures every developer's Claude Code session follows the same rules

Team Plans and Pricing

Claude Code offers several team-oriented plans. Choose based on team size and security requirements.

Plan	Price	Claude Code Access	Key Features
Team Standard	$25/person/month	No	Web, desktop, mobile access only
Team Premium	$150/person/month	Yes	Claude Code + all Team features
Enterprise	Custom pricing	Yes (all seats)	SSO, SCIM, audit logs, admin panel, data governance

Important distinction: On the Team plan, only Premium seats ($150/person/month) include Claude Code. Standard seats ($25/person/month) get web and desktop access but not the terminal/IDE agent. If your team needs Claude Code, budget for Premium seats.

Enterprise plans include Claude Code for all seats at no additional per-seat cost for the tool itself. If your organization has more than 20-30 developers, the Enterprise plan often makes more financial sense than individual Premium seats.

What Enterprise Adds

SSO integration: Okta, Azure AD, or any SAML 2.0 provider
SCIM provisioning: Automated user provisioning and deprovisioning
Audit logs: Complete record of Claude Code activity across the organization
Admin panel: Centralized control over tool permissions, MCP server access, and file restrictions
Data governance: Control over data retention, processing, and compliance
Usage dashboard: PRs created, code committed, sessions run, token consumption

Setting Up Shared Configuration

The most impactful thing a team can do is standardize Claude Code's configuration. This means three files committed to your repository.

1. The Shared CLAUDE.md

The CLAUDE.md in your project root is read by every developer's Claude Code session. This is where team-wide standards live.

A well-structured team CLAUDE.md includes:

# Project: [Your Project Name]

## Build & Test
- Build: `pnpm build`
- Test all: `pnpm test`
- Test single file: `pnpm test -- path/to/test`
- Lint: `pnpm lint`
- Format: `pnpm format`

## Architecture
- Monorepo with pnpm workspaces
- Frontend: React 19, TypeScript, Tailwind
- Backend: Node.js, Express, Prisma, PostgreSQL
- See docs/architecture.md for detailed system design

## Code Conventions
- Named exports only. No default exports.
- All API responses include `requestId` for tracing
- Error handling: use AppError class from src/lib/errors.ts
- Tests go in __tests__/ directories, not co-located
- Database migrations go in prisma/migrations/

## Git Workflow
- Branch naming: feat/, fix/, chore/ prefix
- Commit messages: conventional commits format
- All PRs require passing CI before merge
- Squash merge to main

## What NOT to Do
- Never commit .env files
- Never use `any` type in TypeScript
- Never make direct database queries outside the repository layer
- Never push to main directly

Key principle: Put information in CLAUDE.md that every developer would otherwise need to repeat in every session. Build commands, conventions, architecture pointers, and hard rules. Leave out anything Claude can infer from the code itself.

2. The Shared Settings File

.claude/settings.json contains Claude Code configuration that applies to every team member working in this project:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "type": "command",
        "command": "npx prettier --write \"$CLAUDE_FILE_PATH\" 2>/dev/null || true"
      },
      {
        "matcher": "Edit|Write",
        "type": "command",
        "command": "npx eslint --fix \"$CLAUDE_FILE_PATH\" 2>/dev/null || true"
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "type": "command",
        "command": "echo \"$CLAUDE_TOOL_INPUT\" | grep -qE '(rm -rf /|git push --force|DROP TABLE|DROP DATABASE)' && echo 'BLOCKED: Dangerous command' && exit 1 || true"
      }
    ]
  },
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Commit this file. Every developer who clones the repo gets the same hooks and MCP configuration. Individual developers can add personal settings in their user-level config (~/.claude/settings.json) without affecting the team.

3. Custom Slash Commands

Create shared slash commands in .claude/commands/ for workflows your team uses regularly:

.claude/commands/review.md - Code review workflow:

Review the current branch against main. Run `git diff main...HEAD` to see all changes.

For each changed file, check:
1. Logic errors and unhandled edge cases
2. Security vulnerabilities (SQL injection, XSS, auth bypass)
3. Performance issues (N+1 queries, missing indexes, unnecessary re-renders)
4. Missing test coverage
5. Violations of conventions in CLAUDE.md

Output a structured review with specific line references and suggested fixes.

.claude/commands/pr.md - Pull request creation:

Create a pull request for the current branch.

1. Read all commits since branching from main
2. Write a clear PR title (under 70 chars)
3. Write a description with: Summary, Changes Made, Testing Done
4. Ensure all tests pass before creating the PR
5. Create the PR using the GitHub MCP

These commands ensure consistent workflows across the team. A new developer can run /project:review on day one and get the same quality review process as a senior team member.

CI/CD Integration

Claude Code can run in headless mode, which means it can be part of your CI/CD pipeline. Here are the most valuable integration points.

Automated Code Review on PRs

Add a GitHub Action that runs Claude Code review on every pull request:

name: AI Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
      - run: npm install -g @anthropic-ai/claude-code
      - name: Run Claude Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude --headless --print "Review the changes in this PR. \
          Run git diff origin/main...HEAD. \
          Post your review as a PR comment using the GitHub MCP. \
          Focus on bugs, security issues, and performance problems. \
          Be specific with line numbers."

This gives every PR an automated first-pass review. It catches obvious issues before human reviewers spend their time, and it runs within minutes of PR creation.

Automated Test Generation

When new code lands without sufficient test coverage, Claude Code can generate the missing tests:

name: Generate Missing Tests
on:
  push:
    branches: [main]

jobs:
  test-coverage:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
      - run: npm install -g @anthropic-ai/claude-code
      - run: pnpm install
      - name: Check Coverage and Generate Tests
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          COVERAGE=$(pnpm test -- --coverage --json 2>/dev/null | jq '.total.lines.pct')
          if (( $(echo "$COVERAGE < 80" | bc -l) )); then
            claude --headless --print "Run the test suite with coverage. \
            Identify files below 80% line coverage. \
            Write tests for the uncovered code paths. \
            Run tests to verify they pass. \
            Commit the new tests to a branch and create a PR."
          fi

Documentation Updates

Claude Code can automatically update documentation when code changes:

- name: Update API Docs
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  run: |
    claude --headless --print "Check if any API endpoints were modified \
    in the last commit. If so, update the corresponding documentation \
    in docs/api/. Ensure parameter types, response formats, and examples \
    are accurate. Commit any documentation changes."

Agent Teams: Parallel AI Development

Agent Teams is Claude Code's feature for coordinating multiple Claude instances working simultaneously on the same codebase. A lead agent spawns and manages specialized agents that each handle a portion of the work.

How It Works

You describe a complex task to the lead agent
The lead agent breaks it into subtasks and spawns teammate agents
Each teammate works on its subtask independently
The lead agent coordinates, resolves conflicts, and merges results
The final output is a cohesive set of changes

When to Use Agent Teams

Feature implementation: Split frontend, backend, and test writing across three agents
Large refactors: Each agent handles a different module or service
Migration tasks: One agent per service in a microservices architecture
Bulk operations: Processing multiple files or components in parallel

Configuration

Start with 3-5 teammates for most workflows. More agents means more parallelism but also more coordination overhead. The sweet spot depends on how independent the subtasks are.

Implement the user profile feature. Use agent teams with:
- Agent 1: Database schema and migrations (prisma/)
- Agent 2: API endpoints (src/api/users/)
- Agent 3: React components (src/components/Profile/)
- Agent 4: Test suite (src/__tests__/users/)

Each agent should follow the conventions in CLAUDE.md.
Coordinate to ensure API contracts match between frontend and backend.

Security Best Practices

Deploying AI coding tools across a team requires security guardrails. Here is what matters.

API Key Management

Use organization-level API keys from the Anthropic console, not personal keys
Store keys in your CI/CD secret management system (GitHub Secrets, Vault, etc.)
Rotate keys every 90 days
Use separate keys for development and CI/CD environments

Data Security

Claude Code sends code to Anthropic's API for processing
Anthropic's policy: API inputs and outputs are not used for model training
Enterprise plans provide additional data governance: data retention controls, processing region selection, and compliance certifications
If your organization has strict data sovereignty requirements, discuss with Anthropic's enterprise team before deployment

Permission Controls

Use PreToolUse hooks to enforce security policies:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "type": "command",
        "command": "echo \"$CLAUDE_TOOL_INPUT\" | grep -qiE '(curl.*-d|wget|ssh|scp|rsync)' && echo 'BLOCKED: Network operation requires approval' && exit 1 || true"
      },
      {
        "matcher": "Write|Edit",
        "type": "command",
        "command": "echo \"$CLAUDE_FILE_PATH\" | grep -qE '(\\.env|credentials|secrets|private)' && echo 'BLOCKED: Cannot modify sensitive files' && exit 1 || true"
      }
    ]
  }
}

These hooks prevent Claude Code from making network requests or modifying sensitive files without explicit approval. Customize the patterns for your organization's security policies.

MCP Server Security

Only install MCP servers that your team actually needs
Use project-scope MCP configuration (not user-scope) for servers with sensitive access
Grant minimum necessary permissions when creating API tokens for MCP servers
Audit MCP server usage through the Enterprise admin panel

Onboarding New Developers

A well-configured Claude Code setup dramatically accelerates onboarding. Here is the workflow:

Day 1 Setup

New developer clones the repository
Shared CLAUDE.md and .claude/settings.json are already in the repo
Developer installs Claude Code and authenticates
Developer sets required environment variables (GITHUB_TOKEN, etc.)
Developer runs claude in the project directory

Claude Code immediately understands the project: build commands, architecture, conventions, git workflow. The new developer can start being productive with prompts like:

"Explain the authentication flow in this application"
"Show me how the API routing works and where I would add a new endpoint"
"What tests are currently failing and why?"

Ongoing Team Practices

Update CLAUDE.md when conventions change. Treat it like documentation.
Add to .claude/commands/ when a workflow becomes common. If three developers are doing the same thing manually, it should be a slash command.
Maintain a tasks/lessons.md with common mistakes Claude makes in your codebase. Reference it from CLAUDE.md. Over time, Claude stops repeating the same errors.
Review hook effectiveness monthly. Are the PostToolUse hooks catching real issues? Are PreToolUse hooks blocking things that should be allowed? Iterate.

Monitoring and Measuring Impact

You cannot improve what you do not measure. Here is what to track.

Metrics That Matter

Metric	How to Measure	What It Tells You
PRs per developer per week	GitHub analytics	Overall throughput change
Time from issue to PR	GitHub issue timestamps	Development velocity
CI failure rate	CI/CD dashboard	Whether AI-generated code meets quality standards
Code review turnaround	GitHub PR analytics	Whether automated first-pass review helps
Claude Code token usage	Anthropic dashboard / Enterprise panel	Cost per developer
Developer satisfaction	Monthly survey	Whether the team finds the tool helpful

The Enterprise Dashboard

Enterprise plans include a usage dashboard showing:

Sessions run per developer
Token consumption over time
PRs and commits created via Claude Code
Cost breakdown by team and individual

Export metrics to your observability stack with OpenTelemetry integration for custom reporting.

ROI Calculation

A simple framework for justifying the investment:

Monthly cost per developer = $150 (Premium seat)
Hours saved per developer per week = X
Developer hourly cost = Y
Monthly savings = X * Y * 4.3 weeks
ROI = (Monthly savings - Monthly cost) / Monthly cost

Most teams report 5-15 hours saved per developer per week. At a $75/hour fully-loaded developer cost, even 5 hours per week saves $1,612/month per developer. That is a 10x return on the $150/month Premium seat.

Common Team Workflow Patterns

The Review-First Pattern

Every PR goes through Claude Code review before human review. The automated review catches formatting issues, missing tests, potential bugs, and convention violations. Human reviewers focus on architecture, business logic, and edge cases. This reduces human review time by 30-50%.

The Draft-and-Delegate Pattern

A senior developer writes a high-level spec or plan. Claude Code implements it. The senior developer reviews the implementation and iterates. This multiplies the senior developer's output without requiring them to write every line.

The Parallel Sprint Pattern

During sprint work, each developer uses Claude Code for their own tasks. For large cross-cutting changes, Agent Teams coordinates multiple Claude instances to complete the work in parallel. This turns a 2-day refactor into a 2-hour supervised task.

The Documentation-First Pattern

Before writing code, Claude Code generates documentation: API specs, architecture decisions, test plans. The team reviews the documentation, and once approved, Claude Code implements exactly what was documented. This reduces rework by aligning on the approach before any code is written.

Getting Started

Here is the concrete action plan for a team adopting Claude Code:

Choose a plan: Team Premium ($150/person/month) or Enterprise (custom pricing). If budget is tight, start with Premium seats for 2-3 developers as a pilot.
Write the shared CLAUDE.md: Pull your senior developers into a 30-minute session. Document build commands, conventions, architecture, and hard rules. Commit to the repo.
Configure shared hooks: Add formatting and linting hooks to .claude/settings.json. Add security guards for sensitive files and dangerous commands. Commit to the repo.
Create initial slash commands: Start with a code review command and a PR creation command. Add more as workflows emerge.
Install team MCP servers: At minimum, GitHub MCP. Add others based on your stack.
Run a pilot: Have 2-3 developers use Claude Code for a full sprint. Measure PRs shipped, time saved, and code quality.
Iterate and expand: Based on pilot results, refine CLAUDE.md, add slash commands, adjust hooks, and roll out to the full team.

For more on individual Claude Code techniques, read our tips and tricks guide. For MCP configuration details, see our MCP setup guide. And for a broader comparison of AI coding tools for team adoption, check our best AI coding tools guide.

The Claude Code Brief. Weekly. No noise.