Sports Media Inc. Computer Science Training Academy

Master Full-Stack & Cybersecurity with Claude Opus 4.7, GPT-5.5, Gemini 3.1 & Open Source Tools

Claude Opus 4.7 Agent Teams Setup

Enable multi-agent collaboration in Claude Code v2.1+ for parallel development workflows. Now powered by Opus 4.7 (April 16, 2026 release).

For Sports Media Inc. Training Site - Last Updated: May 12, 2026

NEW: Agent View →Requires Claude Code v2.1.139+

Quick Setup

Step 1: Install or Update Claude Code

Claude Code ships as a standalone native binary. Choose the instructions for your operating system.

macOS

Install via the official installer (recommended) or Homebrew:

# Recommended - official installer (auto-updates)
curl -fsSL https://claude.ai/install.sh | bash

# Alternative - Homebrew (manual updates)
brew install claude-code

Works on Intel and Apple Silicon (M1/M2/M3/M4). Do not use sudo. If claude is not found after install, open a new terminal window.

Linux (Ubuntu / Debian / Fedora / Arch)

# Official installer (auto-updates)
curl -fsSL https://claude.ai/install.sh | bash

Supports Ubuntu 20.04+, Debian 10+, Fedora, Arch, and Alpine. Installs to ~/.claude/bin/.

Windows

Claude Code runs natively on Windows via PowerShell or CMD, or through WSL:

# Option A: Native Windows (PowerShell)
winget install Anthropic.ClaudeCode

# Option B: WSL (Ubuntu) - install WSL first if needed
wsl --install -d Ubuntu
# Then inside WSL:
curl -fsSL https://claude.ai/install.sh | bash

WinGet does not auto-update. Run winget upgrade Anthropic.ClaudeCode to update manually. For agent teams with split panes, WSL with tmux is recommended.

Verify Installation

claude --version
claude doctor

claude doctor checks your installation type, version, and reports any issues.

Step 2: Enable Agent Teams Globally

Open your global Claude settings file:

# macOS / Linux
code ~/.claude/settings.json
# or: nano ~/.claude/settings.json

# Windows (PowerShell)
code $env:USERPROFILE\.claude\settings.json

Paste this configuration (replace everything in the file):

