Anthropic shipped a Projects update to Claude Code on November 14. It is not a large change, but the direction is unmistakable: instead of you opening threads to see where things stand, the project tells you.

The groundwork was laid in September

Projects was rebuilt in September around a division of labour. You hand the project one task, Claude splits it into independent threads that run in parallel, and the role holding them together is called the coordinator. Ask for a small website and it can put page design in one thread, testing in another and the usage docs in a third, none of them blocking the others.

That is also where the new problem came from. Once threads multiply, keeping up with them becomes the work. The November 14 release mostly addresses that.

Ask for progress in the main thread

You no longer walk the thread list. Ask "where is the testing thread" in the project's main conversation and the coordinator answers with a roll-up across threads. The next change matters more.

You decide when it reports

Tell it the conditions you care about — "only ping me when a task finishes or gets blocked" — and polling becomes a callback. The middle of the work stays quiet; a stall comes to you.

Threads you are not ready to deal with can be parked behind a reminder, for example "remind me to check this at 3pm tomorrow". The thread drops out of the working list, returns at the appointed time, and the coordinator flags it once in the main conversation. For anyone juggling several workstreams, this beats keeping windows open.

/btw and /fork are not the same command

They look alike and do different jobs.

/btw is a side channel. Claude is restyling a site, you think of something unrelated, you type /btw and it opens a separate thread for that question while the original keeps running.

/fork is a branch. You are unconvinced by the current approach and want to try another, so you split a new line of work off the current thread. Both proceed, you keep one.

Short version: /btw handles an unrelated question, /fork explores a second version of the same question. Confuse them and you either muddle the main line or turn a throwaway question into a second main line.

One hard exception on sharing

The thread menu can produce a read-only link, so any signed-in Claude user can read the whole thread without screenshots or pasted transcripts. The exception: a thread that touched your local machine cannot be shared. That restriction is correct — a demo is not worth handing out local paths and file contents.

A smaller addition: recently opened, updated or pinned artefacts now surface together, and each thread carries a thumbnail of what it produced. Once the file count grows, that beats scrolling a transcript.

The cost: quota drains faster

Anthropic said this when the coordinator launched — the coordinator and every executing thread draw on the same allowance. Three parallel threads do not mean three times the speed at one times the cost; they mean three times the consumption, at the same moment.

Three ways to contain it immediately: hold concurrency at two or three threads and queue the rest; keep one-off small edits out of Projects, where a plain session is cheaper; and run execution threads on a cheaper model while the coordinator stays on a strong one. That last split earns its keep — orchestration needs judgement, execution mostly does not.

Who can use it now

The new Projects is rolling out to Claude Pro, Max and similar subscription tiers across web, desktop and the new mobile app, with a waitlist for those who have not been reached. Anthropic has not published a single timetable for Team and Enterprise, so it depends on the account.

A rollout order that works

Do not move your main project in first. Pick something that splits naturally — "add a search page to the existing site" — with one thread on the endpoint, one on the template and one on tests. Then check two things: did the coordinator's reporting actually cut the number of times you had to intervene, and did the quota hold up.

If both pass, migrate the routine work. If either fails, go back to a single thread. More threads is not the goal.