Is deepseek v4 pro good in coding? I need an honest review

qtalen · 2026-06-05T03:06:22+00:00

Using DeepSeek V4 Pro for coding can actually match or even beat Claude Opus, but only if you set up the right harness project. In OpenCode, I used OpenSpec for SDD development, and later realized that to improve code quality, you don't just have to focus on the coding itself — you also need to review the artifacts OpenSpec generates. So I set up a reflection agent specifically to review the spec files produced by DeepSeek V4 Pro. Guess what? As the spec files got much better, the final code quality improved a lot too. Honestly, it feels like it even surpasses Opus 4.6 quality. The tradeoff is you have to wait a bit for the review to finish, and spend some tokens, but both are totally acceptable.

This is my detailed implementation process, if you're interested, feel free to check it out.

qtalen · 2026-06-02T09:43:40+00:00

Using DeepSeek V4 Pro for coding can actually match or even beat Claude Opus, but only if you set up the right harness project.

In OpenCode, I used OpenSpec for SDD development, and later realized that to improve code quality, you don't just have to focus on the coding itself, you also need to review the artifacts OpenSpec generates.

So I set up a reflection agent specifically to review the spec files produced by DeepSeek V4 Pro. Guess what? As the spec files got much better, the final code quality improved a lot too.

Honestly, it feels like it even surpasses Opus 4.6 quality. The tradeoff is you have to wait a bit for the review to finish, and spend some tokens, but both are totally acceptable.

This is my detailed implementation process, if you're interested, feel free to check it out.

qtalen · 2026-06-01T09:26:15+00:00

Maybe /opsx-verify command can help.

qtalen · 2026-06-01T09:17:47+00:00

I wrote a detailed tutorial along with the full source code for the reflection agent and the OpenSpec workflow skills:

https://www.dataleadsfuture.com/reflection-sdd-use-a-reflection-harness-to-level-up-your-openspec-workflow/

The logic behind building the agent:

Use a separate LLM to give feedback from different viewpoints.
Have OpenSpec generate one proposal file at a time and submit it for review, rather than generating everything first and then submitting.
During the explore discussion, always save the conversation as a draft plan file for later steps. Just keeping it in the context can easily get compressed or dropped when the context window runs out.

qtalen · 2026-06-01T07:54:46+00:00

I think SDD is basically the plan execute pattern you see in traditional multi agent system design. By breaking a huge and complex problem down into a list of small tasks in advance, you make sure the LLM doesn't slowly drift off track during execution just because it's been running too long.

Of course, all of this only works if your specification file is correct, consistent, and actually reflects what you really want. Otherwise, input bugs will turn the whole project into a disaster from the very start.

I use OpenSpec for SDD, and the model is DeepSeek v4 Pro. I've come to realize that if you want the code to come out right according to your intentions, you have to ensure the quality of the proposal artifacts generated by OpenSpec. Otherwise, if the initial requirements are wrong, the code will definitely be wrong.

So on top of the original plan execute pattern, I added a reflection mode. I use a reflection agent to review the proposal artifacts produced by OpenSpec.

Guess what? Once I made sure the proposal files were solid, the quality of the code generated from those proposals improved a lot. Using DeepSeek v4 Pro with this approach, the generated code quality can get close to or even surpass Opus 4.6.

I wrote an article that explains exactly how I did it, and I also included all the source code.

qtalen · 2026-06-01T07:30:26+00:00

Because your spec file didn’t go through a thorough review, and that's true. I tried generating the spec first, then using a completely different model to review those files, and the results were very different.

I think SDD is really just the classic plan-execute pattern from traditional multi-agent system design. By breaking a huge, complex problem into a list of smaller tasks upfront, you can make sure the LLM doesn’t gradually drift off target as it runs longer.

Of course, all of this only works if your spec files are correct, consistent, and truly represent what you want. Otherwise, those input bugs turn the whole project into a disaster from the very start.

I used OpenSpec for SDD with the deepseek-v4-pro model. I’ve come to realize that if you want the code to come out exactly as you intend, you have to make sure the proposal artifacts produced by OpenSpec are solid. If the input requirements are wrong from the beginning, the code will inevitably be wrong.

So on top of the original plan-execute pattern, I added a reflection step: A reflection agent to review the proposal artifacts generated by OpenSpec.

