Claude Code Projects Tutorial: Run Parallel Cloud Threads With Shared Memory (Beta)

Step-by-step guide to Claude Code Projects (public beta, September 2026): create a project, write standing instructions, send a batch of work to parallel cloud threads, review pull requests, and control cost.

By AI Mastermind Lab · Published 25 Sept 2026

TL;DR: Claude Code Projects, in public beta on Pro and Max plans since mid-September 2026, turns one conversation into a coordinator that spins up parallel cloud sessions ("threads"), each on its own branch with its own pull request, all sharing the project's repositories, instructions and memory. This tutorial walks through creating a project, sending it a batch of work, reviewing what comes back, and writing the standing instructions that make threads behave. Everything here is taken from Anthropic's Projects documentation as of 25 September 2026.

If you have used Claude Code on the web, you know the pattern: one cloud session, one task, one branch. Running five tasks meant opening five sessions, pasting the same background into each, and checking back to see which finished. Projects remove that coordination work. You describe the stream of work once; Claude starts a thread per task, tracks them, and shows you which ones need an answer.

Prerequisites

Before you start, the documentation lists three things to check:

  • Plan. You are on Claude Pro or Max, and Projects appears in the left sidebar at claude.ai/code or in the Code tab of the desktop app. Projects are rolling out gradually, starting with accounts that have already used cloud sessions. They are not yet available on Team or Enterprise plans. If you do not see the entry, you can join the waitlist.
  • GitHub, if the project will touch code. Your repositories must be on github.com (not GitHub Enterprise Server, GitLab or Bitbucket), your connected GitHub account needs push access, and the Claude GitHub App must be installed on each repository. For organisations that enforce SAML SSO, you have to reconnect GitHub and authorise the Claude app for that organisation before its private repositories show up.
  • Network, credentials and tools. Cloud threads get these from the project's cloud environment. The default environment already reaches common package registries; you only need a custom environment if the work needs other domains, a secret, or a tool that is not preinstalled.

How a project is organised

The docs describe four parts, and understanding them makes the rest of the workflow obvious:

  1. The project conversation. One long-running session where Claude acts as coordinator. It takes what you send, decides what becomes a thread, and keeps track of every thread it started. It sees what threads report back, not every step they take.
  2. Threads. The workers. Each is a separate session with its own context window that does one piece of work and reports back when it finishes. A cloud thread works on its own branch and opens a pull request when the work calls for one. If a task needs something only your machine has, you can ask Claude to run that thread locally through Remote Control.
  3. What every cloud thread starts with. The project's repositories and uploaded files, its instructions and memory, the CLAUDE.md and skills from each repository (and, in single-repository projects, that repository's permission rules and hooks), the connectors on your claude.ai account, and the cloud environment that defines network access, environment variables and tools.
  4. The Overview pane. Where you see every thread at once and which of them need you. Its tabs are Library (files you added and files threads produced), Pull requests (the ones threads opened) and Routines (scheduled work in the project).

One consequence the docs call out: cloud threads do not pick up anything from the Claude Code setup on your own machine. Skills, plugins and MCP servers you use locally have to be added to the project or its environment to reach threads.

Step 1: Create the project

