Anthropic upgraded Claude Code Projects on November 13, 2026, and the headline change is simple: the coordinator is now proactive. It answers questions directly in the project chat and posts status updates as its parallel worker threads make progress, instead of waiting for you to ask what is happening.
If you write code with Claude, this changes how you run larger jobs. Instead of babysitting one long session, you describe the work once, and a coordinator splits it across several independent threads that run at the same time. Each thread works on its own copy of the repository and its own Git branch, and the coordinator reviews the results and assembles them.
This guide explains what Projects is, what changed on November 13, who can use it, and how to run it without burning through your plan limits in an afternoon. It also covers the honest limits: the beta is still narrow, and several workflows you might expect are not here yet.
What Claude Code Projects Actually Is
A project is one long-running conversation where Claude coordinates a stream of related work. You describe an outcome — a feature, a refactor, a bug hunt across several files — and the coordinator scopes the request, delegates pieces to threads, tracks every thread it started, and assembles the finished result.
Each thread is a full Claude Code cloud session with its own copy of the repository and its own Git branch. That separation is the whole point. Two threads can work on different parts of the same codebase at the same time without stepping on each other's edits, because their changes live on separate branches until they are reviewed and merged.
A thread can also split its own assignment further, using subagents, loops, and workflows. The coordinator stays in charge of the overall shape: what is done, what is still running, and what came back. You steer from the main chat, and the work keeps going after you close your laptop.
Memory is shared across the project: every thread adds to it and draws from it, so Claude can remember decisions, dates, and working preferences from one thread to the next. A library collects the files you add and the artifacts the threads produce, so new work builds on old work instead of starting from scratch each time.
Projects run on claude.ai/code, in the desktop app, and in the Claude mobile app. They do not run in the terminal CLI, the VS Code extension, or the JetBrains plugin. That is an important boundary if your daily workflow lives in an editor: Projects is a cloud-first workflow, not a terminal one. The Claude Code overview in Anthropic's documentation explains how the cloud sessions underneath Projects work.
Projects also sits on top of Claude Code's tool connections, which run through the Model Context Protocol — the open standard that lets Claude Code talk to external tools and data sources. The coordinator can use those connections, but the threads themselves are what do the work.
The idea is not new to Anthropic's roadmap. Projects have existed in Claude since June 2024 as folders of reference files. The September 17, 2026 redesign, Projects redesigned: from folder to conversation, turned them from a folder into a conversation, and the November 13 update is the first major upgrade to that redesigned version. The announcement put it plainly: projects have threads that do the work, and a coordinator that directs them.
What Changed on November 13
Anthropic's developer account posted a thread of Projects updates at 22:51 UTC on November 13, 2026. The changes all point the same way: less monitoring, more delegation. Here is what arrived.
| Change | What it does |
|---|---|
| Proactive coordinator | Answers questions in the project chat and posts status updates as threads progress, without being asked |
| Read-only thread sharing | Share an individual thread as a read-only link with signed-in Claude users |
| Scheduled reminders | Set a reminder on any thread, or ask Claude to remind you; the thread moves out of the way until then |
| /btw command | Open a side thread for a tangent without derailing the main work |
| /fork command | Branch a new thread from the current one to explore a different approach |
| Recents and artifacts | A row at the top of the threads panel with the threads you recently opened, updated, or pinned |
The proactive coordinator is the change that matters most in daily use. Before this update, the coordinator waited to be polled: you had to ask for a status update. Now it reports in chat as threads finish steps, hit problems, or need a decision. That turns Projects from a system you check into a system that tells you when it needs you.
Read-only thread sharing is the quiet collaboration feature. You can send a teammate a link to one thread so they can read the work without editing it. Threads that had access to a local computer cannot be shared, which is a sensible guard: a thread with machine access may hold credentials or local paths you should not forward.
The /btw and /fork commands were already available in regular Claude Code sessions. Their arrival in Projects brings the same branching workflow to coordinated, multi-thread work. Use /btw when a thought is worth exploring but should not interrupt the main thread, and /fork when you want to try a second approach in parallel and compare the results.
How to Use Projects: A Practical Workflow
Start with a job that genuinely splits. A single-file fix does not need a coordinator. A feature that touches the API, the frontend, and the tests does. The rule is simple: if the work has three or more independent pieces, Projects earns its overhead. If it has one piece, a normal session is faster.
Describe the outcome, not the steps. Tell the coordinator what "done" looks like: the feature, the acceptance criteria, and the tests that must pass. A good brief names the repositories, the branches to work from, and any constraints, such as "do not change the public API" or "keep the existing test suite green". The coordinator's job is to turn that brief into threads.
Let the coordinator pick the split, then check it. After you send the brief, the coordinator scopes the work and starts threads. Read the plan before it gets far: if two threads are about to touch the same file, say so early. Anthropic is explicit that overlap surfaces as an ordinary merge conflict in a pull request, so catching it in the plan is cheaper than resolving it later.
Steer from the chat while threads run. Ask the coordinator for a status update, redirect a thread that went down the wrong path, or pause one piece while you think. Because the coordinator now posts updates on its own, you can leave the tab and come back to a summary of what happened, instead of scrolling through every thread.
Review thread by thread, then merge. Each thread's work lands on its own branch, so review it like any pull request: read the diff, run the tests, and check the result against your brief. The coordinator assembles the finished result, but the final judgement is still yours. Never merge a thread you have not read.
When a thread hands you configuration files or an API response, validate them before you paste them anywhere. A quick pass through the JSON Formatter catches the malformed output agents sometimes produce, and it runs entirely in your browser with nothing uploaded.
The Usage-Limit Trap: Parallel Work Burns Limits Faster
Projects carry no separate fee, but every worker consumes your existing Claude Code allowance. A project can run several full Claude Code sessions at once, and each one draws on the same plan limits as a normal session. That is the single most important thing to understand before you start your first project.
New projects default to Opus for both roles, with high effort for the worker threads and low effort for the coordinator conversation. Opus is the most capable model and the most expensive in usage terms, so a project with four workers can reach your limits several times faster than a single session. Check the project-level usage view Anthropic provides, and consider lowering the effort level for workers on routine tasks.
A thread that hits a usage limit pauses and resumes automatically when the limit resets. That is a safety net, not a plan: a paused thread stops making progress, and a project with several paused threads is just a queue. If you run Projects regularly, watch the usage panel for a week and set a rough budget for how many parallel threads you can afford per day.
The hard cap is 200 new threads per day across all of your projects, according to Anthropic's Projects documentation. Most developers will hit their plan limits long before they hit that cap, but it matters for automated or heavy workflows. Treat threads as a resource: start the ones you need, close the ones you do not, and do not spawn threads speculatively.
Claude Code Projects vs Other AI Coding Assistants
The honest question is not whether Projects is good, but whether it is the right tool for your workflow. Several AI coding assistants now offer parallel agents: GitHub's agent features, Cursor's background agents, and independent multi-agent harnesses all run more than one agent at a time. Projects is Anthropic's version of that idea, built around Claude Code's cloud sessions.
Projects is the best fit when your work already lives in Claude Code's cloud sessions and you want coordination without leaving that world. The coordinator-plus-threads shape, the phone-steerable chat, and the work that continues after you close your laptop are genuinely useful for multi-part features. No other tool in this list ties those three together in quite the same way.
It is the wrong fit in three cases. First, if your workflow lives in the terminal or an IDE, Projects does not run there yet, and switching to the web app just for coordination is a real cost.
Second, Team and Enterprise plans do not have Projects yet, so teams on those plans cannot use it at all. Third, if you need local execution — threads running on your own machine, behind your network, with your local tools — that is still coming, not here.
The fair comparison is against your current workflow, not against a rival's marketing. If you already coordinate several Claude Code sessions by hand, Projects removes real overhead. If you work in one session at a time and rarely split jobs, it adds a layer you do not need. Start with one real feature, measure whether the coordination saved time, and decide from that evidence.
What Still Isn't Here
Local execution is the biggest missing piece. Threads run only in the cloud today. Anthropic says the ability to run them on a local machine, alongside local tools and code and behind your network, is coming very soon. Until it arrives, anything that needs your machine — a local database, an internal service, a private registry — stays outside Projects.
Team and Enterprise plans are still waiting. The beta is open to Pro and Max subscribers, rolling out gradually, and users without access can join a waitlist. Anthropic has given no date for Team and Enterprise, and the same applies to the rest of Claude beyond Claude Code: the new Projects experience reaches chat and Cowork later.
The migration of old Projects is also incomplete. Existing projects on the web or desktop keep working unchanged and will be upgraded as the rollout reaches them. If you used Projects in the last 30 days, Anthropic says you will get an email before the move. There is no way to opt out or delay it that Anthropic has described.
Finally, remember the security habits that do not change with any tool. Projects threads work on copies of your repository, but they still handle your code, your API keys, and your credentials. The same care applies here as in any AI coding session: keep secrets out of prompts and repository files, and review every change before it reaches your main branch.
The Claude Code email leak from earlier this month is a reminder that agent tools can expose more than you expect. Treat thread outputs the same way you treat any unreviewed code: verify first, merge second.
Should You Try It?
If you are on a Pro or Max plan and you already use Claude Code cloud sessions, yes — with one real job, not a toy example. Pick a feature with three or more independent pieces, write a clear brief, and watch how the coordinator splits it. Check the usage panel after the first run so you know what parallel work costs you.
If you are on a Team or Enterprise plan, or your work lives in the terminal, wait. The beta will reach you eventually, and the local-execution update will matter more to your workflow than the coordinator upgrade does. Join the waitlist so you are in the queue, and keep an eye on the Claude Code Projects documentation for the rollout notes.
The broader shift is worth watching regardless of which tool you use. Parallel AI workers are becoming the default shape for coding agents: one coordinator, several workers, each on its own branch. Projects is Anthropic's entry in that race, and the November 13 upgrade makes it meaningfully easier to run. Learn the shape now, and you will recognise it in every tool that follows.
Frequently Asked Questions
What is Claude Code Projects?
Projects is a Claude Code feature where one long-running conversation coordinates development work. A coordinator scopes your request, delegates pieces to parallel threads, and assembles the result. Each thread is an independent Claude Code cloud session with its own copy of the repository and its own Git branch.
What changed in Claude Code Projects on November 13, 2026?
The coordinator became proactive: it answers questions in the project chat and posts status updates as threads progress. Anthropic also added read-only thread sharing links, scheduled thread reminders, /btw and /fork commands, a recents row with artifact thumbnails, and a cap of 200 new threads per day across all projects.
Who can use Claude Code Projects?
It is in public beta for Pro and Max subscribers, rolling out gradually. Users without access can join the waitlist. Team and Enterprise plans do not have it yet. Projects run on claude.ai/code, in the desktop app, and in the Claude mobile app — not in the terminal CLI or the VS Code and JetBrains extensions.
Do parallel workers cost extra?
There is no separate Projects fee, but every worker draws on your existing Claude Code plan limits. Several parallel workers can exhaust those limits faster than a single session. New projects default to Opus with high effort for workers, so check the project-level usage view and lower the effort level for routine tasks.
Is Claude Code Projects the best AI coding tool for parallel work?
It depends on your workflow. It is the strongest choice if you already use Claude Code cloud sessions and want coordination, phone steering, and work that continues after you close your laptop. It is the wrong choice if you work in the terminal or an IDE, or if you are on a Team or Enterprise plan, because Projects does not run there yet. Compare it against your current workflow, not against marketing claims.
Can two threads edit the same file?
They can, but each thread works on its own branch, so the overlap surfaces as an ordinary merge conflict in a pull request. Check the coordinator's plan early and flag files that two threads are about to touch, so you resolve the split in the plan instead of in a merge.
