I’ve spent most of the last week testing the new Claude Code Projects.

Not the old version where you dump a bunch of files into a folder and start separate chats.

The new version connects to your GitHub repo, takes what you want to build, then acts as the orchestrator for the entire thing.

• It decides what needs to be done.
• Splits the work into separate threads.
• Then each thread builds its part and opens its own PR in GitHub.

In theory, this is exactly what I want.

I tell it what to build once and come back to a stack of finished features.

But after a week of testing it properly…

I don’t like it.

At least not yet.

too many threads, not enough coordination

The first problem is that it makes a lot of small mistakes.

I’ll explain a feature and Claude will split it into a bunch of threads that all start working at the same time.

Which sounds great until those threads need something from each other.

One thread changes the navigation.
Another builds the page.
Another updates a shared component they both use.

From what I can tell, they aren’t properly communicating as they work.

Each thread seems to know what the repo looked like when it started, but not necessarily what every other thread has changed since.

So one PR gets merged, then the next PR arrives without those changes accounted for.

Individually, both PRs can look fine.

Together, there are gaps everywhere.

The most annoying version of this is the UI stuff.

A page gets built but the URL isn’t wired up.

A button looks finished but doesn’t go anywhere.
The navigation changes in one thread but the page from another thread never gets added to it.

Basic things Claude usually catches when I’m building one feature from start to finish.

None of it is difficult to fix.

There’s just a lot of it.

So instead of reviewing a finished feature and merging it, I’m opening every page, checking every button, testing every route and sending it back to fix all the missing pieces.

The work happens faster in parallel, but the finished result takes longer to trust.

it burns through tokens

The second problem is usage.

Claude Projects can spin up a lot of threads at once.

Every one of those threads is reading the repo, planning, writing code, running tests and opening a PR.

Then when the threads create mistakes between each other, Claude burns through even more tokens trying to work out what went wrong and fix it.

There is one genuinely good feature here.

When you hit your usage limit, Claude can automatically prompt itself to continue once the next window opens.

So the work can keep moving without you coming back to restart it.

But continuing automatically is only useful if the work is worth continuing.

For the first time, I burned through my entire weekly allowance in three days.

And that’s on the 5x plan.

Normally, when I manage the features one at a time, I can build far more before getting anywhere near that point.

This week I had more threads running than ever…

But fewer finished features I was actually happy to merge.

More activity didn’t create more output. It created more things to fix.

i think it’s just too early

I don’t think Claude Projects is a bad idea.

I actually think this is probably what building software will look like in the future.

Give AI the outcome.
Let it split up and manage the work.
Come back when it’s finished.

Once the models are better, the threads can coordinate properly and we have access to a lot more compute, I think this feature will be great.

But right now, it’s too early.

The models make too many small mistakes.
The parallel threads create too much cleanup.
And the amount of usage it takes to get to a finished result is too high.

Right now it feels like I traded control for parallelism, then spent all the time I saved cleaning up afterwards.

The idea is right.

I just don’t think the models or the compute are ready for it yet.

In the next email, I’ll show you the workflow I do like.

It still lets AI run almost the entire thing.

It can work 24/7, and I only need to step in for the specific decisions I’ve trained it to bring back to me.

But instead of trying to build everything at once, it works through one feature at a time.

1. Build it.
2. Verify it.
3. Merge it.
4. Then move on.

It’s the middle ground between manually sitting inside Claude, managing every feature and reading every PR…

And handing the whole project to an orchestrator that spins up a pile of threads and hopes they all fit together at the end.

I’ll break down the full workflow in the next email.

For now, I want to know how you’re using Claude Projects.

Do you like it? Have you found a workflow that actually works? Or are you seeing the same problems I am?

Reply and let me know.

Talk soon,

Mitch