Anthropic Turns Claude Code Projects Into a Parallel AI Development Team

For years, the pitch for AI coding tools was wonderfully simple: give developers a smarter assistant.

Anthropic is now aiming considerably higher.

On September 17, 2026, Anthropic unveiled a major redesign of Projects in Claude Code, transforming the feature from what was essentially an organized workspace into something much closer to a coordinated team of AI agents. Instead of developers manually splitting a complicated job across several Claude sessions, keeping those sessions organized, and eventually stitching everything back together, Claude can now orchestrate much of that process itself. (Claude)

Give the project a goal. Claude scopes the assignment. It delegates pieces of the job to separate threads. Those threads work simultaneously. Claude reviews their results and coordinates the final output.

And because the work happens in the cloud, those agents don’t necessarily stop just because you close your laptop.

That seemingly small detail tells us quite a lot about where AI coding is heading.

This isn’t merely about getting autocomplete on steroids anymore. Anthropic is trying to turn Claude Code into something developers can delegate entire chunks of work to.

Welcome to the era of the AI development team.

Claude Projects Gets a Serious Promotion

The old concept behind Projects was familiar.

Create a workspace. Add relevant information. Keep conversations and files associated with a particular task together.

Useful? Absolutely.

Revolutionary? Not exactly.

Anthropic’s redesigned version changes the basic interaction.

According to Anthropic’s announcement, developers can now tell Claude what they want accomplished rather than manually organizing every individual session required to accomplish it.

Claude then becomes the coordinator.

Projects contain individual threads, which perform the actual work, while a central coordinator directs those threads.

Imagine telling a technical lead:

“Here’s the objective. Figure out how we’re going to get there.”

That’s roughly the experience Anthropic is pursuing.

The coordinator can scope the request, assign work, run several threads simultaneously, review their outputs and assemble the results. Developers can still intervene whenever necessary rather than surrendering control of the process completely. (Claude)

That makes the redesign much more than a cosmetic overhaul.

Projects is shifting from a place where developers organize AI conversations into a system where AI can organize work.

That’s a much bigger idea.

Meet the Coordinator and Its AI Workers

The architecture is surprisingly easy to understand.

At the top sits Claude, acting as the project’s coordinator.

Underneath are threads.

Each thread is effectively an independent Claude Code cloud session operating on its own branch and copy of a repository. Those sessions can tackle different assignments simultaneously. (Claude)

Suppose you’re preparing a major software update.

One thread could investigate an API issue.

Another could modify the frontend.

A third might work on tests.

A fourth could handle another repository entirely.

Instead of opening four separate Claude sessions yourself and repeatedly explaining what’s happening, the project coordinator keeps the overall objective organized.

Even better, individual threads aren’t necessarily limited to doing everything sequentially.

Anthropic says threads can further divide assignments through subagents, loops and workflows when necessary. (Claude)

That’s AI delegation inside AI delegation.

Things are getting delightfully recursive.

Developers can watch everything from the main project conversation or jump directly into individual threads when they want more control.

The human hasn’t disappeared.

The human’s role is simply moving upward—from manually directing every individual operation toward managing the larger objective.

Anthropic’s Checkout Example Shows Why This Matters

Anthropic provides a particularly useful example.

Imagine an online store has a performance problem. The company wants to reduce its checkout latency.

Traditionally, that goal could produce a surprisingly long list of engineering tasks.

Which endpoints are slow?

Where are the bottlenecks?

What optimizations might work?

Will those optimizations break anything?

Have the changes been tested?

Who creates the pull requests?

With the redesigned Projects, a developer could establish the performance goal and let Claude organize multiple threads to investigate different endpoints simultaneously.

Those threads can profile endpoints, experiment with optimizations, run tests and open pull requests. (Claude)

Suddenly, “make checkout faster” isn’t merely a prompt requesting suggestions.

It becomes a project.

Anthropic gives another example involving several repositories. A company retiring an old API could connect its API, web and mobile repositories. Claude could then create separate threads to migrate callers in each repository, run tests and open pull requests.

The coordinator can subsequently explain which changes should merge first.

That’s important because real software development rarely involves one neat file and one neat task.

Real projects are messy.

They span repositories, teams, dependencies, tests and decisions.

Anthropic is designing Projects around that mess.

The Agents Can Keep Working Without You

Here’s where things become particularly interesting.

These threads operate in the cloud.

That means they don’t necessarily depend on the developer keeping a local machine active throughout the job.

Anthropic says Projects can continue working after someone steps away from their computer, and developers can monitor or steer progress—including from a phone. (Claude)

That subtly changes the relationship between developer and coding assistant.