Open claude.ai/code (or the desktop app's Code tab), select Projects in the sidebar, then New project. In the browser you can also go straight to claude.ai/code/projects/browse.

The dialog has three fields, and only the first is required:

  • Name. How the project appears in the list. Scope it to one stream of work you will keep adding to, such as "Keep the checkout API under its latency target."
  • Goal (optional). One line of what you are trying to get done. Claude in the conversation works toward it. You can add it later in Project settings > General.
  • Context (optional). The GitHub repositories the project works on, plus any files, folders or Google Drive folders threads should read. Add the repositories most tasks need rather than every one the work might touch; you can add more later in Project settings > Environment.

Click Create project. On your first project, Claude takes a turn of its own as soon as the project exists, unless you send a message first: it may start a read-only thread that explores the repository and proposes next steps, and it may post Setup recommendations drawn from your recent cloud sessions (repositories to add, routines to create, threads it could start). Every recommendation starts switched on; turn off the ones you do not want, then click Update setup, or ignore them and describe the work yourself. That first turn uses your plan.

Alternative: start from a running cloud session. If a cloud session is already doing work that belongs in a project, open its menu in the sidebar and choose Continue as a project (creates a new project named after the session and asks Claude to propose the setup) or Move to project (brings the session's work into an existing project). In both cases the original session stays in your list; if it was mid-turn it keeps running, so stop it yourself if you do not want two copies working.

Step 2: Write the standing instructions

This is the step that decides whether threads behave. Project instructions are read by every new thread, so a rule you state once reaches all of them. The documentation's own examples are a good template:

Target branch: main. Open one pull request per task; never push to main directly.
Run `npm test` and `npm run lint` before opening a PR; do not open a PR with failing checks.
Follow the conventions in CLAUDE.md. If a task is ambiguous, ask in the project conversation
instead of guessing.
Keep PR descriptions to: what changed, why, how it was tested.

Anything a thread should remember after one task, such as a pitfall it hit while fixing a bug, you can tell Claude to store in project memory, and later threads pick it up.

Because threads read each repository's CLAUDE.md, keep repository-level conventions there and project-level workflow rules in the project instructions. Since Claude Code 2.1.277, per the changelog, a repository's AGENTS.md is read when it has no CLAUDE.md, which helps if your repositories already standardise on that file for other agents.

Step 3: Send the first batch

In the project conversation, describe the work as a list. Something like:

1. Bring every service in this repo up to the new ESLint config; one PR per package.
2. Add request-duration histograms to the three slowest endpoints named in docs/perf.md.
3. Write a migration plan for moving off the deprecated ORM as a document in the Library.
Start without asking me to confirm each thread.

Claude decides which items become threads and starts them. Each cloud thread works on its own branch and opens a pull request when it has something to merge. You can walk away: cloud threads keep going after you close your laptop, and you can check on and steer them from the mobile app.

Step 4: Review what comes back

The Overview pane is your inbox. When you return, it shows which threads finished, which pull requests are ready for review, and which threads are under Waiting on you because they need an answer or an approval. Review a thread's pull request from the Pull requests tab; open the thread itself when you need to take control of a session directly; unblock a thread waiting on a permission approval from the conversation.

For work that is not code, threads deliver each write-up as a file on the Library tab. Uploading a folder of documents to the project instead of a repository is the pattern the docs suggest for tasks such as "find the ten most common integration mistakes in these support tickets."

Step 5: Tune models and cost

The documentation's Choose models and let Claude manage context section covers model selection per thread; Claude Code 2.1.280 made Claude Opus 5.5 the default model, per the changelog, and you can pick differently for a project. The important cost fact is stated plainly: a project draws on the same plan limits as your other Claude Code sessions and uses them faster, because several threads run at once. The Usage and cost section explains what draws on the plan and how to see and reduce a project's usage. Practical rules that follow from it:

  • Batch related tasks so threads share context instead of re-deriving it.
  • Put a "start without confirming" instruction in only when you are confident in the task list; a thread that guesses wrong burns the same tokens as one that guesses right.
  • Use routines for recurring work (the docs give "post a dependency report every Monday" as the example) rather than a thread you re-create by hand.

When not to use a project

The docs are explicit about the cases where something else fits better:

  • One task that fits in a session. Start a cloud session yourself.
  • Work where every task needs your machine (a local database, a device emulator, an API behind your VPN). Use a local session, or agent view to run several at once.
  • One scheduled task with no conversation around it. Create a routine on its own.
  • Several people steering Claude together in Slack. Use Claude Tag.

Troubleshooting notes from the docs

Two situations the documentation addresses directly: a thread that looks stuck, and threads that "guessed or stalled instead of asking." The fix for the second is almost always the instructions: state what threads should do when a task is ambiguous, and tell them when to ask in the conversation rather than proceed. Read the Limitations section before committing a production workflow; the feature is in beta and its constraints are changing weekly.

Related reading

Sources