Skip to content
BSWEN
Blog

Why Claude Sonnet Is More Proactive Than DeepSeek V4 (And How to Fix It)

Cowrie
Cowrie
Dev @ Bswen

AI assistant conversation

Problem

When I switched from Claude Sonnet to DeepSeek V4 for coding, I noticed something frustrating: DeepSeek just answers the question. No alternatives. No “have you considered…” No next steps. Sonnet felt like a senior dev who anticipates problems; DeepSeek felt like a junior who only does what you ask.

I’m not alone. On the r/opencodeCLI subreddit, many developers reported the same experience:

“Sonnet 4.6 is a LOT more conversational and proactive. Sonnet will more often than not suggest alternatives and/or next steps… while DSV4-Pro will just tell you the problem exists.”

So I dug into why this happens. The answer surprised me.

What’s Really Going On

Here’s the key insight: Sonnet’s proactivity is not a model feature — it’s a harness feature.

What do I mean by “harness”? Every AI coding assistant has three layers:

architecture-layers.txt
┌─────────────────────────────────────────────┐
│           User Experience                    │
│  "The AI suggested alternatives!"            │
│  "The AI just answered the question."        │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│     Harness / System Prompt Layer            │
│  - Tool orchestration rules                  │
│  - "Always suggest alternatives"             │
│  - "Propose next steps after each task"      │
│  - Conversation formatting rules             │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│          Base Model (LLM)                    │
│  - Sonnet 4.6 / DeepSeek V4 Pro / etc.      │
│  - Generates tokens based on instructions    │
└─────────────────────────────────────────────┘

When you use Claude Code, the harness layer includes system prompts that instruct the model to be proactive — suggest alternatives, flag issues, propose next steps. When you call the Sonnet API directly, without that harness, it behaves much like DeepSeek V4.

One Reddit user confirmed this:

“You are correct about Claude’s harness, not the Sonnet model. Both models behave almost exactly the same if you use Sonnet directly from LLM API calls.”

So the proactivity gap is mostly a prompt engineering gap, not a model intelligence gap.

DeepSeek V4 text arena ranking

How to Make DeepSeek V4 More Proactive

The fix is straightforward: write explicit system prompts that tell DeepSeek to behave proactively.

Solution #1: Add a Proactive System Prompt

proactive-system-prompt.md
You are a coding assistant. After completing each task:
1. Suggest 2-3 alternative approaches with pros/cons
2. Identify potential issues or edge cases
3. Propose logical next steps
4. If the user's request is ambiguous, ask clarifying questions before proceeding


Format your suggestions as:
- **Alternative**: [description] — [why consider this]
- **Next step**: [what to do next] — [reason]

I tried this with DeepSeek V4 Pro. Before adding the system prompt, a typical interaction looked like:

before-default-behavior.txt
Me: Refactor the database connection pool


DeepSeek: Here's the refactored code:
[outputs code]


(End of response. No suggestions, no warnings.)

After adding the proactive system prompt:

after-proactive-prompt.txt
Me: Refactor the database pool


DeepSeek: Here's the refactored code:
[outputs code]


- **Alternative**: Use HikariCP instead of the built-in pool — better
  performance under high concurrency
- **Alternative**: Switch to a connection-per-request pattern — simpler
  but may not scale as well
- **Next step**: Add pool size monitoring — you'll want to tune the
  pool size based on actual usage

The difference is night and day.

Screenshot of DeepSeek V4 Pro chat producing proactive suggestions after applying the system prompt

Solution #2: Configure Your Tool’s Skills

If you use a tool like Pi (opencodeCLI), you can configure skills that trigger proactive behavior automatically:

pi-skills-config.yaml
skills:
  proactive-suggestions:
    model: deepseek-v4-pro
    system_prompt: |
      After answering, always suggest:
      1. Alternative approaches
      2. Potential issues
      3. Next steps
    trigger: after_each_response

This way, you don’t need to repeat the instruction in every message. The skill applies it automatically.

Important: Use Pro, Not Flash

One thing I learned the hard way: DeepSeek V4 Pro follows complex system prompt instructions well, even in its reasoning tokens. Flash is less consistent with multi-step behavioral instructions.

If you need the model to reliably follow a proactive system prompt, use Pro. Flash works fine for simple tasks, but it often “forgets” to apply the proactive format when the main task gets complicated.

DeepSeek V4 benchmark comparison

The Remaining Gap: Intent Guessing

There’s one area where Sonnet genuinely outperforms DeepSeek V4: guessing what you mean when your prompt is vague.

One Reddit user ranked models by intent-guessing ability:

intent-ranking.txt
Opus 4.6 >> Sonnet 4.6 ≳ DSV4 Pro ≳ GPT 5.5
          > Gemini 3.1 Pro ~ DSV4 Flash > Gemini 3.5 Flash

This is subjective, but it matches my experience. When I give Sonnet a messy brain dump like “make the auth thing work with the redirect from the login page that sometimes fails”, Sonnet turns it into a clear action plan. DeepSeek asks me to clarify.

This isn’t a flaw — it’s a different design philosophy. DeepSeek is more conservative and literal. The fix here is simple: write clearer prompts. If you’re switching from Sonnet to DeepSeek, invest a few extra seconds in your prompts. It pays off.

Common Mistakes

When I first evaluated DeepSeek V4, I made these mistakes:

  • Attributing harness behavior to the model — I assumed Sonnet was “smarter” because it suggested alternatives. In reality, Claude Code’s system prompt was doing the heavy lifting.
  • Not writing system prompts for DeepSeek — I used the default and then complained it was less helpful. That’s like driving a car without power steering and blaming the car.
  • Using vague prompts — DeepSeek needs more explicit instructions than Sonnet. A brain dump works with Sonnet; DeepSeek wants specifics.
  • Expecting Flash to follow behavioral instructions — Flash is fast but doesn’t consistently apply complex system prompt rules. Use Pro for this.

Summary

In this post, I explained why Claude Sonnet feels more proactive than DeepSeek V4 and how to fix it. The key point is that Sonnet’s proactivity comes from the Claude Code harness (system prompt + tool orchestration), not from the model itself. You can replicate this behavior in DeepSeek V4 Pro by writing explicit system prompts that instruct it to suggest alternatives, flag issues, and propose next steps. The one remaining gap is intent guessing — Sonnet is better at understanding vague prompts, so write clearer instructions for DeepSeek.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: