DeepSeek Harness Hands-On Review: A Transparent AI Coding Framework Where Everything Is a Plugin

An AI Coding Framework That Breaks Convention

DeepSeek has released a developer preview tool called DeepSeek Harness. Unlike mainstream AI coding assistants (such as Claude Code), it adopts an extremely unique design philosophy that has caught many developers' attention. According to a hands-on demo by YouTube channel NeuralNine, while the tool is still in preview and its workflows are somewhat rough around the edges, its underlying architectural approach is already noteworthy.

Its core selling points can be summarized in two phrases: everything is a plugin, and everything is traceable. These two features directly address the two major pain points of current AI coding tools—closed functionality and black-box processes.

Everything Is a Plugin: Ultimate Modular Design

Harness's most radical design choice is abstracting every component of the tool itself into a plugin. Whether it's the UI sidebar, its two capability systems, or system prompts—everything can be independently enabled or disabled.

Plugin Architecture is a classic design pattern in software engineering, with the core principle of splitting system functionality into independently loadable and unloadable modules. This design has a long history in the IDE space—Eclipse and VS Code both employ similar architectures. VS Code's extension system allows third-party developers to hook into every layer of the editor through APIs, from syntax highlighting to debuggers. But what makes Harness radical is that it doesn't just make "extended features" into plugins—even the system's core components (like the UI and system prompts) are pluginized. This means the system's "skeleton" itself is detachable, which is a first among AI coding tools.

In other words, every feature and every UI element you see on screen corresponds to a toggleable plugin behind the scenes. This fine-grained modularity makes the entire system extraordinarily flexible—you can trim it down to a minimal coding environment or stack various custom capabilities on top.

Currently, toggling plugins still requires manual editing of configuration files. In the hands-on test, the author navigated to the cordis-patch.yaml file in the profiles/web directory—simply adding a plugin's id and setting isDisabled: true, then reloading, caused the sidebar to disappear. The Cordis configuration system used by Harness is based on dependency injection and reactive programming principles, allowing developers to manage inter-component dependencies through declarative configuration. YAML as a configuration format is more suitable for human reading and manual editing, and the advantage of declarative dependency management is that when a plugin is disabled, the system can automatically handle all downstream components that depend on it, preventing cascading failures. While this mechanism isn't exactly "user-friendly" yet, future versions are expected to provide one-click button operations.

Creator Mode: Building New Features Through Conversation

If the plugin system merely enables free assembly and disassembly of features, then Creator Mode takes extensibility to an entirely new level.

Developing Plugins Through Natural Language Prompts

Among Harness's Agent presets, in addition to standard mode, code mode, and minimal mode, there's a dedicated Creator mode. Its purpose is: describing functionality in natural language and having Harness develop and activate new features on its own.

Creator Mode is essentially an implementation of "Metaprogramming" in AI tools—using programs to generate programs. This concept isn't new in computer science; Lisp's macro system and Ruby's metaprogramming capabilities are classic examples. But combining metaprogramming with large language models, making natural language the "metalanguage," is a unique innovation of the AI era. From a technical implementation perspective, Creator Mode needs to solve several key problems: sandbox security for code generation, hot-swappable dynamic loading mechanisms, and interface compatibility between generated code and the existing system.

The author provided two intuitive examples in the hands-on test. The first was creating an ASCII cat animation overlay that moves back and forth at the bottom of the screen; the second was adding a GUI calculator plugin in the bottom-right corner. Throughout the process, users only need to describe requirements via prompts—Harness in Creator mode automatically loads programming skills, develops the corresponding plugin, and dynamically loads it into the current session after confirmation.

Even more noteworthy is that these newly added plugins can be enabled, disabled, or even removed in real-time, with virtually no unexpected side effects. The author demonstrated how to "pause" the cat animation and restart it at any time—this dynamically composable experience is a direct manifestation of Harness's underlying design.

The Mathematical Foundation: The Quartus Calculus System

DeepSeek Harness is built on a project called Quartus, accompanied by a formal mathematical paper. Its core idea is: every action is reversible—every operation has a corresponding "inverse action" or "rollback action," which is essentially an inverse operation.