Traditional AI coding assistants largely wait.

You type.

They respond.

You approve something.

They continue.

Cloud agents can operate more asynchronously.

A developer could assign work, leave, and return later to see what happened.

The project’s threads might have run tests, produced documents, modified code or opened pull requests during that period, depending on the assignment and available connections. (Claude)

That’s much closer to delegation than conversation.

It doesn’t mean Claude suddenly becomes an autonomous software company. Developers still need to establish goals, inspect important changes, handle conflicts and determine whether the output is actually suitable for production.

But the workflow is changing.

The question increasingly isn’t:

“What should I ask the AI next?”

It’s becoming:

“What work should I assign it?”

That distinction could become enormously important.

Shared Memory Tackles One of AI Coding’s Biggest Annoyances

Anyone who has worked extensively with AI knows the ritual.

Explain the project.

Explain the architecture.

Explain the weird decision the team made Tuesday.

Explain why that weird decision actually makes sense.

Start another conversation.

Explain everything again.

Anthropic wants Projects to reduce that repetition.

Every thread contributes to and draws from a shared project memory. Over time, Claude can retain relevant details about decisions, schedules and project-specific requirements. (Claude)

Anthropic gives examples such as remembering that a release moved to Friday, understanding why a feature was removed, or knowing who should be consulted before changes are made to a billing service.

Projects can also learn preferences about how someone wants Claude to work.

Users can adjust how often Claude provides updates, how readily it creates new threads and how detailed those updates should be.

There’s also a project Library.

The Library gathers uploaded material alongside artifacts Claude produces, giving future threads access to information accumulated during earlier work. (Claude)

That’s potentially significant.

The useful unit of AI interaction stops being a single prompt.

Instead, it becomes an evolving workspace containing decisions, files, history, instructions and work produced over days—or potentially much longer.

Parallelism Is the Real Superpower Here

A developer has something AI agents don’t particularly care about:

only one pair of hands.

Even talented engineering teams encounter the same constraint. Humans can divide work across people, but adding people introduces communication and coordination costs.

Software agents introduce another possibility.

Spin up more workers.

Anthropic’s Projects can run several full Claude Code sessions simultaneously. (Claude)

That doesn’t automatically mean four agents accomplish four times as much work. Parallel work can introduce duplication, conflicting changes, higher compute consumption and additional review requirements.

But certain engineering problems naturally divide into independent pieces.

Testing several endpoints is one example.

Working across separate repositories is another.

Research, documentation and implementation might also run concurrently.

That’s where agent orchestration becomes powerful.

Instead of making one extraordinarily capable AI perform everything sequentially, developers can potentially divide a problem among several capable agents and coordinate their outputs.

Other AI companies are exploring similar multi-agent and parallel-agent concepts, making orchestration an increasingly important frontier in AI development tools. Anthropic’s implementation is notable because it embeds that model directly into the everyday structure of Claude Code Projects. (The Decoder)

The race isn’t only about building smarter models anymore.

It’s also about getting models to work together effectively.

There’s Still a Very Human Problem: Merge Conflicts

AI agents may be futuristic.

Git remains Git.

Each Claude Code thread operates on its own branch and repository copy. If multiple threads modify overlapping pieces of code, Anthropic says those conflicts are resolved through ordinary merge-conflict procedures. (Claude)

In other words, Claude hasn’t abolished one of software development’s favorite little headaches.

Perhaps some traditions are immortal.

More seriously, this illustrates an important design choice.

Anthropic isn’t pretending parallel agents magically eliminate the realities of collaborative software engineering.

Instead, it’s plugging agents into workflows developers already understand.

Threads have branches.

They can open pull requests.

They can run tests.

Changes still need to fit together correctly.

The coordinator organizes the process, but coordination isn’t the same thing as guaranteed correctness.

This matters because the more work developers delegate to AI, the more important verification becomes.

Parallel agents can potentially generate more work faster.

They can also generate more work that needs reviewing faster.

The productivity equation therefore depends on whether orchestration reduces enough manual effort to outweigh the additional review and compute requirements.

Anthropic clearly believes it can.

The beta should give developers an opportunity to test that proposition on real projects.

More AI Workers Also Means More AI Usage

There’s another practical catch.

Parallel agents aren’t free workers.

Every thread is a full Claude Code session.

Run several simultaneously and you’re naturally consuming more resources than you would with one session.

Anthropic explicitly warns that Projects can reach usage limits more quickly because multiple threads may operate concurrently. Users can inspect project-specific usage and choose the models and effort levels assigned to both the coordinator and worker threads. (Claude)

That introduces an interesting optimization problem.

Maybe the coordinator needs a highly capable model.