{
  "alwaysThinkingEnabled": true,
  "model": "opus",
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Save the file. This enables agent teams across all your projects on this computer. The setting must be nested under the "env" key - not at the root level of the JSON.

Step 3: Install tmux

Agent teams use tmux to spawn each teammate in its own terminal pane so you can see all agents working simultaneously. Install tmux for your platform:

macOS

brew install tmux

Ubuntu / Debian

sudo apt update
sudo apt install tmux

Fedora / RHEL

sudo dnf install tmux

Windows: tmux does not run natively on Windows. Use WSL (wsl --install), then install tmux inside your WSL distribution. Alternatively, set teammateMode to "in-process" in settings.json to run teammates without tmux (agents share your terminal instead of getting separate panes).

macOS iTerm2 users: Claude Code auto-detects iTerm2 as a split-pane backend. No extra configuration needed.

Step 4: Restart Claude Code

# Close your current Claude session
exit

# Start fresh with tmux, then launch Claude
tmux
claude

Setup Complete

Agent teams are now enabled globally. No per-project configuration needed.

Research Preview - May 11, 2026

Agent View (Claude Code v2.1.139+)

A unified dashboard for managing multiple parallel Claude Code sessions from one terminal. Spawn, monitor, and attach to sessions without juggling tmux panes or windows.

Read the announcement

Quickstart

  1. Update Claude Code: npm install -g @anthropic-ai/claude-code@latest (need v2.1.139 or later).
  2. Confirm version: claude --version.
  3. Open the agent view: run claude agents, or press ← from inside any active session.
  4. Type a prompt at the bottom and press Enter. A new session starts and appears as a row.
  5. Each row shows: session, state (working / waiting for input / completed / failed / idle / stopped), last response preview, last-interaction time.

Keybindings

EnterSend the prompt (spawn a new session)
↑ / ↓Move between rows
Enter on rowAttach to the selected session
→ on rowAttach to the selected session
Alt+1..Alt+9Attach directly to the Nth session
← on empty promptDetach (back to agent view)

When to use Agent View vs tmux

  • Use Agent View when you want to fan out 3-10 short parallel tasks (audit X, fix Y, draft Z) and triage state at a glance.
  • Use Agent View for the AI-Driven Research SOP: run Stage 2 (Gemini), Stage 3 (DeepSeek), and Stage 4 (Claude synthesis) in separate sessions and switch between them via Alt+1..3.
  • Keep tmux when you need long-running sessions across multiple machines or terminals, or when you want layout control beyond a single dashboard.
  • Agent View is currently a research preview, so expect rapid iteration. Pin your team to a specific CLI version in .tool-versions if you need stability.

How Agent Teams Work

An agent team consists of a team lead (your main Claude session), one or more teammates (independent Claude instances), a shared task list, and a mailbox for inter-agent communication. The lead orchestrates the work while teammates execute tasks in parallel.

1.
Global setting - Works across all projects after one-time setup.
2.
Requires tmux (for split panes) - Each teammate gets its own tmux pane. Without tmux, teammates run in-process (same terminal, navigate with Shift+Up/Down).
3.
Explicit prompts - You must ask for agent teams in your prompt. Claude will not create a team automatically.
4.
Automatic role assignment - You describe what you need done and Claude creates the team structure, assigns roles, and distributes tasks. You do not need to manually define agents.

Your Workflow Changes by Two Words

Before: "Update the website and push to Vercel."

With teams: "Use agent teams to update the website and push to Vercel."

Everything else stays the same - git, Supabase, Vercel, and all existing workflows work as before.

Architecture Overview

ComponentRole
Team LeadYour main Claude Code session. Creates the team, spawns teammates, and coordinates work.
TeammatesSeparate, independent Claude Code instances that each work on assigned tasks.
Task ListShared list of work items with dependency tracking. Teammates claim and complete tasks.
MailboxInbox-based messaging system for peer-to-peer communication between agents.

Tasks have three states: pending, in progress, and completed. Tasks can depend on other tasks - a pending task with unresolved dependencies cannot be claimed until those dependencies are completed. File locking prevents race conditions when multiple teammates try to claim the same task.

Training Site Prompt Examples

Copy and paste these prompts directly into your tmux + Claude session. Each describes the team structure so Claude knows how to distribute the work.

Website Audit & Performance Check

Use agent teams to audit https://computersciencesop2.vercel.app. Have one agent check Lighthouse performance scores, another review accessibility/SEO, another analyze mobile responsiveness, and a fourth check all external links and student program URLs. Summarize findings with priority fixes.

Result: 4 agents work in parallel - performance, accessibility, responsiveness, and link validation - then the lead consolidates findings.

Deploy to Vercel (Full Workflow)

Use agent teams to deploy this project to Vercel. One agent runs the production build and tests, another handles git commit/push to the main branch, a third initiates Vercel deployment, and a fourth verifies the live URL and checks for deployment errors. Share the production URL when complete.

Result: Parallel execution of build, git, deploy, and verification.

Update Supabase + Website + Deploy

Use agent teams to: update Supabase schema to add 'program_clicks' analytics table, update the homepage hero section with new messaging, add tracking to all student program signup buttons, test locally, commit to GitHub, and deploy to Vercel. Share the live URL and Supabase migration SQL.

Result: Multi-layer changes (database + UI + deploy) completed in parallel.

Create New Student Program Page

Use agent teams to create a new page for the GitHub Student Developer Pack at /programs/github-pack. One agent builds the Next.js page with all pack benefits listed, another creates the Supabase table for tracking signups, a third adds navigation links from the homepage, and a fourth deploys to Vercel and shares the URL.

Result: Complete feature from page creation to deployment.

Fix Broken Links & Update Content

Use agent teams to scan all pages on https://computersciencesop2.vercel.app for broken external links to student programs, verify each program is still active and the URLs are correct, update any outdated information (prices, deadlines, eligibility), commit changes, and deploy. Provide a summary of all fixes made.

Result: Comprehensive site maintenance with automated fixes.

Add New Documentation Section

Use agent teams to add a new section to the training site. One agent writes the documentation content following our existing format, another creates the page layout and navigation, a third adds code examples and setup instructions, and a fourth deploys to Vercel and validates all links work. Follow our existing design system.

Result: Documentation writing, page structure, code examples, and deployment handled in parallel.

When to Use Agent Teams vs. Solo Claude

TaskSolo ClaudeAgent Teams
Quick button color fixBest choice - fastOverkill
Routine deploy to VercelBest choice - simpleNot needed
Multi-step workflow (DB + UI + Deploy)Slow, sequentialParallel speed
Website audit (perf + a11y + SEO)May miss anglesParallel experts
Full feature (schema + code + test + deploy)Sequential, slowerParallel execution

Rule of thumb: If your task has 3 or more independent steps, use agent teams. A 3-teammate team uses roughly 3-4x the tokens of a single session, so reserve teams for tasks where parallel execution provides a clear benefit.

Best Practices

Give Teammates Rich Context

Teammates start with a blank conversation - they do not inherit the lead's history. They load CLAUDE.md automatically, but task-specific details must be in your prompt. Be explicit about what files matter, what conventions to follow, and what "done" looks like.

Size Tasks Appropriately

Aim for roughly 5-6 tasks per teammate. Too granular and coordination overhead dominates. Too broad and you lose the benefit of parallelism. Each task should produce a clear deliverable (a function, a test file, a review).

Avoid File Conflicts

There is no built-in file locking for code files. Two teammates writing to the same file means last write wins. Structure work so each teammate owns different files. If they need to touch the same file, sequence the tasks with dependencies.

Use Distinct Roles

Assign each teammate a distinct lens so they do not overlap. For example, when reviewing a PR: one focused on security, one on performance, one on test coverage.

Plan First, Execute Second

Use plan mode to design the work (cheap), then hand the plan to a team for parallel execution (faster but uses more tokens). The plan gives you a checkpoint before committing resources.

Start with Read-Only Tasks

If you are new to agent teams, start with tasks that do not modify code: reviewing a PR, researching a library, investigating a bug. Learn the coordination patterns before letting multiple agents write code simultaneously.

Pro Tips

Keyboard Shortcuts (In-Process Mode)

ShortcutAction
Shift+Up/DownSelect a teammate
EnterView a teammate's session
EscapeInterrupt a teammate's turn
Ctrl+TToggle the task list
Shift+TabCycle into delegate mode

Validation Test

Run this test to confirm everything works:

# In your terminal
tmux
claude

Then paste this prompt:

Agent team: create a simple Next.js hello world page with TypeScript, deploy it to Vercel, and share the live URL.

Expected result: 2-4 tmux panes open with agents working in parallel. The lead coordinates while teammates handle page creation, build, and deployment.

Troubleshooting

"Agent teams not available"

Restart Claude after editing ~/.claude/settings.json. Run exit, then tmux, then claude. Verify the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS key is nested inside the "env" object.

"tmux: command not found"

macOS: brew install tmux. Ubuntu/Debian: sudo apt install tmux. Windows: Install WSL first (wsl --install), then install tmux inside WSL.

Agent teams not spawning

Did you explicitly ask for teams in your prompt? Add "use agent teams" or start with "Agent team:" in your prompt. Claude will not create a team unless you request it.

"command not found: claude" after installation

Open a new terminal window. The installer modifies your shell profile (.zshrc, .bashrc), but changes only take effect in new sessions.

Split panes not showing in VS Code terminal

Split-pane mode is not supported in VS Code's integrated terminal, Windows Terminal, or Ghostty. Use a standalone terminal (iTerm2 on macOS, a native terminal on Linux, or WSL on Windows) with tmux.

Team Agents with Instructions & SOPs

Combine agent teams with custom instructions and standard operating procedures to create specialized, repeatable workflows. This is how Gilbridge staff and students should set up their team workflows for consistent results.

Step 1: Define Your Team SOP in CLAUDE.md

Your CLAUDE.md file acts as the SOP for all agents. Every teammate loads it automatically on start, so put team-wide instructions here.

# CLAUDE.md - Team SOP

## Team Roles
- **Lead Agent**: Coordinates work, reviews outputs, manages git
- **Frontend Agent**: UI components, styling, accessibility
- **Backend Agent**: API routes, database, server logic
- **QA Agent**: Testing, validation, link checking

## Standards (All Agents Must Follow)
- TypeScript strict mode required
- All components must be accessible (WCAG 2.1 AA)
- No secrets in code - use environment variables
- Run `npm run lint` before committing
- Follow existing code patterns and naming conventions

## Workflow
1. Lead creates tasks and assigns to teammates
2. Each teammate works on assigned files only
3. Teammates report completion via mailbox
4. Lead reviews, runs build, commits, and deploys

## Deployment SOP
1. Run `npm run build` - fix any errors
2. Run `npm run lint` - fix any warnings
3. Git commit with descriptive message
4. Push to main branch
5. Verify Vercel deployment succeeds

All teammates inherit this context automatically. No manual sharing needed.

Step 2: Give Agents Specific Instructions in Your Prompt

While CLAUDE.md provides the team SOP, your prompt should include specific role instructions for each agent. This ensures each teammate knows their exact responsibilities.

Use agent teams to update the training site with the following structure:

Agent 1 (Content Writer): Update all free tools documentation on /tools/ai-platforms.
Verify all URLs are current, update pricing, and add any new student programs. Follow
our existing card layout pattern.

Agent 2 (Frontend Dev): Create a new ClaudeModelsGuide component explaining Opus 4.6
vs Sonnet 4.6, extended thinking, and deep research. Match existing design system
(Tailwind, rounded-lg cards, gradient headers).

Agent 3 (QA & Deploy): After agents 1 and 2 finish, run npm build, check for TypeScript
errors, verify all links work, commit to git, and deploy to Vercel. Share the live URL.

All agents: Follow the CLAUDE.md SOP for coding standards and deployment procedures.

The lead agent will create tasks with dependencies - QA waits for content and frontend to complete.

Step 3: SOP Templates for Common Team Tasks

SOP: Website Content Update

  1. 1. Research agent verifies all external URLs and program details are current
  2. 2. Content agent updates page content with verified information
  3. 3. Frontend agent ensures responsive layout and accessibility
  4. 4. QA agent runs build, tests links, commits, and deploys

SOP: New Feature Development

  1. 1. Architecture agent designs the component structure and data flow
  2. 2. Backend agent creates API routes and database schema
  3. 3. Frontend agent builds UI components following design system
  4. 4. Integration agent connects frontend to backend, runs full tests
  5. 5. Deploy agent commits, pushes, and verifies production deployment

SOP: Site Audit & Maintenance

  1. 1. Performance agent runs Lighthouse and identifies bottlenecks
  2. 2. Accessibility agent checks WCAG compliance across all pages
  3. 3. Content agent verifies all external links and program details
  4. 4. Security agent reviews for exposed secrets and XSS vulnerabilities
  5. 5. Lead consolidates findings into prioritized fix list

SOP: DoD/Gilbridge Staff Onboarding

  1. 1. Setup agent installs Claude Code and configures settings.json
  2. 2. Training agent walks through CLAUDE.md creation and PSB workflow
  3. 3. Tools agent sets up all free student programs and accounts
  4. 4. Verification agent confirms all tools are accessible and working

Model Selection for Agent Teams

Optimize cost and performance by mixing models within your team:

Opus 4.7 (Team Lead - NEW)

Use Opus for the lead agent that coordinates work, makes architectural decisions, and reviews outputs. The deeper reasoning is worth the extra tokens for coordination.

Sonnet 4.6 (Teammates)

Use Sonnet for worker agents doing focused implementation tasks. Faster execution and lower token cost per agent. Enable extended thinking for tasks requiring deeper reasoning.

// ~/.claude/settings.json - Optimal team config
{
  "alwaysThinkingEnabled": true,
  "model": "opus",
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}
// Note: Lead uses Opus. Teammates default to Sonnet for cost efficiency.
// The system handles model selection per role automatically.

Known Limitations

Additional Resources

Ready to Get Started?

One-time global setup. Explicit prompts. Parallel execution on multi-step workflows.

Ideal for training site updates, Supabase + Vercel deployments, content audits, and full-feature development.