Claude Code Projects (beta, September 2026) lets one project conversation coordinate multiple parallel cloud sessions -- called threads -- that share repositories, memory, and a file library. You describe what needs doing; Claude splits the work, runs threads in parallel, and keeps going after you close your laptop. Available now to select Pro and Max users.
I've been watching this roll out since September 17 and the concept is genuinely different from how Claude Code has worked until now. It's not just "run multiple sessions." It's a coordinator model where the project conversation handles routing and memory so you don't have to.
What exactly is a Claude Code Project?
A Claude Code Project is one ongoing conversation that acts as a coordinator, spawning parallel cloud sessions -- threads -- that each handle a piece of work. Every thread starts with shared repositories, instructions, and memory. The coordinator routes tasks, tracks state, and surfaces what needs your attention in the Overview pane.
The official docs spell out the distinction from claude.ai Projects: "Claude Projects help Claude remember the context you gave it. Claude Code Projects are designed to help Claude remember and coordinate the work it is doing." Context vs. coordination -- that's the architectural split that makes the two features different tools for different problems.
Three things are shared automatically across every thread a project spawns:
- Repository access (all GitHub repos you connected to the project)
- Project instructions and memory (rules, decisions, standing context)
- CLAUDE.md files and skills from each connected repository
One rule stated once -- "always target the develop branch, never push directly to main" -- propagates to every new thread without you repeating it. That's the core value the coordinator model delivers for any work spanning more than one session or repository.
How do parallel threads actually work?
Each thread in a Claude Code Project is an independent cloud session: Claude Code running on Anthropic's infrastructure, not on your machine. Threads run simultaneously, each on its own git branch, and open pull requests when the work calls for one. The coordinator sees what threads report back, not every step they take -- it tracks state, not execution.
The Overview pane is your control surface. It shows threads sorted by state: "Ready for review" (PRs open and waiting), "Waiting on you" (thread hit a decision point it can't resolve on its own), and "Working" (still running). You can steer individual threads from the Claude mobile app on iOS and Android -- no laptop required to unblock a thread that's waiting on a judgment call.
In practice: paste a batch of tasks into the project conversation, optionally tell Claude to start without asking for confirmation, and walk away. When you're back, the Overview shows which PRs are ready, which threads need an answer, and which are still running. The Library tab collects every artifact threads produced -- generated files, write-ups, specs -- for retrieval and for future threads to build on.
A concrete use case from the official docs: "One goal across many repositories. Bring every service up to the new lint config." Claude runs one thread per repository, each opening its own pull request. Without a project you'd be managing those sessions individually, re-explaining the lint config to each one. With a project, one standing instruction in project memory handles it across all threads.
How shared project memory works
Shared project memory is a standing context every new thread starts with automatically. You define it in project instructions -- rules, constraints, architectural decisions, anything that should apply to all threads. When a thread discovers something worth remembering (a bug pattern, a breaking change, a naming constraint), you tell Claude to log it to project memory so the next thread inherits it.
This is the part that changes how long-running work actually feels. Say you're migrating a monorepo across 8 services to a new ORM. Thread 1 hits a quirk with the legacy transaction wrapper. You tell Claude: "Add to project memory: transactions in this codebase use the legacy wrapper in utils/db.py, not standard ORM syntax." Threads 2 through 8 all start with that knowledge -- no retelling, no relearning the same edge case.
The project conversation itself is the coordinator's persistent view. Every thread reports back to the same conversation when it finishes, so the coordinator sees the full picture of what's done, blocked, or waiting. Decisions you add early in a migration are still there for threads you spin up days later. Context doesn't reset between sessions the way a standalone cloud session would.
Want the templates from this tutorial?
I share every workflow, prompt, and template inside the free AI Creator Hub on Skool. 500+ builders sharing what actually works.
Join Free on Skool
How to set up your first Claude Code Project
Setting up a project requires a Pro or Max plan, code on github.com, and the Claude GitHub App installed on your repositories. Go to claude.ai/code, click Projects in the sidebar, then New project. Only the project name is required to start -- you add repositories, instructions, and a goal as the work takes shape.
The full setup flow:
- Name the project -- scope it to one stream of work ("API latency fixes", "ORM migration", "lint rollout across services")
- Add a goal (optional but worth doing) -- one line Claude works toward, such as "Hold p95 API latency under 200 ms"
- Add context -- the GitHub repos you want threads to work on, plus any files or Google Drive folders threads should read
- Create the project -- Claude may auto-start an exploration thread that reads the repo and posts setup recommendations
- Set project instructions -- write the standing rules all threads start with (branch targets, naming conventions, what to avoid)
On first project creation, Claude takes one automatic turn: it reads any connected repo and posts "Setup recommendations" -- repositories to add, routines to create, threads it could start. Toggle what you want and click Update setup, or skip the recommendations and send your first batch of work directly.
One migration shortcut worth knowing: if you already have a cloud session doing work that belongs in a project, open the session's menu in the sidebar and choose "Continue as a project." Claude reads the session context and converts it -- existing context carries over, you don't start from scratch.
GitHub setup note: project threads require the Claude GitHub App to be installed on each repository, not just the token-based connection that /web-setup creates. If threads report repository access errors on startup, that's usually the cause. The install is a one-time step at github.com/settings/installations.
The real limitations: what doesn't work yet
Three constraints define what Claude Code Projects can't do in beta: threads are cloud-only with no access to local files or VPN-gated services, only github.com repositories work (not GitLab, GitHub Enterprise Server, or Bitbucket), and merge conflicts from overlapping thread changes are still resolved manually.
The cloud-only constraint is the most significant for teams with non-trivial local setups. Threads cannot reach local databases, device emulators, internal APIs behind a firewall, or any tool that exists only on your machine. You can upload local files directly to the project's Library for threads to read, but threads can't call tools on your machine. Anthropic says local support is coming "very soon" -- it's not in beta as of September 2026.
The GitHub-only constraint is worth checking before you plan a migration. GitLab, GitHub Enterprise Server, and Bitbucket are all unsupported as of September 2026. If your team runs a self-hosted git solution, project threads can't point at your repos yet.
Merge conflicts are handled the way they'd be in any parallel git workflow. Each thread works on its own branch, so there's no collision mid-execution. But when branches get merged, overlapping changes produce standard conflicts. The Overview pane surfaces threads with issues, but resolving the conflict is your job. The cleanest mitigation: scope threads to distinct files, directories, or repositories where possible.
One behavioral note on auto-start: when you create a new project, Claude takes an automatic turn before you send your first message, and that turn draws from your plan limits. If you don't want Claude doing anything until you're fully configured, send a message like "Don't start any threads yet" immediately after creating the project.
Usage costs: parallel threads burn your plan faster than you expect
Claude Code Projects drain your Pro or Max plan faster than single-session work because each parallel thread is a full cloud session running at Opus-level effort by default. Five simultaneous threads consume roughly 5x the tokens of a single session. Max 5x ($100/month) is the practical minimum for sustained parallel workloads; Max 20x ($200/month) is the realistic tier for large multi-repo migrations with 10+ threads running.
The plan tiers: Pro is $20/month, Max 5x is $100/month (5x the usage capacity of Pro), and Max 20x is $200/month (20x the usage capacity of Pro). Anthropic hasn't published a fixed thread cap -- projects draw from the same shared limits as your other Claude Code sessions until they're exhausted. You can add usage credits or switch to pay-as-you-go API billing if you hit the ceiling mid-project.
Practical steps to avoid unexpectedly draining your plan: scope the project goal tightly so Claude doesn't spin up threads outside your intended work area, add a thread preference to your project instructions ("don't start more than three threads at once"), and review the auto-start recommendations on first project creation before accepting all of them. The thread preference is advisory, not a hard cap, but it helps Claude make better routing decisions.
When to use a project (and when not to)
Claude Code Projects pay off when work outlasts one session and generates a continuous stream of related tasks: multi-repo migrations, ongoing bug triage for a single service, or batch processing a large document set. The coordinator overhead is worth it when the alternative is manually managing 5+ parallel sessions, re-explaining context to each one and tracking their state yourself.
Projects are not the right tool for a single task that fits in one session (just start a cloud session directly), work that requires local machine access (use a local session or agent view), or a recurring scheduled task with no interactive conversation around it (use a Routine). The GitHub App setup and project configuration have real overhead -- don't create a project for work that finishes in 20 minutes.
One non-obvious use case from the official docs: document analysis with no code at all. Upload a folder of contracts or a support-ticket export to the project Library, and threads each process a chunk and deliver write-ups as Library files. No GitHub repos needed. If you have large unstructured document batches to analyze in parallel, the batch processing model works even without any code repositories connected.
FAQ
Who can use Claude Code Projects beta?
Claude Code Projects beta is available to select Claude Pro ($20/month) and Max ($100-200/month) subscribers who have used cloud sessions and don't already have Projects on claude.ai chat or Cowork. Rollout started September 17, 2026, expanding to more Pro and Max users over the following week. Team and Enterprise plans are not yet supported. Join the waitlist at claude.com/form/projects if it hasn't reached your account.
Does each thread burn tokens from a separate pool?
No -- all threads draw from the same shared plan limit as your other Claude Code sessions. There's no separate allocation per thread. Each thread runs at Opus-level effort by default, so five parallel threads consume roughly five times the tokens a single session would in the same period. Max 5x or Max 20x plans provide substantially more headroom for parallel workloads than the base Pro plan.
Can project threads access my local development environment?
Not currently. As of September 2026, threads are cloud-only and cannot reach local files, VPN-gated services, local databases, or device emulators. You can upload local files to the project Library for threads to read, but threads cannot call tools that exist only on your machine. Anthropic describes local access support as coming "very soon" in the official documentation.
What happens when two threads modify the same file?
Each thread works on its own git branch, so changes don't collide in real-time. When branches are merged, overlapping changes produce standard git merge conflicts -- the same as any parallel git workflow. The Overview pane surfaces threads that ran into problems, but conflict resolution is a manual step. Scoping threads to distinct parts of the codebase or separate repositories is the cleanest way to avoid this.
Want the templates from this tutorial?
I share every workflow, prompt, and template inside the free AI Creator Hub on Skool. 500+ builders sharing what actually works.
Join Free on Skool