Claude Code Projects is a workspace where Claude coordinates multiple related tasks. You describe the work in a shared conversation, and Claude launches separate work streams, tracks their status, and compiles the results. Streams use shared project instructions, materials, and memory.

Projects are suitable for developing an application, regularly processing documents, or maintaining a product: when work continues beyond a single conversation and new tasks keep appearing. Below are setup instructions using the English interface, ready-made instructions, and an example of a first launch.

Availability checked October 11, 2026. According to Anthropic's official documentation, the new Projects are in public beta on Pro and Max plans. Access is being rolled out gradually; this version is not yet available for Team and Enterprise.

What are Projects and how do they differ from regular chat?

In a regular session, you assign Claude one task and decide yourself when to open the next one. In Projects, the shared conversation becomes a coordinator: it receives tasks, passes them to executors, and tracks progress.

A thread, or work stream, is a separate Claude Code session with its own context. It usually runs in the cloud. For code work, a thread uses its own copy of the repository and a separate branch. The result may be code changes, a pull request—a request to merge them into the main branch—or a finished file.

Item	Purpose
Project conversation	Shared conversation: goals, new tasks, decisions, and summaries.
Threads	Separate task executors.
Project instructions	Persistent rules for the coordinator and new threads.
Project memory	Saved decisions, requirements, and notes.
Overview	Tracking tasks, results, and requests to the user.
Library	Source materials and files prepared by threads.

For example, you ask it to improve a Telegram bot. One thread investigates an authentication error, another prepares payment tests, and a third updates the user guide. The shared conversation shows what is complete, what is blocked, and which result needs review.

The general principles of this approach are covered in the article how AI agents work and where to use them.

What tasks are worth creating a project for?

Create a project around one long-term goal. A good boundary is a specific product, service, or regularly recurring process.

Application development: bug fixes, new features, tests, and documentation.
Migrating multiple repositories: coordinated changes to the server, website, and mobile app.
Service maintenance: investigating errors, user reports, and test results.
Working with documents: analyzing support exports, preparing instructions, and comparison reports.

For a single small fix, a regular Claude Code session is enough. If nearly every task requires a local database, device, or VPN access, it is more convenient to start with local sessions.

Do not put your entire business into one project. The “Customer Telegram Bot Development” project has clear materials and outcome criteria. The “All Company Tasks” project quickly accumulates conflicting instructions and unnecessary context.

Step 1. Check access and prepare materials

Open claude.ai/code or the Code tab in the Claude Desktop app. The sidebar should contain a Projects.

section. If the section is missing, access has not yet been granted. You can join the Projects waitlist. Having a Pro or Max subscription alone does not mean the feature is already available on the account.

If the project will modify code

The repository must be on github.com.
The GitHub account connected to Claude must have permission to push changes to the repository.
The required repository must be covered by the Claude GitHub App.

GitHub integration through the /web-setup command, which is sufficient for some cloud sessions, does not replace the Claude GitHub App for Projects workflows. GitLab, Bitbucket, and GitHub Enterprise Server are not supported for the repository integration described in the documentation.

If the project will work with documents

GitHub is not required. Prepare the source files, task description, and outcome requirements. For example: an anonymized export of support requests, the current support guide, and a final report template.

For the first run, use a small set of materials that you can verify yourself.

Step 2. Create a project

Open Projects → New project.
In the Name field, enter a clear name.
In the Goal describe one goal.
In the Context using Add add the required repositories, files, or folders.
Click Create project.

Only the name is required. The goal and materials can be added later, but they make it easier for Claude to identify the work correctly.

Example:

Name: Customer Support Bot.
Goal: Prepare the support bot for a test launch: fix bugs, check workflows, and update the documentation.
Context: bot repository, workflow description, list of known issues.

If Claude shows Setup recommendations, first review the suggested repositories, schedules, and tasks. Repositories and routines may be enabled by default in the recommendations. Disable unnecessary items before clicking Update setup.

An already started cloud session can be continued using Continue as project. Note that the original session may continue running. Check its status to ensure that two sessions do not perform the same task at once.

Step 3. Set persistent instructions

Open the gear icon in the project header, then Project settings → Memory → Project instructions. This is where you set rules that every new workflow receives.

The instructions should explain the goal, workflow, result verification, and what to do when data is insufficient. Below is an example for a development project. Replace the names and commands with real ones.

The project goal is to prepare the customer Telegram bot for a test launch.

Work in the connected repository. Create a separate branch from main for each independent task.

Before changing code, read CLAUDE.md and the instructions in directories related to the task.

Before starting work, specify the definition of done. Before finishing, run the checks required by the repository. In the result, list the changes, checks performed, and remaining limitations.

If access, a file, dependency, or secret is missing, name the issue precisely. Do not replace unavailable data with made-up results.

