Claude Code Projects turns a folder into a conversation that delegates. What the new Projects change for a small company's software work

Since June 2024, a Project in Claude has meant a folder: a place to keep files, standing instructions and a set of separate chats that share them. On 17 September Anthropic replaced that idea inside Claude Code with something closer to a chief of staff. A Project is now a single conversation that runs for as long as the work does. You describe what you need as it occurs to you, and Claude scopes it, opens threads to do it, checks the results and tells you what is finished and what is waiting on you.

We have been running the work on this website through it since the day it launched, so this is a first-hand account rather than a reading of the announcement. It changes how a small team gets software work done. It also changes the bill and the review burden, and both deserve a plain description before anyone reorganises around it.

What did Anthropic change in Claude Code Projects?

The redesigned Project is one coordinating conversation plus a set of worker threads, a shared memory and a library. Each thread is a full Claude Code session running in the cloud on its own branch and its own copy of the repository. The coordinator decides whether a new request belongs in an existing thread or needs a fresh one, and threads can split their own work further using subagents, loops and workflows. When two threads touch the same code, the overlap surfaces as an ordinary merge conflict on the pull requests, which is the right place for it.

Anthropic's own examples are a goal to cut checkout latency, where Claude profiles each endpoint, tests changes and opens pull requests in parallel, and a goal to retire a deprecated API endpoint across three repositories, where it creates a thread per repository, migrates the callers, runs the tests and tells you which pull request has to merge first.

Memory is the part that matters most over a week or a month. Every thread reads from and writes to a shared project memory, so a decision made on Monday in one thread constrains what a different thread does on Thursday. Anthropic's examples are the kind of thing that used to live in someone's head: the release moved to Friday, the export feature was dropped and why, check with a named person before touching the billing service. The Project also learns how you like to work, and you can tell it to check in more or less often, open fewer threads, or write shorter updates.

The library collects the files you add and the files Claude produces, so a later thread can build on an earlier artefact without you re-uploading it. Each Project can be configured with its own cloud environment, connectors, plugins, instructions and model, and you can set model and effort separately for the coordinator and the workers.

Availability is narrow for now. The beta opened on 17 September to selected Pro and Max subscribers who use cloud sessions in Claude Code and have no existing Projects on web or desktop, with wider Claude Code access promised over the following week and chat, Cowork, Team and Enterprise after that. Existing Projects keep working as they did. Threads run in the cloud today; Anthropic says running them on your own machine, behind your own network, is coming soon.

What does the new Project make easy?

It removes the two jobs that made multi-agent coding work tiring: dividing the work up front and stitching the results together afterwards. Before this, running three Claude Code sessions in parallel meant writing three briefs, keeping three tabs open, remembering which one had been told about the schema change, and merging the results yourself. Now the coordinator writes the briefs, tracks the state and reports back in one place, and you can steer it from a phone while the threads run.

The second thing it makes easy is continuity. On our website work, the standing instructions about tone, the copy rules we lint against and the decision about how we deploy all live in project memory, and every thread starts with them. We have stopped re-explaining the project at the start of each session, which was the tax that made short tasks not worth delegating.

The third is long-running work. If a thread is halfway through a migration when you shut the laptop, it finishes and leaves a pull request. That sounds small. In practice it is the difference between an agent that works your hours and one that works its own, a point we made about always-on agents in May and which now applies to code.

Where does it cost more than it looks?

Usage, first. Anthropic says so in the launch post: several threads at once draw down a plan's usage several times faster, and each thread is a full Claude Code session. A Project that fans a request out into five threads with subagents underneath is running perhaps a dozen agent loops on your behalf. On a Max plan that shows up as hitting the usage limit by Wednesday. On a team's API budget it shows up as a line item nobody forecast. The controls exist, in per-project usage reporting and separate model and effort settings for coordinator and workers, and the discipline of using them is the same one we set out for metered agent workloads: cheaper models for worker threads, a spend ceiling per project, and someone who reads the number weekly.

