Module 7: Remote Control and CLAUDE.md for Teams
1. Module Introduction — Remote Control and CLAUDE.md as the Team Constitution
1. Module Introduction — Remote Control and CLAUDE.md as the Team Constitution
Description
Up to this point, everything you've built with Claude Code requires you to be in front of your computer. You created specialized subagents, gave them memory, coordinated them in parallel, organized them into teams with task boards, packaged them as plugins, and automated them with hooks and the headless SDK. A complete stack. But there's a silent restriction that has been there since Module 1: your terminal. You're always there. If an Agent Team is running a 45-minute refactor and needs approval for a force push — you have to be sitting there waiting. If you go for a walk, the agent gets blocked.
Remote control removes that restriction. It's the ability to connect to active Claude Code sessions from another device — your phone, your tablet, another computer — to monitor progress, approve operations, or redirect work. The Agent Team keeps running on your machine. You supervise from anywhere.
But remote control solves an individual problem. When three people on your team use Claude Code, a different problem appears: consistency. You configure your CLAUDE.md with strict TypeScript conventions. Your colleague uses Python with tabs. Another has no CLAUDE.md. Each agent produces code with different styles, different patterns, different quality. The result is a chaotic repository where each file seems written by a different person — because it was, by agents with different rules.
CLAUDE.md for teams solves this. It's a file shared in the repository that establishes the rules all the agents follow: code conventions, architectural patterns, security restrictions, testing requirements. When a new member clones the repo, their Claude Code automatically adopts the team's rules. There's no manual onboarding. There's no "how did you configure your Claude?"
This module opens Phase 3 (Orchestration) because it's the bridge between individual automation and team operation. Remote control frees you from the terminal. CLAUDE.md unifies your team. Together, they turn Claude Code from "my personal tool" into "my team's tool."
Where Are We in the Guide?
Context in the Guide
This guide has 8 modules organized into 3 phases:
Phase 1: Advanced Subagents (Modules 1-3) ← COMPLETED
├── Module 1: Custom Subagents ✅
├── Module 2: Agent Memory and Scopes ✅
└── Module 3: Parallel Sub-Agent Delegation ✅
Phase 2: Agent Teams and Plugins (Modules 4-6) ← COMPLETED
├── Module 4: Agent Teams ✅
├── Module 5: Plugins: Creating and Distributing ✅
└── Module 6: Advanced Hooks and Headless SDK ✅
Phase 3: Orchestration (Modules 7-8)
├── Module 7: Remote Control and CLAUDE.md for Teams ← YOU ARE HERE
└── Module 8: Project: Complete Multi-Agent System
Total estimated duration: 8-10 hours (self-paced).
What changes with remote control and CLAUDE.md?
In the previous modules, the automation was local and personal. Hooks react to events, the SDK runs Claude Code from scripts, but everything runs on your machine and with your rules. Remote control extends the operational reach — you can supervise from anywhere. CLAUDE.md extends the organizational reach — your rules are shared with the whole team.
The mental shift is: you stop thinking like an individual developer and start thinking like a tech lead who designs the operation of a team of agents.
From Individual Automation to Team Operation
What you have now
After 6 modules, your stack is powerful but personal:
┌─────────────────────────────────────────────────────┐
│ Your Current Stack (Individual) │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ Subagents (M1) + Memory (M2) + Parallel (M3)│ │
│ │ Agent Teams (M4) + Plugins (M5) │ │
│ │ Hooks + SDK (M6) │ │
│ └──────────────────────────────────────────────┘ │
│ │
│ Limitations: │
│ ❌ You must be at the terminal to supervise │
│ ❌ Your rules aren't shared with the team │
│ ❌ Each developer configures differently │
│ ❌ Manual onboarding for new members │
└─────────────────────────────────────────────────────┘
What you'll have after this module
┌─────────────────────────────────────────────────────┐
│ Your Stack + Team Operation │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ Everything above + │ │
│ │ Remote Control (supervise from any │ │
│ │ device, approve operations remotely) │ │
│ │ Shared CLAUDE.md (team constitution) │ │
│ └──────────────────────────────────────────────┘ │
│ │
│ Gains: │
│ ✅ Supervise Agent Teams from your phone │
│ ✅ Approve operations without being at the terminal │
│ ✅ Consistent rules for the whole team │
│ ✅ Automatic onboarding: clone = adopt the rules │
└─────────────────────────────────────────────────────┘
Remote Control: Supervising Without Being There
The real problem
Imagine this scenario: you configured an Agent Team to do a massive refactor. The team lead coordinates 3 teammates, each working on a different module. The process will take 30-40 minutes. At 15 minutes, one of the teammates needs to approve a git push --force to a staging branch. Without remote control, you have two options:
- Sit there for 40 minutes watching the terminal — a waste of time
- Leave and come back — the agent got blocked for 25 minutes waiting for your approval
Remote control adds a third option:
- Leave and approve from your phone — the notification arrives, you review, you approve, the agent continues
Remote control capabilities
From your mobile device or web you can:
┌────────────────────────────────────────────┐
│ 👁️ MONITOR │
│ See what Claude is doing in real │
│ time — edited files, commands, │
│ Agent Team state │
├────────────────────────────────────────────┤
│ ✅ APPROVE / ❌ REJECT │
│ Operations that require permission — │
│ force push, database changes, deploys │
├────────────────────────────────────────────┤
│ 🔄 REDIRECT │
│ Change priorities, pause tasks, │
│ send additional instructions │
├────────────────────────────────────────────┤
│ 🛑 INTERRUPT │
│ Stop the execution if something goes wrong │
└────────────────────────────────────────────┘
Experimental status: Remote control is a feature in active development. The capabilities described are based on the documentation available as of March 2026. Verify the current availability at docs.anthropic.com.
Real use cases
| Scenario | Without remote control | With remote control |
|---|---|---|
| Long refactor (30+ min) | You wait, sitting there | You monitor from the café |
| Nightly batch job | You review results the next day | You approve operations from bed |
| CI that needs approval | The pipeline blocks until you open the laptop | You approve from your phone |
| Agent Team with an error | You don't find out until you return | You receive a notification, you intervene |
CLAUDE.md: The Team Constitution
More than a configuration file
You already know CLAUDE.md from previous guides. You used it to give Claude Code instructions about your project: "use strict TypeScript", "don't modify files in production/", "the tests go in tests/". It worked well for you.
But when three developers work in the same repo with different CLAUDE.md files (or with no CLAUDE.md), the result is inconsistency. CLAUDE.md for teams isn't just a configuration file — it's a constitution: the document that defines the rules, values, and restrictions all the agents respect.
The merge hierarchy
CLAUDE.md works at three levels, with a clear precedence hierarchy:
Level 1: Global (~/.claude/CLAUDE.md)
Personal preferences that apply to ALL your projects.
E.g.: "Always respond in Spanish", "Use vim keybindings"
▼ (project overrides global)
Level 2: Project (./CLAUDE.md in the repo root)
The team's rules. They're committed to the repo.
E.g.: "TypeScript strict", "No console.log", "Tests with vitest"
▼ (subdirectory overrides project)
Level 3: Subdirectory (./src/api/CLAUDE.md)
Rules specific to a module.
E.g.: "Endpoints follow RESTful naming", "Validation with Zod"
The precedence rule: more specific wins. If your global CLAUDE.md says "use tabs" but the project's CLAUDE.md says "use spaces", the project wins when you work in that repo.
What to put in a team CLAUDE.md
An effective team CLAUDE.md has clear sections:
# CLAUDE.md — [Project Name]
## Code Conventions
- TypeScript strict mode required
- Pure functions preferred over classes
- Name files in kebab-case
## Architecture
- API: FastAPI with modular routers
- DB: PostgreSQL with SQLAlchemy async
- Cache: Redis for sessions and rate limiting
## Forbidden Patterns
- Do NOT use any in TypeScript
- Do NOT use raw SQL queries (use the ORM)
- Do NOT use console.log in production
## Testing
- Minimum coverage: 80%
- Unit tests for all business logic
- Integration tests for endpoints
## Git
- Commits in conventional commits format
- PR requires at least 1 review
- No force push to mainThe power of automatic onboarding
When a new developer joins the team:
Day 1 — Without a team CLAUDE.md:
1. Clones the repo
2. Reads 20 pages of documentation
3. Asks colleagues how to configure Claude
4. Manually configures their CLAUDE.md
5. Produces inconsistent code for the first 2 weeks
6. Receives feedback in code review
7. Adjusts their configuration
Day 1 — With a team CLAUDE.md:
1. Clones the repo
2. Their Claude Code automatically adopts the rules
3. Produces consistent code from the first commit
Module Objective
By the end of this module you'll be able to:
- ✅ Configure remote control to access Claude Code sessions from other devices
- ✅ Monitor Agent Teams remotely — tasks in progress, completed, failed
- ✅ Design approval flows: which operations require human approval and how to approve them remotely
- ✅ Design a standard team CLAUDE.md with conventions, restrictions, quality gates, and patterns
- ✅ Implement CLAUDE.md merge: project-level + user-level + subdirectory-level without conflicts
- ✅ Configure enforcement: hooks that validate the code respects the CLAUDE.md rules
- ✅ Create an onboarding flow where new members adopt the standard automatically
Professional objective
Remote control + team CLAUDE.md are the features that turn Claude Code into development infrastructure for teams. The tech leads who master this combination don't just automate their own work — they standardize the whole team's. It's the difference between "everyone uses Claude Code however they want" and "our team has a quality standard the agents respect automatically."
Module Roadmap
Capsule map
| # | Capsule | What you'll learn | Type |
|---|---|---|---|
| 01 | Introduction (this one) | Context, remote control + CLAUDE.md mental model, why it matters for teams | Intro |
| 02 | Remote Control Setup | Configuring remote control, connecting devices, monitoring sessions | Technical |
| 03 | Remote Approval Flows | Designing approval gates, approving from mobile, timeouts and security | Technical |
| 04 | CLAUDE.md for Teams | Structure, merge hierarchy, enforcement with hooks, templates | Technical |
| 05 | Project: Team Setup | Complete CLAUDE.md, remote control, approval flows, onboarding — all integrated | Project |
Learning flow
First you'll understand remote control — how to connect devices, monitor active sessions, and see the Agent Teams' state from your phone (capsule 02). Then you'll design approval flows — which operations need human approval, how to approve them remotely, and what happens if no one approves in time (capsule 03). Next you'll learn to design CLAUDE.md as a team standard — structure, merge hierarchy, enforcement with hooks, and production-ready templates (capsule 04). Finally, you'll build a complete team setup that integrates CLAUDE.md + remote control + approval flows + onboarding (capsule 05).
The progression is: monitor remotely → approve remotely → standardize the team → integrate everything.
Each capsule is independent in concept but builds on the previous one in the final project. Capsules 02 and 03 cover remote control. Capsule 04 covers CLAUDE.md. Capsule 05 integrates everything.
Estimated module duration: 1-1.25 hours.
Connection to the Project
Module project: Complete Team Setup
In capsule 05 you'll build a production-ready setup for a team of 3 people:
-
Shared CLAUDE.md — The team's constitution with conventions, restrictions, quality gates, and architectural patterns.
-
Remote control configured — Access from mobile devices to monitor Agent Teams.
-
Approval flows — Destructive operations (force push, database changes) require configurable human approval.
-
Enforcement hooks — Scripts that validate the code respects the CLAUDE.md rules.
-
Onboarding checklist — A documented process for new members to adopt the standard in 5 minutes.
Your team setup:
CLAUDE.md (constitution)
↓
All the agents respect the rules
↓
Hooks validate compliance
↓
Remote control supervises execution
↓
Approval flows protect critical operations
↓
A new member clones the repo → adopts everything automatically
Connection to the final project (Module 8)
In the capstone project, this team setup is the operational foundation of the complete multi-agent system. The CLAUDE.md is the constitution all the agents respect, remote control is how you approve critical operations during execution, and the approval flows are the guardians that protect against destructive operations. Without this module, the capstone project would require constant presence at the terminal and would have no shared standard.
Prerequisites
Required knowledge
- ✅ Modules 1-6 completed — Custom subagents, memory, parallel delegation, Agent Teams, plugins, hooks, SDK
- ✅ Basic and advanced hooks — SessionStart, PreToolUse, PostToolUse, exit codes
- ✅ Basic CLAUDE.md — You've created at least one CLAUDE.md in previous guides
- ✅ settings.json — You know how to configure Claude Code at the project level
- ✅ Git — Commits, branches, pull requests
Quick check
If you can answer "yes" to these questions, you're ready:
- Do you know what a PermissionRequest hook is and when it triggers?
- Have you used CLAUDE.md to give Claude Code instructions?
- Can you configure hooks in
.claude/settings.json? - Do you understand the difference between exit code 0, 1, and 2 in hooks?
- Do you know how to use the headless SDK (
claude -p) from scripts?
You don't need
- ❌ Experience with remote control — covered completely here
- ❌ Experience managing teams — the patterns are explained step by step
- ❌ CI/CD infrastructure — mentioned but covered in another guide
- ❌ A mobile device to start — you can simulate remote control from another terminal
Limits: What Is NOT Covered in This Module
- ❌ Complete CI/CD — Covered in the CI/CD Pipelines guide. Here it's mentioned as an integration
- ❌ Multi-repo CLAUDE.md — A single repo with subdirectories is covered, not multiple synchronized repos
- ❌ Organization administration — Enterprise-level policies are out of scope
- ❌ Remote control over private networks/VPN — Standard connectivity is assumed
- ❌ Developing the remote control SDK — The existing API is used, not a new one built
Evidence of Success
By the end of this module, you'll know you succeeded if:
- ✅ You can connect to an active Claude Code session from another device
- ✅ An approval flow blocks a destructive operation until you approve it
- ✅ You have a CLAUDE.md your whole team uses and that applies automatically
- ✅ Hooks validate that the generated code respects the CLAUDE.md rules
- ✅ A new team "member" can clone the repo and have the complete standard without manual configuration
- ✅ You can explain the CLAUDE.md merge hierarchy and how conflicts are resolved
Quick self-assessment test
If you can answer these questions by the end:
- How do you connect a mobile device to an active Claude Code session?
- What happens when an approval flow has a timeout and no one approves?
- What's the CLAUDE.md precedence hierarchy (global, project, subdirectory)?
- How do you enforce the CLAUDE.md rules with hooks?
- Which files does a new member need to clone to adopt the complete standard?
Summary
- This module teaches the two operational pieces that turn Claude Code from an individual tool into a team tool: remote control (remote supervision) and CLAUDE.md (shared standard)
- Remote control lets you monitor sessions, approve operations, and intervene from any device — it removes the need to be at the terminal
- CLAUDE.md for teams is a shared constitution: conventions, restrictions, quality gates that all the agents respect automatically
- The merge hierarchy (global < project < subdirectory) allows shared rules with room for personal overrides
- Automatic onboarding is key: cloning the repo = adopting the team standard, with no manual configuration
- The module opens Phase 3 (Orchestration) — the bridge between individual automation (Phase 2) and the capstone project (Module 8)
- The project builds a complete team setup: CLAUDE.md + remote control + approval flows + enforcement hooks + onboarding
Additional Resources
- Claude Code Overview (Anthropic Docs) — General context of Claude Code as a system
- Claude Code Settings — CLAUDE.md and settings.json configuration
- Claude Code CLAUDE.md Memory — Official documentation of CLAUDE.md and its levels
- Claude Code Hooks — Hooks for rule enforcement
- Claude Code Best Practices — Best practices for teams
- Claude Code CLI Reference — Flag reference for remote control
- Claude Code Tips and Tricks — Productivity and configuration tips
- Claude Code Subagents — Subagents that respect the team's CLAUDE.md
Next capsule: In capsule 02 you'll configure remote control — how to enable remote access to Claude Code sessions, connect devices, monitor Agent Teams in real time, and supervise long operations without being at the terminal. You'll see the technical setup, the security protocols, and the differences between operating from the terminal vs. operating remotely.