# Anthropic’s Redesigned Claude Code Projects: What Developers Need to Know
## A New Era for Multi-Agent Development in the Cloud
Anthropic has unveiled a significant overhaul of its Claude Code projects framework, introducing a redesigned system built around cloud-native threads, persistent shared memory, and coordinated multi-agent workflows. The announcement signals a shift in how developers can manage complex coding tasks that span multiple repositories and require parallel execution.
## Why Projects Are Being Redesigned
Historically, Claude Code treated projects as simple directory structures — isolated code roots with no meaningful way to coordinate activity between them. Developers working across multiple repositories had to manually manage threads, track progress, and stitch together results from separate AI sessions. The new architecture fundamentally changes this paradigm.
According to the announcement, the updated project system allows Claude to scope requests, delegate work across parallel threads, coordinate their execution, review outputs, and assemble final results. The system is designed to keep working even after a user closes their laptop, making it particularly suited for long-running development cycles.
## Key Features of the New System
### Persistent Cloud Threads
Each discussion within a project now becomes a full cloud session. These sessions maintain their own branch and copy of the repository, allowing developers to revisit and manage individual threads independently. This persistence means that work continues to exist and evolve regardless of whether the developer’s local machine is active.
### Shared Memory Across Threads
One of the most powerful additions is a shared memory system that threads can draw from and contribute to over time. As Anthropic described it, Claude learns more about the project details as work progresses, reducing the need for complex prompt engineering. This automated memory allows workflows to span multiple repositories, enabling developers to coordinate work across several codebases simultaneously.
### Improved Orchestration
The new system provides a coordination layer that goes beyond simple prompting. Developers are encouraged to brief Claude on a project the way they would brief a chief of staff, with the system intelligently routing work to new or pre-existing threads. Mid-flight steering is supported — developers can dive into a running thread and redirect it before it reaches completion, avoiding wasted time and token consumption.
## Availability and Limitations
The redesigned project feature is currently available to select Claude Pro and Max subscribers who use cloud sessions in Claude Code and who don’t already have existing projects configured on web or desktop platforms. Anthropic has stated that features will gradually roll out to additional user groups over time.
For existing project users, the company confirmed that current configurations will remain unchanged, with upgrades coming at a later date.
### What the New System Doesn’t Change
Several important limitations should be noted. The system does not introduce autonomous execution — threads begin when users manually hit the Start button for each recommended thread. It also does not replace the terminal interface; CLI functionality remains intact and unchanged. Additionally, local workflows are not yet supported by the new architecture, though Anthropic has indicated that running threads on local machines alongside existing tools and behind private networks is expected in the near future.
## Considerations for Evaluation
### Memory Transparency
The shared memory system lacks detailed documentation regarding inspection, correction, export, or retention policies. Developers who rely on structured knowledge management may find this opacity challenging when integrating the tool into their workflows.
### Usage and Cost Scaling
Running multiple threads simultaneously means each one operates as a full Claude Code session. This architecture reaches usage limits faster than single-thread workflows, which is a consideration for teams working on large codebases with extensive agent fleets.
### Merge Conflicts Remain Inevitable
Overlapping threads that modify the same code will eventually surface as merge conflicts. The system does not prevent these collisions — it simply makes them visible when they occur, requiring manual resolution by the developer.
## Frequently Asked Questions
**Q: Who can currently access the redesigned Claude Code projects?**
A: The feature is available to select Claude Pro and Max subscribers using cloud sessions who don’t have existing projects on the web or desktop platforms. Wider availability is planned over time.
**Q: Can I use the new project system with local development workflows?**
A: Not yet. The system currently operates exclusively in the cloud. Anthropic has indicated that local execution support is coming in the future.
**Q: How does shared memory work across threads?**
A: Threads add to and draw from a shared memory pool that grows over time. This allows Claude to apply accumulated project knowledge to new tasks without requiring detailed re-prompts. The exact mechanics of how memory is stored and retained have not been fully detailed.
**Q: Can I steer a thread while it’s running?**
A: Yes. Named threads can be accessed mid-execution, allowing developers to redirect their focus or modify instructions before the thread completes its work.
**Q: Does this replace subagent functionality?**
A: No. The underlying architecture already supports subagents, and the new project system builds on that foundation. The key improvement is the persistence of split work and the ability to return to individual subagent discussions.
**Q: What happens to existing projects during the transition?**
A: Existing projects remain in their current state. Anthropic plans to upgrade them later, and migration details have not yet been fully outlined.
## Conclusion
Anthropic’s redesigned Claude Code projects represent a meaningful evolution in how AI-assisted development can be structured at scale. By introducing persistent cloud threads, shared memory, and improved orchestration, the system addresses many of the coordination challenges that arise when managing complex, multi-repository coding efforts. However, the feature is still in a limited rollout phase, and questions around memory transparency, cost scaling, and local integration remain open areas for refinement.
For cloud-based developers working across multiple codebases, the new capabilities offer a glimpse into a more cohesive and manageable multi-agent workflow. As the feature expands and matures, it has the potential to reshape how development teams coordinate AI-assisted work at scale.
Thank you for reading