Review, second. Parallel threads produce parallel pull requests, and a person still has to read them. A coordinator that opens six pull requests in an afternoon has moved the bottleneck from writing code to reviewing it, and if the review is a rubber stamp then the Project has quietly become the person who decides what ships. Keep the branch protection rules you had before. Keep the tests that block a merge. Treat the coordinator's summary of a thread's work as a summary written by the party that did the work, and read the diff.

Cloud execution, third. Every thread runs on Anthropic's infrastructure with a copy of your repository, using the connectors and environment you configured. For an open-source project or a marketing site that is fine. For a codebase that embeds credentials, customer data fixtures or anything a data protection regime covers, it needs the same review as any other processor you send code to, and the answer may be to wait for the local execution Anthropic has promised. Our agent permissions piece covers what a thread should be allowed to read, write and spend, and the Project's connector configuration is where those limits get set.

How should a small company set up a Claude Code Project?

Start with one repository and one goal, and write the goal as an outcome with a check, in the way you would brief a contractor. "Reduce the checkout p75 latency below 800 milliseconds, measured by the existing Grafana dashboard" gives the coordinator something to plan against. "Make checkout faster" gives it licence to open threads for a week.

Put the standing rules into the project instructions before the first thread runs: how you deploy, what needs a human sign-off, which services are off limits, what a pull request description must contain. Everything the coordinator learns later goes into memory on its own, and the memory is editable, so review it after the first week and delete anything it has inferred wrongly.

Set the worker model one tier down from the coordinator and see whether quality holds; on most of our tasks it has. Set a usage ceiling per project and check it on Fridays. Keep the pull request as the unit of review and merge nothing the tests have not passed. And decide in advance which kinds of work the Project may start on its own and which it must wait for you to confirm, then tell it so, because a coordinator that suggests work it can pick up right away will pick it up if you let it.

Anthropic's naming has created a confusion worth clearing up. The original Claude Projects still exist and still mean a workspace of files and instructions for chat; they help Claude remember the context you gave it. The new Claude Code Projects help Claude remember and coordinate the work it is doing. The two will converge as the rollout reaches chat and Cowork, and until then a team should expect the word to mean different things in different tabs.

Frequently asked

What is the new Claude Code Projects feature? Claude Code Projects, released in beta on 17 September 2026, replaces the folder-style Project with a single running conversation. You describe what needs doing, and Claude scopes the request, delegates it to parallel worker threads that each run as a Claude Code cloud session on their own branch, reviews the results and reports what is done and what is waiting on you. Threads share a project memory of decisions and preferences, and a library holds the files you add and the files Claude produces. Work continues after you close your laptop.

Who can use Claude Code Projects and what does it cost? At launch the beta was available to selected Claude Pro and Max subscribers who use cloud sessions in Claude Code and have no existing Projects, with wider access to Pro and Max Claude Code users promised over the following week and chat, Cowork, Team and Enterprise plans after that. There is no separate price; Projects draw on the plan's usage, and because each thread is a full Claude Code session, running several threads at once uses that allowance faster. A waitlist is open for Pro and Max users who do not yet have access.

How is Claude Code Projects different from the original Claude Projects? The original Claude Projects, introduced in June 2024, are workspaces that hold uploaded knowledge, custom instructions and a set of separate chats; each chat is its own conversation and context does not flow between them unless it is captured in project knowledge. The new Claude Code Projects add a coordinator conversation that plans and delegates work across parallel threads, a shared operational memory that every thread reads and writes, and cloud execution against your repositories. Existing Projects keep working and Anthropic says they will be upgraded as the rollout expands.

Related reading

• Gemini Spark works while your laptop is closed. What an always-on agent changes for a business
• Flat-rate AI is ending for agents. How to budget when every loop is metered
• Agent permissions: how to decide what an AI agent may read, write and spend
• What you can hand to an AI agent in 2026, task by task, and the four jobs to keep

A Project that delegates to itself is the first mainstream tool that manages agents rather than being one, and a small company can now run software work the way a larger one runs a team. Setting that up so the usage, the review and the access stay under control is the kind of work we do in an embedded squad engagement.