Maybe routine worker tasks can use something lighter.

Perhaps difficult debugging deserves more reasoning effort while straightforward documentation doesn’t.

Developers may increasingly manage AI compute the way engineering managers allocate human resources.

Which model should handle this?

How much reasoning should it use?

Should we create another worker?

Is parallelizing this task worth the additional consumption?

AI coding could therefore develop its own strange version of workforce planning.

Except instead of worrying about whether Dave from backend has enough bandwidth, you’re deciding whether Thread Seven really needs that many tokens.

Welcome to management.

Claude Code Is Becoming More Than a Coding Assistant

The larger story isn’t one individual Projects feature.

It’s the direction Anthropic is taking Claude Code.

Coding assistants initially became popular because they accelerated small tasks: generating snippets, explaining unfamiliar code, writing tests and fixing bugs.

Agentic systems expanded that scope.

Now an AI could inspect a repository, modify files, run commands and work through a larger objective.

Projects pushes the idea another step.

The unit of delegation becomes larger again.

Rather than assigning Claude a coding task, developers can assign it something resembling a workstream.

VentureBeat described the redesigned system as an “always-on” environment for persistent development work, while The Decoder emphasized its parallel agent workflows. (Venturebeat)

Those descriptions capture the broader transition well.

AI coding tools are gradually moving through three stages:

assistant → agent → coordinated agents.

Each step reduces how much orchestration the human needs to perform manually.

That doesn’t eliminate developers.

It potentially changes what developers spend their time doing.

Less session babysitting.

More architecture, direction, evaluation and decision-making.

At least, that’s the ambition.

Anthropic Is Starting Small With the Rollout

Don’t go hunting through Claude Code and assume something is broken if Projects hasn’t transformed yet.

The redesigned experience is still a beta.

Anthropic initially made it available to selected Claude Pro and Max subscribers who use cloud sessions in Claude Code and don’t already have existing projects on the web or desktop. (Claude)

The company says access will expand to more Claude Code users on those plans over the following week.

Broader availability across Claude, including Team and Enterprise plans, is planned afterward. Existing Projects aren’t suddenly disappearing either; Anthropic says they’ll continue working while the rollout progresses. (Claude)

Cloud operation is another temporary limitation.

Threads currently run in Anthropic’s cloud environment, but the company says support for running them alongside local tools, local code and resources behind private networks is coming soon. (Claude)

That future capability could matter enormously for enterprise developers whose important infrastructure isn’t sitting conveniently in a publicly accessible environment.

For now, Anthropic gets something equally valuable from the limited beta:

real-world feedback.

Coordinating one AI is challenging enough.

Coordinating several simultaneously is where things get genuinely interesting.

The AI Coding Race Has Entered Its Management Era

The most interesting thing about Anthropic’s announcement may be what it says about the AI industry’s priorities.

For years, AI companies competed largely on model intelligence.

Whose model writes better code?

Whose model solves harder problems?

Whose benchmarks are higher?

Those questions still matter.

But another competition is emerging around orchestration.

A tremendously capable model still has limited value if users must constantly provide context, divide every problem manually and supervise each step.

The next productivity jump may therefore come partly from systems that organize models—not merely models that become smarter.

Anthropic’s redesigned Projects embodies that idea.

One coordinator understands the objective.

Multiple threads attack different pieces.

Shared memory keeps everyone working from the same evolving context.

The Library preserves useful material.

Developers supervise the system rather than manually operating every session.

That’s starting to resemble a small software team.

Except the entire team is Claude.

And unlike your coworkers, none of the agents will schedule a meeting to discuss scheduling another meeting.

From Pair Programmer to AI Engineering Team

Claude Code Projects represents something larger than another feature update.

Anthropic is testing a different model for human-AI collaboration.

The developer provides intent.

Claude coordinates execution.

Specialized threads perform work simultaneously.

Shared memory preserves context.

Cloud sessions keep running even when the developer leaves.

Then the human returns to inspect, steer, approve and make decisions.

That workflow won’t fit every programming job. Small fixes don’t need an army of agents, and parallel execution creates genuine costs and coordination challenges.

But large, multi-part engineering assignments are exactly where the concept becomes compelling.

If Anthropic can make orchestration reliable, developers may eventually stop thinking about AI coding tools as individual assistants altogether.

Instead, opening Claude Code could feel more like walking into a project room.

You explain what needs to happen.

The coordinator divides the assignment.

Several agents get to work.

And you concentrate on whether they’re building the right thing.

AI coding started with autocomplete.

Then came chatbots.

Then agents.

Now we’re giving the agents coworkers.

Things escalated quickly.