DeepSeek Harness Is Not a Claude Code Killer — It’s a Composable Agent Runtime

I Tried DeepSeek Harness on Its First Open-Source Day — and the Gap with Claude Code Is Bigger Than I Expected

Author: kyriewen Tags: Frontend, DeepSeek, AI Programming

Last night DeepSeek open-sourced Harness. It hit 50k GitHub stars in one day, and the comments section was full of "Claude Code killer."

I installed it immediately and ran it through its paces. Here's the conclusion upfront: it's not a replacement for Claude Code; it's a completely different thing. The gap isn't about "which is stronger" — they're not even on the same track.

Installed in 30 Seconds, but There Are Pitfalls

Installing it takes just one command:

npx @deepseek-ai/dsh web

Wait a minute or two for the download, and the terminal outputs an address: http://127.0.0.1:3080/. Open it in a browser and you're ready to go.

But the first pitfall hits right away — the Web version disables the Skills feature by default, doesn't throw an error, and you have no way of knowing it's not active. You need to manually patch it to enable it:

cat > ~/enable-skills.yml <<'EOF'
- id: skill-filesystem
  disabled: false
- id: tool-skill
  disabled: false
- id: skill-badge
  disabled: false
EOF

npx @deepseek-ai/dsh web --patch ~/enable-skills.yml

Before starting, you also need to confirm that port 3080 isn't already in use:

lsof -nP -iTCP:3080 -sTCP:LISTEN

If there's output, it means a previous dsh instance is still running — kill it before starting.

Compare that with installing Claude Code: npm install -g @anthropic-ai/claude-code, then just type claude in the terminal and it works. No browser needed, no patching config files, no checking ports.

The first gap: Claude Code is terminal-native; DSH is a B/S-architecture Web UI. This isn't a question of technical superiority — it's a fundamental divergence in design philosophy.

Four Modes Are Really Four Plugin Combinations

DSH comes with four built-in preset modes:

Mode	Positioning	Loaded Plugin Set
Standard	Full programming assistant	Shell + File editing + Search + Full UI suite
PTC Mode	Programmatic tool calling	TypeScript multi-step orchestration
Minimal	Shell + File editing only	Suitable for model benchmarking
Creative	Dynamic plugin loading	Can author entirely new modes

PTC mode is the most interesting one. It lets you orchestrate tool calls using TypeScript:

// Multi-step orchestration in PTC mode
const result = await dsh.compose([
  tools.file.read('src/components/Dashboard.tsx'),
  tools.analyze.dependencies(),
  tools.refactor.extract({
    target: 'useChartData',
    type: 'custom-hook'
  }),
  tools.file.write('src/hooks/useChartData.ts')
]);

This code and its sub-calls go through the full security pipeline — Hook, approval, permission check, sandbox, timeout control — and can't bypass any layer.

Claude Code has no such concept. Its tool calls are autonomously decided by the model; a developer can't pre-orchestrate a deterministic execution path in code.

This is the second gap: DSH gives developers the ability for "deterministic orchestration"; Claude Code gives the model the freedom of "autonomous decision-making."

Core Architecture: Everything Is a Plugin

DSH's design philosophy can be summed up in one sentence: Model + Harness = Agent.

What is a Harness? It determines:

What the model can see (context management)
Which tools can be called (tool registration)
How context is organized (session strategy)
How to retry on errors (fault-tolerance logic)
When to judge a task as complete (termination conditions)

The same model placed into different Harnesses can produce vastly different results.

DSH pushes this philosophy to the extreme — even the Agent Loop itself is a plugin and can be replaced.

┌─────────────────────────────────────────┐
│              DeepSeek Harness            │
├─────────────────────────────────────────┤
│  Cordis microkernel (only handles        │
│  plugin load/unload/dependencies)        │
├─────────────────────────────────────────┤
│  Plugin layer (all replaceable):         │
│  ┌────────┐ ┌────────┐ ┌────────┐      │
│  │ Model  │ │ Tools  │ │ Skills │      │
│  └────────┘ └────────┘ └────────┘      │
│  ┌────────┐ ┌────────┐ ┌────────┐      │
│  │Session │ │Sandbox │ │Storage │      │
│  └────────┘ └────────┘ └────────┘      │
│  ┌────────┐ ┌────────┐ ┌────────┐      │
│  │  Loop  │ │Schedule│ │   UI   │      │
│  └────────┘ └────────┘ └────────┘      │
└─────────────────────────────────────────┘

Compare with Claude Code: the model is fixed (Claude), the tools are fixed (Bash/Read/Write/Edit, etc.), the Loop is non-replaceable, and the UI is the terminal. The only things you can extend are MCP Servers and Skills.

The third gap: DSH's replaceability boundary goes down from the "tool layer" to the "entire runtime"; Claude Code's replaceability boundary stops at "tools and skills."

Tool Call Pipeline: This Design Is Genuinely Elegant

DSH's tool calling isn't a simple "the model says call it, so call it." Every call goes through a complete pipeline:

Request → Hook → Approval → Permission Check → Sandbox → Timeout Control
                                                          ↓
UI Render ← Logging ← Result Rewriting ← Execution ←─────┘

Developers can insert their own plugins at any stage without modifying the tool itself or the Agent Loop.

Here's a frontend scenario: you want all file write operations to first pass an ESLint check:

// Register a pre-write Hook plugin for file writes
export default class EslintGuardPlugin {
  static inject = ['tools'];
  
