Developer Replaces Claude Code with Local Qwen and DeepSeek Models: Dev Cycle Gets 3–4x Longer

When your favorite tool is taken away, you have two options: look for a cloud replacement, or find out what the models running under your desk can do. After his third Claude Code account block, the author of this story chose the second. He refused to hand over his passport details for verification and moved to local Chinese open-weight models. Below, we look at what he achieved and what you can take from it.

What the setup is and how it works

The hardware comes from his employer, a company that rents out NVIDIA DGX Spark machines. Qwen 3.8 Flash Next runs on one Spark with a 256K context. DeepSeek-V4.1-Flash-1017 runs in EXL3 quantization on two Sparks with a 512K context. The engine in both cases is TensorFold.

The author had Qwen itself handle the DeepSeek deployment. The model, running on the neighboring Spark, scouted the machines, gathered the requirements and wrote Ansible playbooks. It took about a working day, and DeepSeek started on the first attempt. For Qwen, that is a decent test: it solved an infrastructure task autonomously.

For the harness, the author uses a minimalist Pi in WSL, and he built a plugin for PhpStorm for convenience. Subagents save context in the main session. The tasks are real: PHP on Symfony, Go and Kubernetes.

The numbers: fast to generate, slow to read

The author wrote his own benchmark: 10 measurements each at contexts from 2K to 128K, using unique prompts with random salt, so the prefix cache does not help. Here is what he got.

• Qwen on one Spark produces 70–80 tok/s. DeepSeek on two produces 99–109 tok/s.
• Per Spark, the picture reverses: 70–80 tok/s for Qwen versus 49–55 for DeepSeek. Doubling the hardware yields a gain of only 1.36–1.5x.
• Prefill is 2.3–2.5K tok/s for Qwen and 1.7–2.3K tok/s for DeepSeek.

That gives a time to first token at 128K of 57 seconds for Qwen and 73 seconds for DeepSeek, even though DeepSeek generates faster. At 32K it is 13–21 seconds, and at 64K it is 27–36 seconds. Outliers happen too: DeepSeek had requests with a TTFT of 4.8 s at 2K and 10.2 s at 8K.

An important caveat: this is a cold pass over the full prompt. In an agent loop, the context grows gradually and the prefix sits in the cache, so real latencies are noticeably lower.

A workflow built on two models

The author's main finding is about process, not speed. For a large task, both models write plans separately. Then each reads its "colleague's" plan and decides which one to use as the basis. In most cases the two agreed: they picked the DeepSeek plan, and only once did both choose the Qwen plan.

Implementation comes next. In the simple variant, DeepSeek does it with subagents and a separate commit for each step, while the author reviews the commits in parallel and collects comments. Then come reviews in a fresh context, first by DeepSeek and then again by Qwen. In the complex variant, the two models work in parallel in different worktrees, and the author picks the better solution. Testing is organized the same way: two e2e plans are crossed, the models run them in turn and fix bugs, and then come mandatory manual checks, staging and release.

Limitations and takeaways

The price of this freedom is high. By the author's preliminary estimate, the development cycle became 3–4 times longer than with Claude Code. He attributes part of that to unfamiliarity and to duplicated work across two models, and he plans to settle on one. By feel, DeepSeek is roughly 20% smarter and more attentive than Qwen, but it requires two Sparks. This is one person's judgment without any formal quality evaluation, so treat it as subjective.

A side test is revealing too. In an hour, DeepSeek set up Hogwarts Legacy to run in VR: it found an injector, downloaded profiles and wrote a script with instructions. When it did not work on the first try, the model diagnosed the problem on its own in another half hour. The author is sure Opus 5.5 would have managed it several times faster, but for many tasks, open models are already good enough.

The practical takeaway for teams: a local stack works as insurance against account blocks and as an option for a closed environment where code cannot be sent to the cloud. But budget time for prefill waits, for setting up the process and for hardware. If you have one Spark, take Qwen; if you have two, try DeepSeek. Next, the author plans to test GLM 5.3 Flash on two Sparks.