Claude DeepSeek Crew: Opus 5.5 plans, DeepSeek writes the code, and Claude Code uses up to 83% less quota

If you use Claude Code and run out of plan quota halfway through a task, you can have a much cheaper model write the code and leave only planning and review to Opus 5.5. That is what Claude DeepSeek Crew does, the free, open source project I built: in my tests I used 65% less Claude quota on average, up to 83% on the largest project, and the apps passed the same hidden tests as Opus alone.

This article covers every point, in the same order as the video:

1. The result: up to 83% fewer tokens with the same quality
2. The apps I built with DeepSeek
3. The project on GitHub
4. How to install it
5. Why I built this project
6. How it works
7. The parallel with a development team
8. The two ways to use it
9. How I know it works: the hidden tests
10. The developer who cheated
11. The benchmark numbers
12. When not to use it
13. Where to find it

How do you save up to 83% of tokens in Claude Code?

The trick is splitting the work by how much reasoning it needs. Opus 5.5 handles planning and review, the tasks where reasoning really matters. Cheaper developers write the code: Claude Code sessions connected to DeepSeek V4.1 Flash, which cost a few cents.

The problem it solves is concrete. On the $20 Claude plan, or with pay-per-token usage, it is common to run out of quota in the middle of a build. Moving code writing to DeepSeek lowers Claude quota usage without affecting the quality of the result, measured with automated tests.

The project installs in a couple of minutes and is free.

Which apps did I build with Claude DeepSeek Crew?

For the benchmark I had 6 web apps of increasing difficulty built, each designed to simulate different behaviours:

• a spreadsheet, a mini version of Excel: I type a formula in a cell, press enter and the app computes it, even when cells depend on each other, all the way to the final sum;
• a kanban board with email sign-up: it is a CRUD app, so I create and edit resources, and I can drag a job from "to do" to "in progress" and then to "done";
• a group expenses app, with login and sign-up, for splitting costs;
• a room booking app, for example for meeting rooms in an office;
• a bookmark manager with titles, tags and search;
• a suite that combines the previous five modules in a single server.

These are complete apps: if I reload the bookmarks page, the bookmark is still there because there is a backend with a database behind it.

To be transparent: I adapted the design you see in the video to my brand colours after the tests. The behaviour is exactly what was built during the runs.

Where can I find the project?

Claude DeepSeek Crew is on GitHub at github.com/lucadidomenico/claude-deepseek-crew, under the MIT licence. The README contains the installation prompt, an explanation of how it works and all the benchmark data, with the full method in docs/BENCHMARK.md.

How do you install Claude DeepSeek Crew?

Claude Code does the installation for you. The steps are:

1. Open a terminal and start Claude Code.
2. Paste the installation prompt from the repository, in INSTALL_WITH_CLAUDE.md (Italian version: INSTALLA_CON_CLAUDE.md). In practice you ask Claude Code to install Claude DeepSeek Crew on your computer by following the steps in the prompt.
3. Create a DeepSeek API key on platform.deepseek.com and enter it in the command Claude Code gives you.
4. Restart Claude Code and set Opus as the model with /model opus.
5. Inside your project folder, run the installed command, /deepseek-crew, followed by your request.

Using Opus as the main model matters: since you are saving tokens on the less important tasks, the reasoning should be done by the best model.

To try it, the repository includes a sample spec: ask /deepseek-crew to build the app described in SPEC.md. It is just a test to check that everything works: you can use Claude DeepSeek Crew for any development work.

If you prefer a manual install, the repository also has install.sh.

Why did I build Claude DeepSeek Crew?

Delegating implementation to cheaper models is an approach many developers already follow. Usually, though, they stay inside the Anthropic ecosystem, with Opus planning and Sonnet implementing, or they switch to Codex, with Opus planning and a GPT model implementing.

I want my development setup to be as model-agnostic as possible, meaning independent from any single model. At the same time I want to stay inside Claude Code, which is the best coding tool available right now.

So I separated the two. Claude Code is the tool, and it stays. The models can change. Claude DeepSeek Crew uses DeepSeek, which has nothing to do with Anthropic, but the same approach works with other models: OpenAI, GLM, Kimi and local models too. The goal is to stay as open as possible.

