This is a SasaDaily hypothetical business case.
It is neither an official Anthropic customer case nor based on publicly disclosed real implementation results.
Imagine a 7-person enterprise software integration company with the team composition as follows:
- 1 owner/technical lead
- 1 Project Manager
- 3 software engineers
- 1 Mobile Engineer
- 1 QA
The company connects ERP, membership systems, payments, Web, and Mobile Apps for SMBs.
On the surface, engineers spend most time writing code.
But when it comes to cross-system updates, the real headache is often:
having to update five different areas simultaneously, and everyone needing to know what others have changed.
When the Client Deprecates an Old API
For example, the client plans to retire the original:
v1 Customer API
and switch to the new v2.
This is more than just swapping out one API.
It usually involves changes to:
- Backend Service
- Web Admin
- Mobile App
- Automated Tests
- API Documentation
- Deployment Order
Traditionally, the team might proceed like this:
PM tells the Backend Engineer once.
Then repeats the explanation to the Web Engineer.
Then explains again to the Mobile Engineer.
The Backend Engineer mid-way discovers a renamed field and has to notify others.
The Web Engineer has already coded to the old specs and must redo work.
After all finish, the team still asks:
Which PR should be merged first?
Claude Code Projects aims to improve this coordination effort.
Step One: Humans Define Goals First, No AI Random Changes
The team creates a Claude Code Project.
Clearly stating:
Goal: Deprecate v1 Customer API and update API, Web, and Mobile to use v2.
They also add:
- API Repository
- Web Repository
- Mobile Repository
- Migration Instructions
- Client Requirements
- Project Instructions
Additionally, the team enforces three unskippable rules:
No automatic production deploys.
Stop before executing database migrations.
All auth, payment, or client data structure changes must be approved by the technical lead.
AI can assist with many tasks, but decision authority is clearly outlined first.
Step Two: Coordinator Breaks Down Tasks
Anthropic’s new Projects design lets the top-level Claude handle scoping, delegation, and coordinating parallel threads.
In this scenario, the coordinator might split the work into:
Thread A
Review API Repository to identify all v1 endpoints and replacements.
Thread B
Update v1 calls in the Web Repository.
Thread C
Modify the Mobile Repository.
Thread D
Update automated tests.
Thread E
Compile migration documentation.
These tasks can proceed concurrently.
Engineers no longer have to launch five separate Claude Code sessions and constantly check everyone’s progress across windows.
Step Three: Changes Are Recorded in Shared Memory
Midway, the API Engineer notices:
Originally, the docs had:
customer_total
But it’s changed to:
lifetime_value
Also, the Mobile App requires a two-week backward compatibility period.
If this info remains only in a single chat thread, problems can easily arise later.
Each thread in Claude Code Projects accesses and contributes to the same Shared Memory.
In this workflow, the team captures together:
- Field name changes
- Compatibility timelines
- Release dates
- Reasons for feature removals
- Which person to consult before modifying specific services
All kept in one Project Context.
So subsequent threads don’t have to relearn everything from scratch.
But remember:
Shared Memory doesn’t mean automatic code synchronization.
Every thread still works on its own branch and repository copy.
Step Four: Each Thread Updates and Tests Independently
According to Anthropic, once repositories are connected, each thread can:
- Modify code
- Run tests
- Create pull requests
So, for example, the Web thread can:
Change code
→ Run tests
→ Open a PR.
The Mobile thread follows the same steps in its branch.
The real time saving comes not just from coding speed, but shifting from:
“One finishing before the next starts” to
parallel work proceeding simultaneously.
Step Five: Coordinator Organizes but Does Not Trigger Production Deploy
When all five threads complete, the coordinator helps by summarizing:
- Which PRs are ready
- Test pass status
- Dependencies among tasks
- Recommended merge order
- Outstanding issues
But the team retains final decisions.
Human gates remain for:
① Architecture
Is the new API design truly aligned with client needs?
② Merge
Can all branches safely integrate?
③ Database Migration
Should production data structures be changed?
④ Auth/Payment
Login, permissions, and payment changes must not be solely approved by AI despite tests passing.
⑤ Production Deploy
The final deployment is approved by the technical lead.
This is crucial.
Anthropic also clarifies that if two threads modify the same code area, genuine merge conflicts may still occur.
The coordinator can manage AI,
but software engineering risks don’t simply disappear.
How to Estimate ROI?
This isn’t about unproven claims like “AI saves 80% development time.”
Instead, focus on a more quantifiable measure:
cross-person coordination time.
Assume the company gets 3 cross-repository change requests per week.
Previously, weekly coordination takes about:
- Re-explaining context
- Syncing specs
- Checking progress
- Organizing handoffs
- Confirming merge order
Roughly:
6 hours/week.
After adopting this workflow, it reduces to approximately:
3.5 hours/week.
Saving:
2.5 hours/week.
Over a four-week month:
About 10 hours/month saved.
Assuming an internal blended engineering cost of:
NT$900/hour
Theoretical time value saved is:
NT$9,000/month.
But this doesn’t directly translate to extra NT$9,000 profit each month,
because it must be offset by:
- Claude usage fees
- Additional QA
- Code reviews
- Merge conflict resolution
- Onboarding and learning costs
- Rework caused by AI errors
Therefore, the key KPIs to track are not “number of Agents deployed.”
Instead, track:
Has handoff time decreased?
Has rework increased?
Has PR lead time shortened?
Has production incident frequency risen?
What Does This Case Really Change?
The old process resembled:
Humans distribute work
→ Humans repeatedly explain context
→ Everyone works individually
→ Humans track progress
→ Humans manually integrate.
Claude Code Projects aims to shift this to:
Humans define goals and boundaries
→ Coordinator breaks work into threads
→ Multiple threads run in parallel
→ Shared Memory maintains common context
→ AI organizes the outcomes
→ Humans review
→ Humans approve merge, migration, and deploy.
AI is best suited not to own the entire software project,
but to handle large volumes of repetitive tasks such as:
breaking down work, moving context, tracking progress, and summarizing results.
Final decisions impacting customers, data, and production remain with humans.
If you want to find out which steps in your workflow are best to assign to AI first, comment "process," and I can help identify a starting point.
Today, make progress together with AI.
Learn one AI skill every day.
Save a little time every day.
Improve your abilities a bit every day.
SasaDaily, growing with you.