  constructor(ctx) {
    ctx.before('tool/file-write', async (event) => {
      const { path, content } = event.params;
      if (path.endsWith('.ts') || path.endsWith('.tsx')) {
        const result = await eslint.lintText(content, { filePath: path });
        if (result[0].errorCount > 0) {
          event.prevent();
          return { blocked: true, errors: result[0].messages };
        }
      }
    });
  }
}

To achieve the same effect in Claude Code? Write a Hook rule in settings.json. It can "intercept," but the granularity is nowhere near this — you can't access tool call parameters for conditional checks, let alone rewrite results.

Model Agnostic: No Model Lock-In

DSH supports DeepSeek's own models by default, but can switch to interfaces from nearly 40 model providers. Configuration:

# $DSH_HOME/settings.yaml
providers:
  - name: anthropic
    kind: openai-compatible
    base_url: https://api.anthropic.com/v1
    model: claude-sonnet-4-20250514
    api_key_env: ANTHROPIC_API_KEY
  - name: openai
    kind: openai
    base_url: https://api.openai.com/v1
    model: gpt-4o
    api_key_env: OPENAI_API_KEY

In other words, you can run Claude's model inside DSH's Harness. Is this combination better than native Claude Code? In theory, no — because Claude Code's Harness is specifically optimized for Claude models (e.g., system prompt, context management strategy). But it gives you an environment for "controlled experiments."

Claude Code is completely locked to Claude models, with no switching option. This isn't a drawback — the ceiling of a specialized system is always higher than the ceiling of a general-purpose system. Claude Code has done extensive Harness-layer optimizations for Claude models that a general-purpose framework can't achieve.

Real-World Experience: Writing a React Component

I asked DSH's Standard mode (default DeepSeek V4-Pro) to write a table component with virtual scrolling:

DSH's execution process:

Read project structure → analyze dependencies
Generate component code
Write to file
(No automatic type checking run)
(No automatic render result verification)

The same task with Claude Code:

Read project structure → analyze dependencies → read existing component styles
Generate component code
Write to file
Automatically run tsc --noEmit to check types
Find type errors → auto-fix → check again
Start dev server → verify rendering

Where's the gap? Claude Code has a mature "self-correction loop" — after writing code it automatically verifies, and if there are errors it automatically fixes them. DSH's current Agent Loop doesn't yet have this depth of self-verification mechanism; it's more of a "do what I tell you to do" approach.

This is the reality of a v0.1 developer preview. The DSH team themselves said: there are still a lot of details to polish.

The Real Comparison Dimensions

It's not about "who writes better code" — the positioning is completely different:

Dimension	DeepSeek Harness	Claude Code
Positioning	Composable Agent runtime foundation	Mature AI programming assistant
Target User	Harness developers / framework authors	Programmers who want AI to write code
Model	40+ providers, switchable	Locked to Claude
Replaceable Scope	Entire runtime (incl. Loop/UI/Session)	Tool layer (MCP/Skills)
Agent Loop	Plugin, replaceable	Built-in, deeply optimized
Installation Barrier	Node.js + npx + port configuration	npm install + one command
UI Form	Web UI (port 3080)	Terminal-native
Maturity	v0.1 developer preview	Production-grade, 1M+ DAU
Self-Correction	Basic	Deep (type checking + runtime validation)
Open-Source License	MIT	Closed-source

My Judgment

Short-term (within 6 months): Claude Code remains the best solution for daily programming. No v0.1 framework can match the out-of-the-box experience of a product that's been polished for over a year. If you have a project due tomorrow, use Claude Code.

Medium-to-long-term (1-2 years): DSH's architectural design could change the game. Once the "everything is a plugin" foundation has an ecosystem (Cordis already has 4,000+ community plugins accumulated), use cases will emerge that Claude Code can't do — like training a dedicated Agent Loop plugin for your team's coding standards, or chaining code review, deployment, and monitoring into a fully customized pipeline.

The most noteworthy signal: Simultaneously with DSH's release, DeepSeek raised the price of the V4-Pro model starting August 17 (peak output 27 RMB per million tokens). This means DeepSeek intends to use Harness's free open-source ecosystem to feed the model's paid revenue — the exact same logic as OpenAI using the free version of ChatGPT to pull in users and charging for Codex.

If you're an ordinary frontend developer: Don't rush to switch today. But install it and play around, understand the concept of "Harness" — Model + Harness = Agent. This formula is more important than any specific tool, because it determines how you'll choose and combine AI programming tools in the future.

Quick Start Cheat Sheet

Step	Command / Operation
Prerequisites	Node.js v18+
Quick Start	`npx @deepseek-ai/dsh web`
Global Install	`npm install -g @deepseek-ai/dsh`
Source Install	`git clone` → `pnpm install` → `pnpm run build` → `pnpm dsh web`
Access URL	`http://127.0.0.1:3080/`
First-Time Config	Enter DeepSeek API Key
Enable Skills	Create patch yaml → start with `--patch` parameter
Switch Model	Settings page or `$DSH_HOME/settings.yaml`
Switch Mode	Dropdown selection at top of Web UI
View Plugins	Settings → Plugin Management → Enable/Disable
Python SDK	`pip install deepseek-harness-sdk` (built-in runtime, no Node.js required)

Have you installed it? Do you think DSH's "everything is a plugin" is a genuine architectural innovation, or over-engineering? Drop your take in the comments.