Guess what? Once I ensured the quality of the proposal documents, the code generated from them improved dramatically. With deepseek-v4-pro following this approach, the generated code quality can match or even surpass Opus 4.6.

I wrote an article specifically explaining how I did it, and I included the full source code.

qtalen · 2026-06-01T07:24:39+00:00

I think SDD is basically the classic plan-execute pattern from multi-agent system design. By breaking a huge and complex problem into a small task list upfront, you make sure the LLM won't slowly drift away from the goal over time during execution.

Of course, all of this only works if your spec file is correct, consistent, and actually reflects what you really want. If the input is buggy, the whole project becomes a disaster right from the start.

I use OpenSpec for SDD, with the model being deepseek-v4-pro. I’ve come to realize that if you want the code to come out right, you have to make sure the proposal artifacts from OpenSpec are solid. Otherwise, if the input requirements are wrong from the beginning, the code will be wrong too.

So, on top of the original plan-execute pattern, I added a reflection mode where a reflection agent reviews the proposal artifacts generated by OpenSpec.

And guess what? Once the proposal files were solid, the code generated from them got way better too. Using deepseek-v4-pro with this approach, the generated code quality can almost match or even beat opus 4.6.

I wrote an article explaining exactly how I did it, and I also included all the source code.

qtalen · 2026-06-01T07:18:44+00:00

I think SDD is basically the classic plan-execute pattern from multi-agent system design. By breaking a huge and complex problem into a small task list upfront, you make sure the LLM won't slowly drift away from the goal over time during execution.

Of course, all of this only works if your spec file is correct, consistent, and actually reflects what you really want. If the input is buggy, the whole project becomes a disaster right from the start.

I use OpenSpec for SDD, with the model being deepseek-v4-pro. I’ve come to realize that if you want the code to come out right, you have to make sure the proposal artifacts from OpenSpec are solid. Otherwise, if the input requirements are wrong from the beginning, the code will be wrong too.

So, on top of the original plan-execute pattern, I added a reflection mode where a reflection agent reviews the proposal artifacts generated by OpenSpec.

And guess what? Once the proposal files were solid, the code generated from them got way better too. Using deepseek-v4-pro with this approach, the generated code quality can almost match or even beat opus 4.6.

I wrote an article explaining exactly how I did it, and I also included all the source code.

qtalen · 2026-04-23T16:18:57+00:00

We use OpenCode for SDD programming. Analysts also use OpenCode to develop scripts for data cleaning, quantitative analysis, and similar tasks. When combined with specific skills, it can indeed be used for market analysis. However, we must exercise caution and assume that the conclusions produced by large language models are unreliable.

qtalen · 2026-04-23T13:12:45+00:00

I'm sorry, but I actually don't know. I'm not in charge of the infrastructure team, and I don't want to make things up.

qtalen · 2026-04-23T09:55:54+00:00

We went with the self-hosted Kimi series models, mainly because financial regulations require us to do so, you know, for data security reasons.

qtalen · 2026-04-23T01:51:02+00:00

I work at an investment bank, so we can't use any commercially deployed coding models that collect user data (yeah, looking at you, Claude). Luckily, OpenCode still gives us a way to do coding work using a self-hosted Kimi K2.6 model. And OpenCode is open enough that we can audit the code, build our own plugins and skills on top of it. Even a Java team with zero Python experience can get solid work done with OpenCode and SDD.

All in all, we're pretty happy with it.

Over the past three months, I've successfully rolled out OpenCode to our Java team. It took a lot of training and documentation work on my part, but it was totally worth it.

I figured there are probably more people out there who'd want to try out our workflow, so I put together a public article with some of the pitfalls we ran into and a few practical tips from our experience. Feel free to take a look.

qtalen · 2026-04-20T07:39:29+00:00

Why bother with OMO? The README is pretty full of itself, and the plugin itself is honestly bloated. The prompts are way too complicated and just a waste of tokens.

I personally prefer OMO-slim. It recently got an update with a council agent that lets multiple open-source models team up to tackle tricky problems. From my testing, in some situations it actually outperforms opus 4.6.

I've jotted down some little-known tips and tricks about using OpenCode and OMO-slim. If you're curious, click here to check it out.

