DeepSeek Harness Hands-On: Can This "Everything Is a Plugin" AI Dev Framework Challenge Claude Code?

On August 13th, DeepSeek quietly released a developer preview called DeepSeek Harness. Unlike mainstream AI coding tools on the market, this framework takes an aggressively opinionated design philosophy — Everything is a Plugin. From UI sidebars and tool-calling capabilities to system prompts, nearly every feature can be enabled or disabled, and new functionality can even be dynamically generated through conversation.

This article is based on a hands-on video from the YouTube channel NeuralNine. It walks through the tool's core design principles and real-world experience, exploring whether it could genuinely challenge Claude Code's position.

Two Core Features of DeepSeek Harness: Plugin Architecture and Full Traceability

DeepSeek Harness is built on top of a framework called Cordis, accompanied by a mathematically oriented theory paper. The central idea is "action reversibility" — a formalized calculus where every operation has a corresponding revert action, enabling side-effect-free dynamic composition. This includes temporal composability (add or remove features at any time without side effects) and spatial composability (declaratively managing dependencies between components).

For developers, two practical highlights stand out:

• Everything is a Plugin: UI elements, tool capabilities, and system prompts are all modularized at an extremely fine-grained level.
• Every run is fully traceable: Every message, every tool call, and every loaded skill can be analyzed in detail.

The second point is particularly noteworthy — it stands in direct contrast to Anthropic's strategy of hiding the thinking process. DeepSeek has chosen to lay everything out in the open, pursuing 100% transparency.

The Cordis framework evolved from a JavaScript ecosystem service container library of the same name (originally used in the chatbot framework Koishi), with a design philosophy deeply influenced by functional programming. The formalized "action reversibility" calculus draws from concepts in category theory — the loading and unloading of each plugin is modeled as a pair of inverse morphisms, theoretically guaranteeing clean rollback of system state under any plugin combination. Temporal composability means plugins can be hot-swapped at runtime without restarting the entire application; spatial composability automatically handles plugin load order and lifecycle through dependency declarations, similar to a Dependency Injection (DI) Container, but extended to cover the tool layer and UI layer of an AI agent. This architecture is not uncommon in enterprise software, but systematically applying it to an AI coding assistant framework remains frontier territory.

Installation, Configuration, and Multi-Provider Model Support

In the hands-on test, the author chose to run from source. The process is quite straightforward: clone the repository, install and build with PNPM, then launch the web interface via pnpm dsh web.

On first run, the tool asks you to enter a DeepSeek API key (available from platform.deepseek.com). However, one important advantage is that you don't have to use the official DeepSeek API. In the model settings, you can freely connect third-party providers. The author demonstrated two approaches:

• Connecting GLM and other models via OpenCode Go;
• Connecting a locally running Ollama service (the author was running GPT open-source 120B, Gemma, and other models on a Dell Pro Max with a GB10 chip).

This means both cloud APIs and locally deployed models can be seamlessly integrated. The only current limitation is that you can't directly connect a ChatGPT subscription account. This open provider ecosystem is very appealing for teams looking to control costs or use private models.

PNPM (Performant NPM) is an efficient package manager in the Node.js ecosystem. Compared to npm/yarn, it saves significant disk space and speeds up installation by sharing dependencies via hard links, making it especially popular in monorepo projects. Ollama is a tool that allows users to run open-source large language models locally, supporting mainstream models like Llama, Mistral, and Gemma through a unified REST API — making local models callable just like cloud APIs. The "GB10" the author mentions refers to NVIDIA's Grace Blackwell Superchip, which integrates an ARM CPU with a Blackwell GPU, designed for edge AI inference, enabling smooth execution of tens-of-billions-parameter models on consumer-grade devices. This local inference capability, combined with Harness's open provider interface, makes a fully offline, data-stays-local AI coding workflow technically feasible.

Full Traceability: The Ultimate Expression of AI Agent Transparency

The author used a task — "create a simple Flask to-do application" — to demonstrate the tool's traceability features. After the task ran, entering the Trajectory view lets you graphically analyze every step.

Here, you can drill down layer by layer to see:

• The complete content of the system prompt;
• The user prompt and loaded context;
• The assistant's thinking process (viewable as preview or raw text);
• The specific payload, working directory, and return result of each tool call;
• Detailed statistics: time elapsed, number of turns, call timestamps, and duration.

Furthermore, the entire session log can be exported as a zip archive containing a session.jsonl file that records the complete execution details. This level of thoroughgoing transparency is enormously valuable for debugging agent behavior and understanding model decision chains — something most closed-source tools struggle to provide.

Deep Dive into the Plugin System: From Disabling Sidebars to Dynamically Generating Features

The plugin architecture is the most impressive part of DeepSeek Harness. In the plugin list under settings, you'll find that every element in the interface is a plugin — granular to the point where even the UI sidebar itself can be disabled.

In the current preview, enabling and disabling plugins requires manually editing a configuration file (the cordis.patch.yaml under .dsh/profiles/web/). For example, simply adding a few lines of YAML to mark ui-sidebar as disabled: true will cause the sidebar to disappear after reloading.

The author also acknowledged that, as a developer preview, this workflow is still fairly "rough around the edges" — future versions are expected to offer a one-click visual toggle.

Creator Mode: Dynamically Creating Plugins Through Conversation

The real killer feature is Creator mode. DeepSeek Harness offers four agent presets — Standard, Code, Minimal, and Creator — with Creator mode dedicated to dynamically adding plugins.

The author ran two demonstrations:

1. Floating cat animation: With a single prompt — "add a cat to the bottom of the screen that bounces back and forth from left to right" — the tool automatically loaded the Cordis plugin development skill, generated the plugin, and asked for confirmation. After approval, a cat appeared strolling across the bottom of the interface, toggleable at any time.
2. Floating calculator window: Similarly, through conversation, a GUI calculator widget was generated in the bottom-right corner.

While these examples aren't perfect (the button layout has rough edges), the core concept is clearly demonstrated: users can "say" what feature they want in real time during use, and have it persisted. This lays the groundwork for building a complete plugin ecosystem in the future.

The underlying mechanism of Creator mode is that the AI model directly calls the Cordis plugin development SDK during conversation to generate plugin code conforming to the framework's specifications, then injects it into the runtime after sandbox-based user confirmation. This mode is closely related to the concept of metaprogramming — a program generating and executing new program logic at runtime. Unlike the paradigm of tools like GitHub Copilot or Cursor, where "you generate code and then manually integrate it," Harness merges generation and deployment into a single conversational step, with generated plugins persisted so they survive restarts. This Prompt-to-Deploy pattern is a meaningful paradigm shift at the toolchain level. The challenge lies in ensuring the security and maintainability of dynamically generated code — a problem this preview has not yet fully solved.

DeepSeek Harness vs Claude Code: A Competitive Assessment

Back to the original question. Objectively speaking, DeepSeek Harness is still an immature developer preview, with interaction experience and stability both needing refinement. It's unlikely to directly threaten Claude Code's market position in the short term.

But the design direction it represents is genuinely exciting:

• Extreme modularity: Everything is a plugin, freely assembled and disassembled;
• Complete transparency: A sharp contrast to the approach of closed-source tools that hide the chain of thought;
• Open model ecosystem: Compatible with cloud APIs and local deployments, not locked to a single vendor;
• Conversational feature extension: Creator mode makes "prompt-as-development" a real possibility.

If DeepSeek can continue to iterate, polish the user experience, and cultivate an active plugin ecosystem, this framework has the potential to become a significant differentiator in the AI coding tools space. For practitioners tracking the evolution of AI development tooling, this is absolutely a project worth adding to your watchlist.