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
/btw, /fork & AnatomyPart 5
11. Troubleshooting Clinic & Pre-FlightPart 11
6. Background MCP Tasks & Jupyter SyncPart 6
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
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.
- Claude Fable 5.2: Default flagship coding powerhouse with 30% faster generation out of the box, adaptive thinking, and a 1M-token window (
$8/$40per 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/$80per 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
/btwlookups or log scans to Haiku 5.5 for instant pennies-per-run triage.
- Connect Repository & Branch Policy: Link your GitHub or GitLab repo inside a Claude Code Project on
claude.ai/codeor 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 /resumein your local terminal or VS Code extension to pull any cloud worker branch locally, or push local sessions back up to the Session Rail.
/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. |
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.
/fork: expr/redis-pool 5
/btw Side-Thread (Zero Context Pollution) 4
Haiku 5.5 • Read-Only
Claude:
Stripe-Signature (HMAC-SHA256 timestamp + v1 digest). Main thread untouched./rewind • /clear
feat/stripe-v4
Running
test/idempotency
Diff Ready
docker-build-mcp: Container build (72% async)•
jupyter-mcp: Cell #14 synced live to VS Code
.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.
/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.
The 4-Stage Coordinator Dispatch & Reconciliation Flow
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/).
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.
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.
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.
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."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.
/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.
/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.
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.
/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
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. |
/btw, Save Main Memory for Decisions/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.
/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.
- 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.
- Beyond Brittle JSON Edits: Historically, editing
.ipynbfiles as raw JSON stripped cell execution counts or caused merge headaches inside open browser tabs. - Live Kernel + IDE Sync: Pairing
NotebookEditwith 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
/forkwhile keeping baseline notebook checkpoints recoverable via/rewind.
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.
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.
- Smart Classifier Middle Ground: Launch with
claude --enable-auto-mode(or toggle mid-session viaShift+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-setupand inspect baseline policies withclaude auto-mode defaults. Expanded gateway checks intercept indirect prompt injections—stopping untrusted web docs from tricking Claude out of safeWebFetchinto rawcurlshell 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.
- 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 automatedUser-Agentheaders, 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" |
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. |
/fast (2.5x) Only When You Are Actively Pairing/fast during live morning PR diff reviews when human attention is the bottleneck.
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.
- 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.
- 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 |
/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.
CODEOWNERS & Branch Protection10. 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
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.
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.
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.
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.
/fork Paths Archived Out of Active Memory/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.
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
CLAUDE.md & Reminders: Confirm test commands, lint rules, and style conventions live in built-in Project reminders./auto-mode-setup rules and confirm client-identity email guards are active./btw for side lookups, /fork for risky tests, and /clear between milestones.claude doctor if local sync drifts.