Anthropic has overhauled the Projects feature in Claude Code. A project no longer just collects context and files, but independently distributes tasks across multiple threads running in parallel. The feature is in beta and is initially available to users of the Pro and Max subscriptions.
From context container to dispatcher
Until now, Projects was primarily a place where work in progress, files and instructions for a venture come together. With the rebuild, the project additionally takes on a coordinating role: it accepts a task and ensures that subtasks are worked on side by side instead of going through them one after another in a single conversation.
In technical terms, this is a step towards agentic AI — that is, AI systems that not only respond to individual inputs but independently plan and execute multi-step workflows. The orchestrator distributes, the individual threads get it done. For development teams, the interaction shifts: less prompt-by-prompt dialogue, more task description and result review.
What parallelism changes in everyday work
The practical gain lies where tasks are already independent of one another. Typical candidates in web and software projects:
- Writing or adding tests for multiple modules
- Recurring adjustments across many files, such as renames or signature changes
- Updating documentation while refactoring takes place elsewhere
- Sketching several solution variants for a problem in parallel and then comparing them
Where subtasks depend on one another, however — data model before interface, interface before frontend — parallelisation brings little and in the worst case creates conflicts that someone then has to resolve. The question of which work can sensibly be split up at all remains a technical decision and does not automatically move to the tool.
The bottleneck shifts to review
When several threads produce code at the same time, more material that needs checking is created in a shorter time. The bottleneck in the process thus shifts from implementation to review. Teams that already struggle to review pull requests promptly will amplify this problem if they increase output without factoring in review capacity.
What helps in this situation are mechanisms that take effect independently of the author: automated tests with robust coverage, static analysis, linting rules, a clear definition of done. The more strongly quality assurance is anchored in the build, the more readily additional throughput can be processed at all. Without this foundation, faster code production mainly produces a faster backlog.
Assessment for project managers
The announcement initially concerns a single tool and a beta version. How robustly the distribution works in larger codebases, how well the results from different threads fit together and how the consumption of quotas behaves will only become clear in practical use. Betas are betas: behaviour and feature scope can change.
Nevertheless, the direction is noteworthy. Providers of coding assistants are visibly moving away from the model of "one chat, one task" towards systems that coordinate multiple workstreams. Anyone planning development processes today should assume that this mode of operation will become more normal in the coming cycles — regardless of which product ultimately prevails.
What teams can start with now
A sensible start does not require converting the entire toolchain:
- Sort task types. Which work in your own project is actually independent? This list is the basis for any parallelisation, with or without AI.
- Harden the review path. Set up test coverage, CI pipeline and review rules so that they can withstand higher throughput.
- Test in a bounded area. Choose a manageable area where errors show up early and cause little damage — for example internal tools rather than production customer logic.
- Measure results. Not just the time to the first draft, but the time to the approved state including rework.
It is also worth looking at the organisational side: who is responsible for code that an agent has generated? Which areas of a repository are off-limits for automated changes? Such determinations cost little effort but prevent discussions at a point when they become expensive.
What this means for web and software projects
For projects in TYPO3, custom web development or interface work, parallel processing promises speed above all for broadly distributed, uniform tasks — not for technical conception. The decisive lever therefore lies less in the tool than in a process that can reliably review and integrate additional output. Those who tidy up their test basis and review capacity beforehand benefit from agentic tools; those who do not merely shift the bottleneck one station further back.
Sources
- Claude Code: Anthropic macht aus Projects einen Auftragsverteiler — heise developer News