Do not merge pull requests, deploy, modify the production database, or change payment settings without my separate permission.

For the first run, propose workstreams before execution starts. After confirmation, run no more than two workstreams at once. Complete dependent tasks sequentially.

Instructions govern Claude's behavior but do not replace technical access restrictions. In particular, a request to run no more than two workstreams is a preference, not a hard platform limit.

What should be stored in Project instructions, CLAUDE.md, and memory?

Location	What to store there
Project instructions	Project goals, general rules, result format, approval process.
CLAUDE.md in the repository	Architecture, commands for running and testing, code conventions.
Project memory	Decisions made, discovered specifics, and corrected assumptions.

For example, after fixing an issue, write: “Remember: test payments are made only in the sandbox; do not use the production payment account.” Then check the entry in Project settings → Memory.

Read more about the purpose of different types of memory in the article AI agent memory: architecture and risks.

Step 4. Set up the environment and tools

A cloud workstream runs in a separate environment. Programs, environment variables, and connections configured only on your computer are not transferred to it automatically.

Open Project settings → Environment and check:

Repositories: whether all code required for the task is available.
Network access: whether the required domains and APIs are allowed.
Variables and secrets: whether the required settings and credentials are available.
Setup script: whether it installs dependencies to run and validate the project.
Connectors: whether external tools are connected.

The cloud environment configuration is described in the Cloud environments documentation. Set secrets through the provided environment settings; do not put them in instructions or repository files.

Skills and other instructions can be stored in a connected repository. Plugins for cloud workstreams are added through Project settings → Plugins: declaring a plugin in a local settings file alone is not enough.

The project's main conversation does not have connectors. A task requiring such a connection must be assigned to a workstream. If you connect a CRM, database, or another service, it is useful to first understand how MCP gives an AI agent access to tools.

Multiple repositories caveat: in the Anthropic environment, permission rules and hooks from their .claude/settings.json files do not apply to a workstream the same way they do in a single-repository project. Do not assume local restrictions will automatically protect cloud work.

Step 5. Run one validation task

The first task should verify that Claude can see the necessary materials, understands the instructions, and can confirm the result. To start, analysis without changing code is sufficient.

Check the new user registration flow in the connected repository. Do not change the code yet.

Find the registration handlers and related tests. Describe the current user flow and identify possible errors with links to specific files.

Separately list confirmed issues, assumptions, and what could not be verified. Finish by proposing one small fix and its completion criterion.

Run one thread for this task.

After completion, open the thread and check:

Whether it used the correct repository and branch.
Whether it read the necessary instructions.
Whether the conclusions are supported by specific files and verification results.
Whether it presents an assumption as a discovered error.
Whether it changed the code against the task instructions.

If an incorrect assumption is found, correct it in the thread and update the persistent instructions or memory. Then repeat a small task before sending a large batch of work.

Step 6. Split work into independent threads

Run tasks in parallel when they can be completed independently. If one task changes an interface another depends on, first complete and agree on the interface.

Example package for a support bot:

Prepare a plan for three tasks:

1. Fix the confirmed registration error and add a check for this scenario.

2. Update the user instructions for the bot's current behavior without changing code.

3. Analyze how unknown questions are handled and propose improvements without implementing them.

For each task, specify the outcome and dependencies. If threads will modify the same files, propose sequential execution.

Different branches prevent direct file overwrites in cloud copies, but do not eliminate conflicts when merging changes. Ask the coordinator to specify the order for merging pull requests separately.

An addition to an ongoing task can be sent directly to its thread. This is more reliable than expecting the main conversation to correctly identify the recipient of a short message.

How do you monitor progress through Overview?

Overview shows the status of threads. Open it regularly: no new messages in the main conversation does not mean the work has stopped.

Статус	What it means	What to check
Working	The thread is working.	Open its log if needed.
Waiting on you	A response, permission, or error resolution is needed.	Open the thread and respond to the specific request.
Ready for review	The pull request is awaiting review.	Changes, tests, and completion criterion.
Landing	The pull request is approved or queued for merging.	The order of merging dependent changes.
Idle	The thread has finished its current work and is not waiting for anything.	Final response and prepared files.
Resolved	The thread is marked as completed.	Whether completion matches the actual result.

The permission request is confirmed within the specific thread. A “I allow it” message in the general conversation does not clear a pending tool approval.

Find files on the Library, and code change requests on the Pull requests. To stop an individual task, open the thread and click Stop.

For a summary, send the coordinator:

For each open thread, list the task, result, checks performed, blockers, and next step. Separately indicate which changes depend on one another and the order in which to enable them.

How do I assign a task on my computer?

If a task needs a local database, installed program, or a resource behind a VPN, Projects can start a thread through Remote Control. Such a thread works while the computer is on and the connection is active.