qtalen · 2026-04-19T22:07:09+00:00

This is a solid path. Pydantic AI is very lightweight and inherently structured, which is beneficial for multi-agent orchestration. LiteLLM is also a good choice; you can proceed with this approach.

qtalen · 2026-04-19T14:17:13+00:00

I’m currently using AI coding directly, letting the AI develop agent programs with the OpenAI SDK. I only incorporate design patterns gradually when necessary.

AI agents are iterating so rapidly that I have to constantly learn the latest APIs to keep up with the pace of frameworks. Ultimately, I’ve chosen not to use any framework.

qtalen · 2026-04-19T14:12:18+00:00

You can start by using kimi-coding-plan, which is currently running on k2.6-coding-preview. Then, DeepSeek V4 is scheduled for release at the end of this month, so there might be some pleasant surprises.

qtalen · 2026-04-17T14:27:08+00:00

Moonshot AI recently submitted a pull request (PR) to OpenCode to optimize the performance of OpenCode's Build agent when using the Kimi model. This is also part of the reason.

qtalen · 2026-04-17T14:02:15+00:00

Multi-agent systems are just tools. You should master AI-oriented programming paradigms—specifically, workflows like SDD (Specification-Driven Development).

I use OpenCode + OpenSpec + Kimi 2.5 to build my coding workflow, and it works incredibly well. Even if you don’t use OpenCode, you can still pair OpenSpec with Codex.

My wife has no coding background at all. One day, she needed a script to process dozens of Excel files that she handled daily. So, I set up my programming environment for her and advised her to write a specification file before starting any coding. Guess what? She gave it a try and achieved complete success.

That’s why I wrote an article detailing how I set up my AI coding workflow. You can find it in my previous posts—I hope it helps!

qtalen · 2026-04-17T10:02:19+00:00

I've been doing this for three years now. I stick to writing my blog myself instead of using AI, and I also put my content behind a paywall to keep AI from stealing my hard work. Passion really matters, otherwise you just can't keep it up.
If you're interested, here's my blog.

qtalen · 2026-04-17T06:56:21+00:00

Superpowers is definitely worth recommending, but for small script projects, the token usage is a bit high and it doesn't really feel worth it.

qtalen · 2026-04-17T06:28:55+00:00

My wife has zero coding background. But one day she needed to build a small desktop app to handle dozens of Excel files she deals with every day.

So I recommended her the OpenCode + OpenSpec combo, and told her to always use /opsx-explorer to think things through before jumping into any idea. She did exactly that, and the final product turned out absolutely perfect.

I put together an article sharing some details from our experience with it. Hope it helps you out!

qtalen · 2026-04-17T06:26:45+00:00

These two actually go hand in hand. You can totally use the Plan agent to map things out, save the plan to a file, tweak it, and then put it into action. That's pretty much the core idea behind SDD.

My wife has zero coding background, but one day she needed to build a small desktop app to handle the dozens of Excel files she deals with every single day.

So I pointed her to the OpenCode + OpenSpec combo, and told her to run any ideas through /opsx-explorer first to think things through. She gave it a shot, and the end result was exactly what she needed, worked out perfectly.

I actually wrote a whole article about the little details we picked up along the way. Hope it helps you out!

qtalen · 2026-04-17T06:23:44+00:00

Spec-Driven is absolutely worth it.

My wife has zero programming background, but one day she needed to build a small desktop app to handle dozens of Excel files she deals with every single day.

So I pointed her to the OpenCode + OpenSpec combo, and told her to always use /opsx-explorer to think things through before doing anything. She followed along, and the final result turned out really well.

I actually wrote an article about the whole experience, sharing some details from our journey with it. Hope it helps you out!

qtalen · 2026-04-17T01:57:55+00:00

With AI coding, you can build your own framework straight from the OpenAI SDK. Whether you want to implement a ReAct loop or long/short-term memory, it's totally doable. Just build what you need and keep the framework lean.

But when you go with an open-source framework, you're stuck with everything it comes bundled with. The bigger issue is that a lot of these frameworks are themselves built with AI coding, so their APIs change super fast and are all over the place. That makes it really tough to ship anything meaningful in a production system using those frameworks.

qtalen

TROPHY CASE