AIREITERClaude Projects redesigned turns a Project into a coordinator conversation that can delegate work to parallel Claude Code cloud sessions, while existing Chat and Cowork Projects remain on the older behavior during rollout. The practical questions are which context survives and where the work runs.
What Anthropic changed in Claude Projects redesigned
The redesigned Project starts with a goal and relevant context, then Claude scopes the request, creates or reuses worker threads, reviews their output, and reports back in the main conversation. Anthropic says each worker is a full Claude Code cloud session with its own branch and repository copy; workers can run tests, read documents, and open pull requests. (Anthropic’s announcement)
The new model is currently a staged beta. Anthropic says access began with selected Pro and Max subscribers using Claude Code cloud sessions, while broader Claude, Cowork, Team, and Enterprise availability follows later. Existing Projects are supposed to continue working and be upgraded as the redesign reaches those surfaces. (Claude Help Center)
The important architectural differences
| Area | Redesigned Projects | Cowork | Claude Code outside Projects |
|---|---|---|---|
| Main unit | One coordinator conversation with worker threads | Tasks grouped in a work project | A coding session in a repository or directory |
| Best fit | Multi-part work that needs delegation and continuity | Desktop and knowledge-work tasks across files and connected apps | Direct software development, tests, branches, and terminal workflows |
| Execution | Cloud threads in the current beta | Cloud or local workflows depending on task and rollout | Cloud or local Claude Code sessions, depending on setup |
| Context | Project files, repositories, instructions, shared memory, and Library | Project context, instructions, files, scheduled tasks, and Cowork memory | Repository files plus CLAUDE.md and session context |
| Parallel work | Built into the Project model | Task-oriented rather than the redesign’s coordinator model | Usually managed by the developer or separate sessions |
| Main risk | More concurrent sessions consume usage; overlapping edits can conflict | Local/cloud boundaries and separate project memory | Context must be made explicit across sessions |
Projects, Cowork, and Claude Code: which one should own the work?
A Project should own work that has several dependent streams, such as changing an API, web client, and mobile client together. Anthropic’s example uses three repositories and a deprecated v1 endpoint: separate threads migrate callers, run tests, and open pull requests, with the coordinator reporting the merge order. (Projects redesigned)
Choose redesigned Projects for coordinated multi-step work
Use the redesigned model when the task needs a durable objective, parallel execution, and a shared record of decisions. It is the strongest fit for release programs, cross-repository migrations, and document-plus-code work where the coordinator can route new requests to the right thread.
The trade-off is resource use. Anthropic says every worker thread counts as a full Claude Code session, so several concurrent threads can consume a plan’s usage faster. Parallel edits can also produce ordinary pull-request merge conflicts; orchestration does not remove the need for review.
Choose Cowork for desktop knowledge work and connected apps
Cowork is the better default for recurring document, spreadsheet, browser, email, calendar, and local-folder tasks. Its Projects can contain instructions, context, scheduled tasks, and project-scoped memory. The Cowork workflow is task-centered rather than a direct replacement for a repository coordinator.
Do not assume a Chat Project and a Cowork Project are the same workspace. A hands-on comparison by Using Claude found that files and project instructions can transfer through Import, while information held only in accumulated chat memory did not. The author summarizes the result as:
“files yes, chat memory no” — Using Claude’s tested comparison
Choose standalone Claude Code for direct repository control
Use Claude Code directly when a developer needs to inspect a repository, edit files, run commands, and review changes without delegating a larger program to a coordinator. Keep durable instructions in a version-controlled CLAUDE.md; Anthropic describes it as a project memory file that Claude Code reads at the start of a session. (Claude Help Center: CLAUDE.md)
Migration: what is official, and what is still uncertain
Anthropic’s official position is reassuring but incomplete: existing Chat and Cowork Projects continue working during the transition, and Pro and Max Projects will be upgraded as the new experience expands. The announcement does not provide a universal conversion button, a precise upgrade date, or a field-by-field migration manifest. (Claude Help Center)
That leaves two different migration cases:
- Anthropic’s staged upgrade: wait for the redesigned experience to reach your account and surface. Existing Projects are expected to remain available until then.
- Chat Project to Cowork today: use Cowork’s Import option when available, then verify the result. The tested comparison describes three Cowork creation paths—start from scratch, import from a Claude Project, or use an existing folder—and reports that Import carries files and instructions, not accumulated chat memory.
A safer migration checklist
- Export or copy the source files, instructions, and important decisions before changing the workspace.
- Put durable project facts in reviewable files, not only in chat history. For code, commit
CLAUDE.md, a current status note, and decision records. - Import or wait for the upgrade, but do not delete the original Project until verification is complete.
- Ask the destination workspace for a file-specific fact and check that it cites the expected source.
- Ask about a decision that existed only in the old conversation. If the answer is missing, add that decision to a project file or explicit instruction.
- Change one test instruction, reopen a fresh thread, and confirm whether the new instruction is visible.
- For code, inspect the branch, run the test suite, and review pull-request diffs before merging.
- Treat the old and new workspaces as unsynchronized unless Anthropic explicitly shows a live sync relationship.
Context persistence: checks you can run without guessing
Anthropic says redesigned threads begin with the Project’s files, repositories, instructions, and memory, and that every thread contributes to shared Project memory. That is the product claim—not a guarantee that every legacy Chat or Cowork detail will be converted perfectly. (Claude Help Center)
Use this five-part check before trusting a migrated workspace:
| Check | Test prompt or action | Pass condition |
|---|---|---|
| File context | Ask for a fact that appears in one named source file | The answer identifies the right file and value |
| Instructions | Add a distinctive output rule, then start a fresh thread | The new thread follows the rule |
| Memory | Ask about a decision recorded only in prior chat | It is known only if it was deliberately migrated or the redesign retained it |
| Repository state | Ask for the current branch, changed files, and test command | The worker reports the actual connected repository state |
| Synchronization | Edit the source Project after importing it | The destination changes only if documented sync exists; otherwise update it manually |
The memory test is the one most likely to expose a false assumption. The independent Chat-to-Cowork test found that Cowork could answer a question grounded in transferred files but could not answer a question whose answer existed only in chat memory. That is why a short decision log is a better migration artifact than hoping the interface will infer history.
FAQ about Claude Projects redesigned
Is Claude Projects redesigned available in regular Claude?
Not universally at the initial rollout. Anthropic began with selected Pro and Max subscribers using Claude Code cloud sessions and says Chat, Cowork, Team, and Enterprise expansion will follow.
Will my existing Project be deleted?
Anthropic says existing Chat and Cowork Projects continue working during the transition and will be upgraded as the rollout expands. Keep your own export or source-file copy anyway, because the help documentation does not promise a detailed rollback or migration report.
Does redesigned Projects replace Cowork?
No. Redesigned Projects provide orchestration around parallel Claude Code sessions. Cowork remains the more natural surface for desktop files, connected applications, scheduled tasks, and general knowledge work.
Does Project memory persist across every Claude interface?
Do not assume that it does. Anthropic describes shared memory inside the redesigned Project, while the tested Chat-to-Cowork workflow found that chat-only memory did not transfer with files and instructions.
Can redesigned Projects use local code today?
The initial redesigned threads run in the cloud. Anthropic says local execution, including work alongside local tools and behind a user’s network boundary, is planned but does not give a firm release date in the announcement.
Will parallel Project threads use more of my allowance?
Yes. Anthropic says each thread is a full Claude Code session and that running several threads simultaneously consumes usage more quickly.
The safest default while the rollout continues
Use redesigned Projects for a coordinated program, Cowork for task automation around documents and connected apps, and direct Claude Code for repository-level control. During migration, make files and decision logs the source of truth, then test file access, instructions, memory, repository state, and synchronization independently. The remaining trade-off is clear: the redesigned model promises stronger continuity and delegation, but its beta rollout and higher session consumption make a verified, reversible migration more sensible than an immediate cutover.