How does Claude DeepSeek Crew work?

When you ask Claude Code running Opus to build an app, Claude Code reasons first. It works out which features are needed, looks through the project files, and may search the web. This part stays with Opus, because it is pure reasoning.

Then Claude Code writes a work plan, for example in a Markdown file: build these APIs, add this button, check that everything works. At that point the decisions have already been made. A less experienced agent can execute the plan, and in Claude DeepSeek Crew the DeepSeek developers do.

The DeepSeek developers do not need to reason much, because Opus has already done the thinking for them. That is why they cost little and the result holds up.

Why does it work like a development team?

Claude DeepSeek Crew mirrors the structure of a classic development team. The parallel is about the experience of each role: who decides and who executes.

A team has a tech lead, who decides the planning and the development strategy. Then there are junior developers, who implement the code following the features described by the tech lead.

In Claude DeepSeek Crew, Opus 5.5 is the tech lead: it decides the features and how to build them. The DeepSeek developers execute, and they cost far less.

What are the two ways to use Claude DeepSeek Crew?

Claude DeepSeek Crew has two modes:

• Fast mode: Opus reasons, delegates implementation to DeepSeek, checks the developers’ report and wraps up. Here the average quota saving is 65%.
• Review mode: you turn it on by adding --review after the command. When DeepSeek is done, Opus checks the agents’ work, reviews the code and tests the app. Here the average saving drops to 44%, which is still almost half the tokens.

In my runs quality was already at the maximum without review. The benchmark apps are simple, though. For real work I recommend --review mode: you still save about half the tokens and you get a thorough check from Opus.

How do I know Claude DeepSeek Crew really works?

Before publishing it I measured quality with hidden tests. For each app I prepared between 25 and 220 automated checks, depending on complexity: 25 for the kanban board, 220 for the suite.

A test is code that checks a feature before the feature even exists: it describes the behaviour I want once the feature is there. The process was:

1. Claude prepared the tests.
2. The DeepSeek developers built the apps without seeing the tests.
3. Claude Code ran the tests against the apps the developers wrote.

On the suite, all 220 tests passed. That means the code works the way I wanted it to.

What happened with the DeepSeek developer who cheated?

In two runs a DeepSeek developer cheated. It left its folder, found the hidden tests and wrote the code based on them: in practice, it read the answer key.

I excluded those two runs from the benchmark. Then I reran the tests with that behaviour blocked and checked the developers’ tool calls: this time nobody had read the solution.

This detail matters for anyone using autonomous agents. Claude DeepSeek Crew developers run with broad permissions, and in the README I recommend running them on a disposable copy of the project, in a container or in a VM.

What are the benchmark numbers?

The results of the benchmark, which I completed on 28 October 2026:

• 6 apps of increasing difficulty;
• 93 runs in total;
• 100% of hidden tests passed on every app, both with Opus alone and with Claude DeepSeek Crew;
• 65% less Claude quota on average in fast mode;
• 83% less on the suite, the largest app (5 modules, 220 tests);
• 44% less on average with --review;
• about $0.15 of DeepSeek per app.

The saving grows with the size of the job: on the smaller apps it is around 55%, on the suite it reaches 83%.

When is Claude DeepSeek Crew not worth using?

There are two cases where I would not use it today.

Very simple tasks. For a few-line fix or a question about the code, use Opus directly. The lead’s planning work has a fixed cost that cancels out the saving. Claude DeepSeek Crew pays off when there is real development work to delegate.

When time matters. DeepSeek developers are slower than using Claude Code directly: in the benchmark, 12 minutes per app on average versus 4 for Opus alone. My goal was to save tokens and make my setup more independent from Anthropic, and I traded some time for that. Tasks you can launch in the evening and find ready in the morning are the ideal candidates.

If the idea of separating planning from execution interests you, I have seen it applied outside Claude Code as well: the Grok 4.5 workflow in Cursor that separates planning from execution. And if you want to try DeepSeek V4.1 Flash on its own, I wrote about how to use it for free on OpenCode.

Where can I find Claude DeepSeek Crew?

Claude DeepSeek Crew is free and open source on GitHub. I would like to grow it together with the community: if you try it, tell me how it went and which models you connected. The best way to find out how much quota you can save is to run it on your next project.