This concept has deep theoretical roots in computer science. Reversible Computing was originally proposed by Bennett and Landauer at the intersection of physics and information theory, with the core argument that any computational process can be designed to be reversible. In software engineering practice, typical applications of this theory include database Transaction Rollback, Git version control, and Time-travel Debugging in state management libraries like Redux. Harness applying reversible computing theory to its plugin system means that every plugin load records sufficient information to support perfect rollback, providing a mathematical guarantee of system state consistency rather than relying on heuristic "best-effort" undo approaches.

It's precisely this formal calculus system that ensures dynamic plugin composition, temporal and spatial composability, and declarative reactive management of inter-component dependencies. This also explains why users can add or remove arbitrary components at any time without causing system chaos.

Everything Is Traceable: Fully Transparent AI Execution

Harness's second major feature is complete transparency. The author specifically emphasized that this is "the exact opposite of Anthropic's approach of hiding the thinking process."

This comparison refers to how Claude's Extended Thinking feature partially hides its internal Chain of Thought from users—OpenAI's o1 model does the same. These companies cite safety and alignment concerns—exposing the complete reasoning process could be exploited for jailbreak attacks or prompt injection. This reflects the fundamental tension in the AI industry between "transparency" and "safety." DeepSeek's choice of full transparency is both a technical differentiation strategy and implies a different philosophical stance on developer trust and AI auditability.

Every Step of Reasoning Is Traceable

In Harness, every run, every message, every tool call, and every loaded skill can be recorded in detail and analyzed graphically. This actually belongs to the emerging technical field of AI system Observability. As AI Agents become increasingly complex—involving multi-turn tool calls, context switching, skill loading, and other steps—traditional logging is far from sufficient. The industry has already seen dedicated AI observability tools like LangSmith and Weights & Biases, but these are typically external add-on tools, whereas Harness builds observability into the system core as a first-class citizen.

In the demo, the author created a simple Flask to-do app, then entered the "trajectory view" to step through: system prompt content, user prompts, loaded context, the assistant's thinking process and messages, and specific tool calls (such as the exact payload and return results of a Bash call to read a directory).

Additionally, the system provides detailed statistics including duration, rounds, call times, and duration lengths. All sessions can be exported as ZIP packages containing session.json.l files—this JSON Lines format (one independent JSON object per line) is a standard practice for large-scale logging systems, facilitating stream processing and incremental analysis, and allowing developers to use grep and other Unix tools for quick filtering. The complete execution process can be traced line by line. For developers looking to audit AI behavior or debug Agent workflows, this level of transparency is extremely valuable.

Flexible Multi-Model Integration

Beyond plugins and traceability, Harness is quite open when it comes to model integration. While the first run requires a DeepSeek API key, users can connect to other providers through settings.

In the hands-on test, the author connected GPT-series models through OpenCode and also connected to a locally running Ollama instance. Ollama is an open-source local LLM runtime framework that greatly simplifies deploying and running open-source LLMs on personal devices—users can download and run models like Llama, Mistral, and Gemma with a single command. The author specifically ran this on a Dell Pro Max equipped with a GB10 (NVIDIA's GB10 Superchip, high-end hardware designed for AI workstations), loading open-source models with up to 120 billion parameters and Gemma models. The advantages of local deployment include data privacy (code never leaves the machine) and zero API costs, but the tradeoff is expensive hardware investment. Harness's support for Ollama integration means enterprise users can use AI coding capabilities in fully offline environments, which is critically important for scenarios involving sensitive code (such as finance, defense, and healthcare). Users can add custom providers or connect via API keys. However, the author noted that it's currently not possible to directly connect a ChatGPT subscription account.

Worth Watching, But Still in Early Stages

Overall, DeepSeek Harness demonstrates a path distinctly different from mainstream tools like Claude Code: ultimate modularity, complete transparency, open integration, plus Creator Mode that dynamically generates features through conversation.

However, it's important to recognize clearly that this is still just a developer preview. As the author repeatedly emphasized, many workflows are still quite rough—toggling plugins requires manually editing config files, and generated plugin features aren't fully polished (for example, calculator button layouts are chaotic). These plugins currently only apply to the current session and need to be manually saved.

But its future prospects are worth anticipating: over time, Harness could develop into a mature plugin ecosystem, becoming increasingly user-friendly. For developers following the evolution of AI coding tools, this project is worth keeping an eye on. Whether it can truly challenge Claude Code remains premature to say, but the "transparent + pluginized" approach it proposes undoubtedly opens up new imaginative possibilities for the entire field.

Key Takeaways