On September 17, Anthropic announced a ground-up redesign of Projects in Claude Code, and the title itself is a manifesto: "Projects redesigned: from folder to conversation."
A project used to be a "context container": you dropped in documents and code, then manually split tasks across sessions, juggled handoffs, and stitched the results back together. The new version inverts the logic: you describe what needs to get done, and Claude manages the work — scoping the request, delegating, coordinating parallel threads, reviewing outputs, and assembling the finished result. You can steer throughout, even from your phone; and it keeps working after you step away from your computer.
The two official examples are very "engineering manager": set a goal to cut your app's checkout p75 latency, and Claude profiles each endpoint, tests optimizations, and opens PRs in parallel threads; or connect your API, web, and mobile repos and set a goal to retire a deprecated v1 endpoint — Claude opens a thread per repo, migrates the callers, runs the tests, opens PRs, and finally tells you which ones need to merge first.
[1]
Architecture: threads do the work, the coordinator directs
The skeleton of the new Projects has two layers: threads that do the work, and a coordinator that directs them.
- Each thread is a full Claude Code cloud session, working on its own branch and copy of the repo;
- If multiple threads touch the same code, the overlap is resolved as an ordinary PR merge conflict — no new mechanism invented, just the one software engineering has validated for decades;
- Threads can further split their delegated work into subagents, loops, and workflows so large assignments finish faster;
- Your interaction is redefined as "briefing Claude the way you'd brief a chief of staff": monitor and guide from the main project chat, or dive into any individual thread to inspect the details.
Configurable items include the cloud environment, connectors, plugins, instructions, and model. There is also an unusually candid caveat: because every thread is a full session, projects can reach usage limits faster — you can check project-specific usage and select model and effort levels separately for the coordinator and the worker threads.
[1]Memory: the more you use it, the better it knows you — and the harder to leave
The second thread is context that builds over time. Projects are designed for "long-running or agentic workflows": every thread writes to and reads from a shared memory — that the release moved to Friday, why the export was dropped, or who to check in with before touching the billing service. The official line is that this reduces the need for complex prompt engineering.
Claude also remembers your working and communication style: how often to check in, how frequently to start new threads, how detailed each update should be — all adjustable on request. Alongside memory sits a library: it collects the files you add and the artifacts Claude produces, so new work can build on past efforts.
[1]Rollout and boundaries
- Available in beta starting now to select Pro and Max subscribers (limited to those using cloud sessions with no existing web/desktop projects), expanding over the coming week, then across all of Claude plus Team and Enterprise plans; a waitlist is available for those not yet eligible;
- Existing projects keep working as they do today, upgraded later as the rollout expands to chat and Cowork;
- Threads run in the cloud today; running on your own machine, alongside your local tools and behind your network, is "coming very soon."
Analysis: three judgments
First, the "coordinator + threads" architecture moves multi-agent orchestration from the lab into a consumer product — and it is isomorphic to Anthropic's own internal R&D. Anthropic just disclosed that roughly 30,000 research agents run internally at any moment, with Claude "leading" 26% of AI R&D; now it productizes the same "one coordinator directing a swarm of parallel agents" pattern for external developers. Seen side by side, this is not coincidence but a route: validate multi-agent orchestration in your own R&D loop first, then sell the same paradigm to users. Note the echo in governance design — internally, oversight relies on "agent identity + open communication"; on the product side, it relies on "branches + PRs + merge conflicts." Both anchor agent behavior in auditable, existing engineering mechanisms rather than inventing new supervision tools nobody would use.
Second, "brief it like a chief of staff" marks a formal shift in the interaction paradigm: from instruction engineering to goal management. For the past two years the core prompt-engineering skill was "specifying the task clearly"; the new Projects demands "specifying goals, constraints, and acceptance criteria clearly" — a manager's skill, not a writer's. Claude proactively suggesting work it can pick up, remembering release dates and personnel dependencies, and adjusting reporting cadence to your style are all the productization of "subordinate-ness." The real risk that follows is dilution of oversight rhythm: when agents "keep working after you step away" and phone-based approval becomes normal, human review degrades from pre-flight gating to after-the-fact spot checks — the discipline of reviewing generated PRs line by line will be the last moat of engineers in this era.
Third, shared memory is a moat, and also a new migration cost. "Remember why the export was dropped and who to confirm with before touching billing" — once this kind of organizational memory settles into a project, the project itself becomes an asset: memory is lock-in. This mirrors the "cloud-first, local-later" strategy: data and memory stay in the cloud, and the local version's "coming very soon" is precisely a response to enterprise customers' instinctive vigilance about data residency. Practical advice for team decision-makers: demand from day one that project memory be exportable and auditable — otherwise what you accumulate is not efficiency, but dependency.
[1]Appendix: short-form post (Weibo / X ready)
Claude Code just rebuilt Projects: from "folder" to "conversation." You set the goal; Claude scopes, delegates to parallel threads, opens PRs, tells you merge order — steerable from your phone, keeps working after you leave. Architecture: coordinator + threads, each thread an isolated cloud session on its own branch; conflicts resolve as standard PR merges. Shared memory compounds across threads — the more you use it, the harder to leave. Beta for Pro/Max cloud users first. #Claude #Anthropic #AIAgents
[1]