# Claude Code Projects & Proactive Coordinator

> Orchestrating parallel cloud worker branches with Claude Fable 5.2, Opus 5.5, and Haiku 5.5 alongside the Session Rail HUD, /btw and /fork context hygiene, Background MCP tasks, and identity safeguards.

- **Topic:** [Anthropic Claude](https://twelve-pages.com/topics/claude)
- **Web Edition:** https://twelve-pages.com/guides/claude/claude-code-projects-and-coordinator
- **Printable 12-Page PDF:** https://twelve-pages.com/guides/claude/claude-code-projects-and-coordinator/Claude_Code_Projects_and_Coordinator_Complete_How_To_Guide.pdf (2.8 MB)
- **Version:** v1.0 (Updated 2026-11)
- **Reading Time:** 12 minutes (12 pages)
- **Authorship:** AI-authored under human editorial direction & print QA (https://twelve-pages.com/editorial)
- **Tags:** Proactive Coordinator · Parallel Cloud Branches · Fable 5.2 • 2.5x Fast Mode · /btw • /fork • /rewind · Session Rail HUD · Background MCP & Jupyter

## Core Takeaways

- **Coordinated Cloud Fleet:** Dispatch full cloud Claude Code workers across isolated repository copies and Git branches while one parent coordinator reconciles diffs.
- **Zero-Pollution Context:** Spin off side questions with /btw, explore competing implementations with /fork, and roll back cleanly via /rewind or /clear.
- **Non-Blocking & Guarded:** Track subagents in the Session Rail HUD, run async Background MCP tasks, sync Jupyter cells live, and lock down client-identity leaks.

## 1. From Static Context Folder to Proactive Engineering Hub

Earlier versions of Projects acted like passive filing cabinets holding pinned docs while you drove every coding step by hand. In November 2026, Anthropic transformed Claude Code Projects into a cloud-backed multi-agent workspace—led by a Proactive Coordinator that plans, delegates, monitors, and reconciles work across parallel branches automatically.

### Quick Navigation

### Core Mental Model: One Parent Brain, Isolated Cloud Workers

Instead of cramming five unrelated tasks into a single linear terminal thread, you converse with one **Parent Coordinator** anchored to your repository and built-in Project reminders. When a request splits naturally—such as updating backend billing routes, building React checkout components, and writing Playwright regression tests—the Coordinator dispatches full cloud Claude Code workers onto separate repository clones and Git branches, powered by **Claude Fable 5.2**, **Opus 5.5**, and **Haiku 5.5**.

### Architecture: Coordinated Multi-Branch Cloud Execution

#### Why Cloud Isolation Eliminates Broken Local Working Trees

Because every cloud worker runs inside its own repository clone on a dedicated Git branch, closing your laptop never interrupts overnight builds, and Worker A can rewrite your database layer without breaking Worker B's UI test runner.

## 2. Model Tiers, Cloud Setup & Coordination Decision Matrix

Pairing the right Claude model tier with the right execution pattern keeps multi-agent engineering blazingly fast without burning through your context or rate limits. Use the setup guide and comparison matrix below to pick the cleanest surface for every task.

#### 1 November 2026 Model Lineup & Fast Mode

- **Claude Fable 5.2:** Default flagship coding powerhouse with **30% faster generation** out of the box, adaptive thinking, and a 1M-token window (`$8/$40` per M input/output tokens).
- **Optional 2.5x Fast Mode (`/fast`):** Dedicated high-throughput pool boosting streaming output tokens per second by up to **2.5x** on Fable 5.2 or Opus 5.5 (`$16/$80` per M tokens) for rapid live pairing and PR reconciliation.
- **Opus 5.5 & Haiku 5.5:** Use **Opus 5.5** for deep Coordinator architecture planning, and route lightweight `/btw` lookups or log scans to **Haiku 5.5** for instant pennies-per-run triage.

#### 2 Activating Projects, Sync & Reminders

- **Connect Repository & Branch Policy:** Link your GitHub or GitLab repo inside a Claude Code Project on `claude.ai/code` or Desktop; each worker checks out an isolated clone automatically.
- **Pin Project Reminders & `CLAUDE.md`:** Store build commands, coding standards, and built-in project reminders once so every Coordinator and child worker inherits them silently.
- **Terminal & VS Code Continuity:** Run `claude /resume` in your local terminal or VS Code extension to pull any cloud worker branch locally, or push local sessions back up to the Session Rail.

#### Quick CLI & Desktop Commands to Launch & Steer

`/model fable` (switch to Fable 5.2) • `/fast` (toggle 2.5x speed) • `/btw <question>` (side thread) • `/fork [label]` (branch experiment) • `claude --enable-auto-mode` (classifier safety)

### Execution Decision Matrix: Coordinator vs. /goal Loops vs. Local Worktrees

| Execution Surface | Workspace & Isolation | Supervision Rhythm | Laptop / Offline Behavior | Best Used When |
| --- | --- | --- | --- | --- |
| **Projects + Proactive Coordinator** | **Cloud Clones + Git Branches:** Separate isolated repo copy per worker. | **Proactive Parent Thread:** Auto-pushes updates, answers questions & reconciles diffs. | **Runs Unattended:** Works overnight in Anthropic cloud while laptop sleeps. | Multi-module features, backend + UI + test parallel splits & PR prep. |
| **Single-Repo `/goal` Loops** | **Single Working Tree:** One local or cloud checkout guarded by an exit contract. | **Neutral Evaluator Check:** Independent verifier returns `PASS` or `ITERATE` per turn. | Local CLI stops on sleep; cloud sessions continue to turn cap. | Strict test-until-green refactors, single-package migrations & lint sweeps. |
| **Local `--worktree` Fleet (`claude agents`)** | **Local Git Worktrees:** Shared `.git` object store on your local disk. | **Manual / Fleet Dashboard:** You monitor worktree panes and merge locally. | **Tied to Local Machine:** Pauses if laptop sleeps or loses power. | Tasks needing local Docker DBs, macOS Xcode simulators, or hardware USBs. |
| **Standard Single Chat** | **Direct Directory:** Single conversation editing active branch directly. | **Turn-by-Turn Pairing:** Interactive step-by-step confirmation with user. | Interactive foreground session in CLI, VS Code, or Desktop. | Quick bug fixes, code exploration, or 1–2 file surgical patches. |

#### Power Pattern: Combine Proactive Coordinator With Bounded Task Contracts

Treat your Coordinator like a staff tech lead: ask it to dispatch three parallel cloud branches, and give each branch an explicit verification gate (such as `pytest -q` and `tsc --noEmit`) so workers self-verify before notifying the parent thread.

## 3. Annotated Tour: Session Rail HUD & Coordinated Studio

Inside Claude Code Desktop, VS Code, and claude.ai/code, the unified Project Studio pairs your conversational Coordinator on the left with the live Session Rail HUD on the right—tracking workers, context meters, and async MCP jobs in real time.

Billing-Core-v3 • Coordinator (Fable 5.2 • 2.5x)

Diagnostic Link Auto-Mode + ID Guard

Coordinator Thread • Reminders On `/fork`: expr/redis-pool

**Proactive Coordinator Update:** Dispatched 2 parallel cloud workers on isolated branches. Worker B finished idempotency tests (18/18 green); Worker A hit a Stripe webhook signature mismatch and proposes rotating the test fixture secret. Approve reconciliation?

**`/btw` Side-Thread (Zero Context Pollution)** Haiku 5.5 • Read-Only

**You:** "Remind me which header Stripe webhooks expect in v2026?"
**Claude:** `Stripe-Signature` (HMAC-SHA256 timestamp + v1 digest). Main thread untouched.

> Reconcile Worker A + B diffs into PR #412 & link trace `/rewind` • `/clear`

**Session Rail HUD** Ctx: 38% / 1M

**Worker A • `feat/stripe-v4`** Running

Cloud VM • 4 files edited • Awaiting fixture check

**Worker B • `test/idempotency`** Diff Ready

18/18 Playwright & pytest green • Zero conflicts

**Background MCP & Jupyter** Non-Blocking

• `docker-build-mcp`: Container build (72% async)
 • `jupyter-mcp`: Cell #14 synced live to VS Code

**Proactive Coordinator Stream:** Parent thread scopes work, dispatches parallel cloud branches, surfaces alerts early, and answers questions mid-run.

**Session Rail HUD:** Side-panel command center showing active subagent states, branch names, built-in Project reminders, and context window percentage.

**Background MCP & Jupyter Tray:** Executes slow MCP builds, migrations, and live Jupyter `.ipynb` cell sync asynchronously without freezing chat.

**`/btw` Zero-Pollution Side Drawer:** Spawns an isolated side question thread that reads project context without cluttering the active Coordinator history.

**`/fork` Branch Switcher:** Forks your active conversation at any step to test divergent architectures safely without losing your baseline path.

**Read-Only Diagnostic Link:** Generates a shareable view-only trace URL so teammates inspect logs and tool outputs safely with zero write risk.

**Auto-Mode Gateway & Client-Identity Guard:** Background classifier evaluates tool calls against `/permissions` rulesets while blocking personal account email injection or spoofing in scripts, fetches, and MCP headers.

## 4. Proactive Coordinator & Parallel Branch Reconciliation

Instead of manually juggling five terminal tabs and copying diffs by hand, the Proactive Coordinator acts as your automated tech lead—fanning tasks across isolated cloud Claude Code sessions and bringing cleanly reconciled branches back to one thread.

*[Illustration: Isometric Graphite-Olive Studio Diagram Showing a Central Coordinator Core Dispatching Three Parallel Luminous Branch Conduits Across Isolated Workspace Cubes Into a Unified Verification Arch]*

**Fan-Out to Isolated Branches, Converge at Verification:** Each cloud worker gets its own repository clone and dedicated Git branch so parallel builds never collide on disk before branch diff reconciliation.

### The 4-Stage Coordinator Dispatch & Reconciliation Flow

#### 1 Task Scoping & File Partitioning

Read your Project specs and ask the Coordinator to split work into non-overlapping modules (for example: Worker A owns `src/api/billing/`, Worker B owns `src/components/checkout/`, Worker C owns `tests/e2e/`).

#### 2 Full Cloud Worker Sessions

Every dispatched worker is a complete cloud Claude Code instance—not a toy text helper. It reads files, runs compilers, executes Playwright or unit tests, and commits checkpoints to its own Git branch.

#### 3 Proactive Progress & Q&A Loop

Workers notify the parent Coordinator whenever a milestone finishes or a spec ambiguity appears. You answer once in the main thread, and the Coordinator relays your decision directly to the blocked worker.

#### 4 Branch Aggregation & PR Conflicts

Once workers pass local checks, the Coordinator aggregates branch diffs into a unified review. If two workers touched the same shared interface, overlaps surface as standard Git PR merge conflicts for crisp resolution.

```
<code>Coordinator Dispatch Example (Claude Code Project — Fable 5.2):
"Split our Stripe Subscription Pause feature across 3 parallel cloud workers on isolated branches:
1) Worker A (feat/pause-api): Add POST /v1/subscriptions/pause + webhook handler in src/api/billing/. Run pytest -k billing.
2) Worker B (feat/pause-ui): Build PauseModal.tsx in src/ui/settings/ matching our Design tokens. Run npm run typecheck.
3) Worker C (test/pause-e2e): Write Playwright happy-path & double-click idempotency specs once A & B expose route types.
Push proactive updates only on blockers or test completion, then reconcile branch diffs into one staging PR."</code>
```

#### Pro Tip: Partition Shared Interfaces First to Avoid Merge Conflicts

When two workers depend on one TypeScript interface or OpenAPI schema, have Worker A lock and commit the contract file first (or define it in your parent prompt) before Worker B and Worker C branch out.

## 5. Context Hygiene: /btw, /fork, /rewind & Directive Anatomy

Multi-hour coding sessions fail when tangential questions, dead-end refactors, and raw stack traces pollute the Coordinator’s context window. Keep your primary timeline razor-sharp with four dedicated context-hygiene controls.

#### 1 `/btw` Zero-Pollution Side Threads

Need to ask *"What flag resets Alembic migrations?"* without derailing an active multi-branch build? Type `/btw <question>`. Claude spins an ephemeral side thread using read-only Project awareness and answers instantly—leaving zero tokens inside your Coordinator or worker history.

#### 2 `/fork` Divergent Experiments

Want to test Redis caching vs. SQLite edge caching without ruining a clean working thread? Run `/fork` to branch the conversation at the current checkpoint, benchmark both approaches side by side in the Session Rail, and keep only the winning branch.

#### 3 Project Reminders & Diagnostic Links

Pin **built-in Project reminders** so rules like *"always run uv test before commit"* survive resets automatically. When a worker hits a tricky failure, generate a **read-only diagnostic thread link** so teammates can inspect logs safely without touching your repo.

#### 4 `/rewind` & `/clear` Policy Recovery

Press `Esc` twice or run `/rewind` to revert both chat turns and native file-edit snapshots cleanly (remember: raw shell/bash side effects require Git reset). Between finished epics, run `/clear` to wipe stale history while automatically keeping `CLAUDE.md` policies intact.

### The 5-Part Coordinated Project Prompt Anatomy

[1. Scope & Model Tier] Using `Fable 5.2` inside Project `Payments-v3` (honoring pinned `CLAUDE.md` reminders), [2. Parallel Branch Split] dispatch Worker A on `feat/invoice-pdf` and Worker B on `test/invoice-pdf` across isolated cloud clones. [3. Context Hygiene Rule] Keep exploratory API checks inside `/btw` threads and run `/fork` before altering shared schemas. [4. Async MCP / Jupyter] Execute container builds via Background MCP tasks and sync evaluation metrics back to `eval.ipynb`. [5. Safety & Reconcile Gate] Enforce Auto-Mode gateway + email-identity lock, run full tests, and reconcile diffs into one PR with a read-only diagnostic link.

| Directive Component | What It Controls in the Workspace | Failure Mode When Omitted |
| --- | --- | --- |
| Scope & Model Tier | Pins model speed/cost (`Fable 5.2`, `Opus 5.5`, `Haiku 5.5`) & Project context. | Coordinator burns flagship Opus tokens on trivial lookups or ignores repo conventions. |
| Parallel Branch Split | Assigns explicit non-overlapping directory ownership and Git branch names. | Workers edit identical files concurrently, causing noisy PR merge conflicts. |
| Context Hygiene Rule | Routes tangents to `/btw`, risky experiments to `/fork`, and resets via `/clear`. | 1M context fills with irrelevant side debugging, degrading instruction recall. |
| Async MCP / Jupyter | Detaches slow builds and live `.ipynb` runs into non-blocking Session Rail tasks. | Chat stalls for minutes waiting on Docker builds or corrupts notebook JSON metadata. |
| Safety & Reconcile Gate | Locks Auto-Mode classifier rules, client-identity privacy, and final merge gates. | Unverified code lands early or shell scripts leak user metadata in HTTP headers. |

#### Context Discipline Rule: Keep Tangents in `/btw`, Save Main Memory for Decisions

Treat your primary Coordinator thread like shared engineering meeting minutes. Every lookup asked via `/btw` disappears cleanly without diluting instruction recall, while `/clear` resets finished milestone clutter while keeping pinned Project reminders active.

## 6. Background MCP Tasks & Live Jupyter Notebook Cell Sync

Slow integration test suites, warehouse exports, and interactive data notebooks no longer hold your terminal hostage. Background MCP routing and real-time Jupyter cell sync let engineering and data exploration run smoothly side by side.

*[Illustration: Minimalist Dark Olive-Slate Studio Composition Showing a Luminous Lime Main Workflow Spine Branching Into an Isolated Side Prism and Parallel Fork Crystal Flanked by Asynchronous Pulse Rings and Segmented Progress Bars]*

**Clean Branching & Non-Blocking Execution:** Side investigations (`/btw`) and divergent forks (`/fork`) stay cleanly separated from the main timeline while Background MCP tasks stream live progress rings to the Session Rail HUD.

#### 1 Background MCP Tasks (Non-Blocking)

- **Automatic Async Offload:** When a connected MCP server triggers a long-running operation—such as a cloud container build, BigQuery warehouse export, CI test matrix, or game-engine asset import—Claude Code moves it to the **Background MCP Tray** inside the Session Rail HUD.
- **Keep Coding While It Runs:** Your local terminal, VS Code editor, and Coordinator chat stay completely responsive so you can review diffs, answer worker questions, or edit docs in parallel.
- **Completion Notification:** Once the MCP job resolves, the Coordinator receives a concise summary payload and resumes the dependent step automatically.

#### 2 Jupyter Notebook Cell Sync & Kernels

- **Beyond Brittle JSON Edits:** Historically, editing `.ipynb` files as raw JSON stripped cell execution counts or caused merge headaches inside open browser tabs.
- **Live Kernel + IDE Sync:** Pairing `NotebookEdit` with IDE/JupyterLab session-rail extensions and the **Jupyter MCP server** lets Claude attach directly to your running IPython kernel, execute targeted cells, inspect pandas frames or tracebacks, and hot-sync updated cell outputs straight into VS Code or JupyterLab.
- **Safe Branch Testing:** Fork ML experiments with `/fork` while keeping baseline notebook checkpoints recoverable via `/rewind`.

#### Golden Habit: Keep Background MCP Logs Compact

Configure custom MCP servers and build wrappers to return structured summaries (status, duration, artifact URL, and the final 20 lines of any failure trace) rather than streaming 10,000 lines of raw compiler noise back into the Coordinator thread. Use `read-only diagnostic links` whenever a teammate needs to inspect the full verbose build trace.

#### Seamless VS Code & JupyterLab Extension Pairing

Open the Claude Code Session Rail right inside VS Code or JupyterLab: click any cell or diff hunk in your editor to anchor a Coordinator task, watch Background MCP jobs tick down in the side rail, and inspect live notebook plots without switching windows.

## 7. Expanded Auto-Mode Gateway & Client-Identity Safeguards

Giving autonomous cloud workers and MCP tools room to move fast requires guardrails that stop dangerous commands and block subtle privacy leaks. November 2026 releases pair expanded Auto-Mode gateway policies with strict client-identity protections.

#### 1 Expanded Auto-Mode Gateway Controls

- **Smart Classifier Middle Ground:** Launch with `claude --enable-auto-mode` (or toggle mid-session via `Shift+Tab`). Instead of approving every trivial read or running completely unchecked, a background safety classifier audits each tool call before execution.
- **Gateway Rules & Tool Escalation Blocks:** Tune project rules via `/auto-mode-setup` and inspect baseline policies with `claude auto-mode defaults`. Expanded gateway checks intercept indirect prompt injections—stopping untrusted web docs from tricking Claude out of safe `WebFetch` into raw `curl` shell scripts.
- **Soft vs. Hard Denials:** Routine workspace tests auto-approve cleanly, risky commands pause for explicit human review, and forbidden operations hard-fail with clear audit explanations.

#### 2 Client-Identity & Email Leak Safeguards

- **Why It Matters (`v2.1.325+`):** Earlier coding harnesses injected the signed-in user's account email into prompt context, causing models to inadvertently embed personal emails inside automated `User-Agent` headers, API calls, or generated scripts.
- **Hard Identity Boundary:** Current Claude Code builds actively scrub personal account emails from model context and **block using user account emails as client identity** across shell scripts, web fetches, file writes, and outbound MCP requests.
- **Clean Telemetry & Attribution:** Enterprise gateways use organization-assigned service headers or explicit Git author settings—never leaking private developer emails to third-party servers.

### Runtime Safety Controls Reference Matrix

| Safeguard Mechanism | What It Inspects / Governs | Threat or Mistake Prevented | Operator Command / Location |
| --- | --- | --- | --- |
| **Auto-Mode Classifier** | Shell commands, file mutations, package installs & tool chains. | Accidental `rm -rf`, force-pushes, or hidden prompt-injected payloads. | `/auto-mode-setup` & `Shift+Tab` |
| **Gateway Egress Rules** | Outbound URL domains, `WebFetch` vs. raw network tools & MCP hosts. | Data exfiltration or fetching untrusted executable scripts from arbitrary sites. | `/permissions` & `claude auto-mode defaults` |
| **Client-Identity Privacy Lock** | Outbound HTTP headers, scripts, file writes & MCP request metadata. | User account email leakage, spam correlation, or spoofed client identity headers. | Built-in (`v2.1.325+`) & Privacy Guard |
| **Read-Only Scoped Flags** | Whitelist of permitted tools during audits (`Read`, `Grep`, `Glob`). | Unintended edits when running architecture reviews or incident diagnostics. | `--allowedTools "Read" "Grep"` |

#### Security Reality Check: Auto-Mode Is a Policy Classifier, Not a VM Sandbox

Always remember the boundary: Auto-Mode classifiers dramatically reduce risk for everyday repos, yet they do not replace OS/container isolation. Keep untrusted third-party code inside cloud Claude Code worker VMs and store real OAuth tokens inside Vault-backed remote MCP servers rather than local shell environment files.

## 8. 5 Real-World Copy-Paste Project & Coordinator Recipes

Use these concrete, ready-to-run prompts and slash-command flows inside any connected Claude Code Project to dispatch cloud worker branches, isolate side investigations, and reconcile verified code cleanly.

| Recipe & Use Case | Exact Copy-Paste Prompt or Command Sequence | What Happens & Deliverable |
| --- | --- | --- |
| **1. Parallel API + UI + E2E Fan-Out** *Multi-Branch Feature* | `Launch 3 parallel cloud workers on isolated branches for Webhook Retries: Worker A (feat/retry-queue) owns src/jobs/, Worker B (feat/retry-ui) owns src/components/webhooks/, Worker C (test/retry-e2e) builds Playwright specs. Run Fable 5.2, message me only on blockers or test results, then reconcile diffs into one PR.` | 3 concurrent cloud clones build, test, and push clean commits; Coordinator reconciles one unified PR diff. |
| **2. Zero-Pollution Mid-Flight Lookup** *`/btw` + Haiku 5.5* | `/btw Using Haiku 5.5, check whether src/db/pool.ts sets statement_timeout in milliseconds or seconds, and list the two callers that override it—do not modify files or append to main Coordinator context.` | Opens a crisp side drawer with exact file references while keeping your main Coordinator window 100% clean. |
| **3. Safe Dual-Architecture Benchmark** *`/fork` + Opus 5.5* | `/fork exp-in-memory-lru "Implement the rate-limiter cache using an in-memory LRU without external Redis calls, run k6 load script, and report p99 latency and memory footprint so I can compare against our Redis main thread."` | Branches a side-by-side experiment in the Session Rail; merge only the winning architecture and discard the loser. |
| **4. Background MCP + Live Jupyter Loop** *Async Build & Data* | `Start our staging Docker build via Background MCP (docker-build-mcp) asynchronously. While that runs in the Session Rail tray, attach to the active Jupyter kernel via jupyter-mcp, re-run cells 8-14 in notebooks/churn_eval.ipynb, fix any schema mismatch, and sync updated outputs to VS Code.` | Long Docker build executes non-blocking while Claude fixes and syncs live notebook cells in real time. |
| **5. Atomic Recovery & Team Handoff** *`/rewind` + Diagnostic Link* | `/rewind to checkpoint before the auth middleware refactor. Generate a read-only diagnostic thread link explaining why the token mock failed, verify Auto-Mode identity guards block personal emails in scripts, then run /clear to reload clean Project reminders for the next sprint.` | Cleanly restores file snapshots, exports a safe view-only debug link for teammates, and resets context fresh. |

#### Speed Tip: Toggle `/fast` (2.5x) Only When You Are Actively Pairing

Keep standard Fable 5.2 (already 30% faster) for unattended overnight worker branches, then toggle `/fast` during live morning PR diff reviews when human attention is the bottleneck.

#### Context Discipline: Move Repeating Rules Into Project Reminders

Notice yourself typing *"don't forget Prettier and vitest"* in every prompt? Pin it once inside built-in Project reminders and `CLAUDE.md` so every spawned worker obeys automatically.

## 9. Team Collaboration, Enterprise Governance & Safety Matrix

Scaling Claude Code Projects from solo hacker sessions to an engineering organization means giving teammates transparent visibility without exposing secrets, risking accidental branch edits, or bypassing compliance gateways.

#### 1 Read-Only Diagnostic Thread Links

- **Safe Asynchronous Debugging:** Share a **read-only diagnostic link** directly inside Slack, Linear, or GitHub PR comments so peers can inspect exact tool inputs, worker timelines, and test failures without mutating your branch.
- **Zero Secret Exposure:** Diagnostic views strip raw Vault tokens and honor client-identity email redaction automatically before teammates open the trace.
- **Cross-Role Visibility:** Security reviewers and SREs can verify how an autonomous worker validated a migration without needing local IDE setup.

#### 2 Enterprise Policy & Gateway Controls

- **Org-Wide Auto-Mode Templates:** Platform teams publish centralized JSON rulesets constraining allowable shell patterns, package registries, and network domains across all repositories.
- **Zero Model Training Guarantee:** On Team and Enterprise plans, Project source files, Coordinator threads, and worker branch diffs are never used for model training.
- **Cloud Sovereign Routing:** Enterprise orgs can pin Coordinator and cloud worker inference to Anthropic Enterprise, AWS Bedrock, Google Cloud Vertex AI, or Microsoft Foundry endpoints.

### Collaboration & Governance Matrix Across Tiers

| Capability / Policy | Pro & Max Plans | Team Plan | Enterprise Plan |
| --- | --- | --- | --- |
| **Cloud Coordinator & Workers** | Full personal cloud branches & Session Rail HUD | Shared team Projects, PR links & branch sync | Org-governed cloud pools, VPC & quota routing |
| **Fable 5.2 & 2.5x Fast Mode** | Fable 5.2 + opt-in `/fast` usage pool | Org toggle for Fast Mode & model selection | Admin-governed tier budgets & Bedrock/Vertex |
| **Auto-Mode & Identity Guard** | Local/cloud classifier + built-in email privacy lock | Shared Project `/permissions` & identity lock | Enforced gateway rulesets + SIEM audit stream |
| **Diagnostic Thread Links** | Personal snapshot links & local export | Workspace-authenticated read-only links | SSO-gated read-only traces + retention policy |

#### Critical Recovery Boundary: Understand What `/rewind` Can and Cannot Undo

`/rewind` (or `Esc + Esc`) atomically reverts conversation messages and edits made through Claude's native file tools (`Edit`, `Write`, `NotebookEdit`). However, it **cannot undo external shell side effects** (such as `sed -i` scripts, database drops, or external API POSTs). Run risky experiments inside isolated cloud worker branches where discarding a bad branch costs zero cleanup.

#### Pair Shared Projects With `CODEOWNERS` & Branch Protection

Let cloud Coordinator workers open draft pull requests freely while keeping GitHub branch protection rules mandatory—ensuring CI checks and human approval remain the final production merge gate.

## 10. Cross-Tool Synergy: From Spec to Reconciled Production PRs

Claude Code Projects acts as the execution hub of the broader Anthropic workspace—turning spatial roadmaps from Claude Whiteboards and Design specs into coordinated parallel branches verified by Claude Security and remote MCP tools.

### End-to-End Engineering Rhythm in Four Moves

#### 1 Feed Specs From Design & Whiteboards

Export your finalized PRD from **Claude Whiteboards** or component tokens from **Claude Design** directly into your Project knowledge base and pin build checks inside Project Reminders.

#### 2 Fan Out Parallel Cloud Workers

Let the Coordinator run backend, frontend, and test branches simultaneously using **Fable 5.2** while you field tangential questions in `/btw` and benchmark risky ideas via `/fork`.

#### 3 Offload Heavy Tooling to Async MCP

Run slow database migrations, container builds, and live **Jupyter notebook** cell experiments via Background MCP tasks monitored in the Session Rail HUD without blocking active coding.

#### 4 Reconcile, Security-Scan & Ship

Reconcile worker branch diffs into one staging PR, query the **Claude Security MCP** connector to verify zero regressions against your threat model, and attach a read-only diagnostic link.

#### Keep Losing `/fork` Paths Archived Out of Active Memory

Once a `/fork` experiment answers your architectural question, summarize the decision in two lines inside `CLAUDE.md` and close the unused branch so future workers never confuse rejected experiments for live specs.

#### Pin Merged Decisions Back Into Your Project Knowledge Base

Whenever a reconciled PR introduces a new API route, database migration convention, or MCP tool rule, update your Project Reminders and `CLAUDE.md` right away so the next wave of parallel cloud workers starts with ground truth.

## 11. Troubleshooting Clinic & Coordinator Pre-Flight

Use this diagnostic reference whenever parallel workers hit merge conflicts, async MCP tasks stall, or safety policies trigger unexpected blocks—followed by our 6-point checklist before launching multi-branch sprints.

| Symptom / Issue | Root Cause | 10-Second Fix |
| --- | --- | --- |
| **1. Two cloud workers triggered PR merge conflicts on the same file** | Parallel worker slices both modified a shared types or router file simultaneously. | Inspect the surfaced PR conflict markers with the Coordinator to merge cleanly; next time, lock shared contracts in Worker A before fanning out. |
| **2. Coordinator forgot earlier rules mid-session after side questions** | Tangential debugging cluttered the primary thread instead of staying isolated. | Always ask quick off-track questions using `/btw`, pin durable rules inside Project Reminders, and run `/clear` between completed epics. |
| **3. `/rewind` reverted file edits, but script/database side effects stayed** | `/rewind` restores chat turns and native file-tool snapshots, not raw bash actions. | Run risky experiments in isolated cloud worker branches (discarding failed branches cleanly) or revert shell edits with standard `git reset`. |
| **4. Long Docker build or warehouse MCP call froze my terminal turn** | Legacy blocking MCP config waited synchronously instead of detaching async. | Enable Background MCP Task routing (`v2.1.319+`) so heavy tool calls move to the Session Rail tray while terminal/VS Code work continues. |
| **5. Jupyter notebook edits dropped cell outputs or conflicted in VS Code** | Claude patched raw `.ipynb` JSON while the browser/IDE kernel held stale state. | Connect the **Jupyter MCP server** and IDE session-rail sync so Claude executes cells directly on the live kernel and syncs outputs cleanly. |
| **6. Auto-Mode blocked a safe script or flagged an outbound HTTP header** | Classifier flagged shell escalation or privacy guard detected a user email string. | Tune rules via `/auto-mode-setup` & `/permissions`, and remove personal emails from `User-Agent` headers or script flags (`v2.1.325+`). |
| **7. Fast Mode quota burned faster than expected on background tasks** | `/fast` (2.5x speed at `$16/$80`) stayed active during unattended worker sweeps. | Toggle `/fast` off for background cloud workers (standard Fable 5.2 is already 30% faster) and route `/btw` lookups to **Haiku 5.5**. |

### 6-Point Coordinator Pre-Flight Checklist

✓

**1. Pin `CLAUDE.md` & Reminders:** Confirm test commands, lint rules, and style conventions live in built-in Project reminders.

✓

**2. Partition Branch Ownership:** Assign explicit non-overlapping directories to each parallel worker before dispatching.

✓

**3. Calibrate Auto-Mode & ID Lock:** Verify `/auto-mode-setup` rules and confirm client-identity email guards are active.

✓

**4. Route Slow Tools Async:** Confirm heavy builds, CI runners, and Jupyter kernels use Background MCP inside the Session Rail.

✓

**5. Keep Context Spotless:** Use `/btw` for side lookups, `/fork` for risky tests, and `/clear` between milestones.

✓

**6. Reconcile & Share Proof:** Review unified branch diffs, attach a read-only diagnostic link, and run `claude doctor` if local sync drifts.

#### Final Takeaway: Orchestrate Across Branches, Keep One Thread Crystal Clear

The magic of November 2026 Claude Code Projects lies in pairing parallel power with conversational calm: cloud workers build and test on isolated branches, Background MCP handles heavy lifting in the Session Rail, and your Parent Coordinator brings home clean, verified pull requests.

---

## Edition Note & Attribution

This 12-page handbook, its topic structure, and its illustrations were generated with AI under human editorial direction and print-layout QA. Verify commands, pricing tiers, and security settings against official vendor documentation before production use.

- AI & Editorial Disclosure: https://twelve-pages.com/editorial
- Terms & Licensing: https://twelve-pages.com/terms
- Privacy & Cookie Notice: https://twelve-pages.com/privacy