Update Claude Code: the documentation for this scenario requires version 2.1.280 or later.
In Claude Desktop, open Settings → Claude Code.
Enable Use this computer from your phone and claude.ai and add a working folder.
In the project conversation, select + → Work locally and describe the task.
In the Allow Claude to work in a folder on your device card, select a folder and click Allow once.

An alternative way to connect is to run the command in the required folder claude remote-control and leave it running. For a Git repository, the –spawn worktree option lets threads use separate working copies.

Do not run multiple threads in the same folder without isolation: they may overwrite each other’s changes. A local thread uses the computer’s tools and settings and receives project instructions, but its memory files are not loaded at startup. Include any necessary decisions directly in the task.

Additional connection requirements are listed in the Remote Control guide.

How do I manage limit usage?

Projects use the same subscription limits as other Claude Code sessions. Usage includes the work of threads and the coordinator. Several parallel tasks can use up the available amount faster than one session.

Open Project settings → General and check Thread model, Thread effort, Coordinator model and Coordinator effort. According to the current documentation, a new project uses Opus; threads default to high effort and the coordinator to low.

For simple tasks, choose an appropriate less resource-intensive model and effort level.
Ask small questions in the general conversation without a separate thread.
Do not connect repositories to every task when they are only needed occasionally.
Check usage by thread and model in Project settings → Usage.
Stop unnecessary work and monitoring of completed pull requests.

After opening a pull request, a thread may continue monitoring CI errors and comments, fixing them automatically. This monitoring also uses limits when new work appears.

A regular thread that reaches a limit can continue on its own after the limit resets. If it should not continue, click Stop or pause the project. Work beyond included limits is possible with usage creditsenabled; a thread cannot enable them for you.

What errors occur during setup?

Problem	What to do
Claude can't see the repository.	Check push permissions, the Claude GitHub App installation, and the app's access to this repository.
The command works locally but not in the cloud.	Check dependencies, the setup script, variables, and network access in the cloud environment.
The session is using old rules.	Changes to instructions, environments, repositories, and plugins apply to new sessions. Send the fix to the current session separately.
Claude is reading an old version of the document.	Uploaded files are copies. Upload the updated file and select Replace.
The work appears to be stuck.	Open the session: it may be preparing the environment, running a command, or waiting for permission.
Uncommitted changes disappeared.	If the cloud environment can't be restored, the session may continue from a fresh copy. For long tasks, save intermediate work with commits and push.

Also note: in the current beta, a project belongs to one user. You can't share the project itself or its sessions with a colleague. A different access setup is needed for multiple employees.

Before connecting business systems, define allowed operations and minimum permissions. A practical process is described in the article how to limit an AI agent's access to email, CRM, and data.

Which MVP should you start with?

The first MVP is one project, one source of materials, and one verifiable task. The goal of the first run is to make sure Claude works with the right data and confirms the result.

For development, choose a small bug in a test branch. For document work, upload an anonymized export of support tickets and ask it to find recurring issues.

Analyze the attached export of support tickets. Identify recurring user issues.

For each issue, provide the number of tickets, example IDs, and a proposed instruction change. Don't count a repeated export of the same ticket as a new request.

Prepare a report. If there isn't enough data to draw a conclusion, state that. Don't send anything to customers or change anything in the CRM.

Manually check several examples and calculations. Then add new tasks and integrations. Expand the project once the result quality, typical errors, and limit usage are clear.

If you want to apply this process to your company's development, support, or documents, discuss the task and the first MVP with CenterAI.

Frequently asked questions

Can you use the new Projects from the terminal or VS Code?

The Projects interface is available in the browser, Claude Desktop, and the mobile app. The project interface itself isn't available in the terminal CLI, VS Code extension, or JetBrains plugin. The terminal can be used to connect a local folder via Remote Control.

Can OpenRouter be connected instead of Anthropic?

The described Projects use Anthropic as the model provider, both for cloud sessions and for sessions on a computer via Remote Control. Projects documentation doesn't support connecting OpenRouter instead of this provider.

Can work be performed automatically on a schedule?

Yes. From a project, you can ask Claude to create a routine — a task with a schedule or another supported trigger. It appears on the Routines tab. Add a schedule after verifying a regular run.

How do I stop the entire project?

Open Project settings → General → Pause. Pausing interrupts active sessions and the conversation, blocks new runs, and stops routines until the project is resumed.

What happens when a project is deleted?

Delete permanently removes the project, its sessions, memory, and files, and also disables routines. Branches and pull requests already sent to GitHub are preserved.

Sources and verification

Date features, availability, and UI element names were checked: October 11, 2026. Projects are in beta, so the interface and access terms may change.

Claude Code Projects: a practical guide from setup to results