Preface¶

DeepSeek Harness (hereinafter referred to as DSH) treats models, tools, skills, conversations, sandboxes and interfaces as detachable plugins. The official repository positions itself as “Everything is a Plugin”: capabilities are not hardcoded into the kernel, but attached to Cordis’s shared context and combined according to profiles. Skills belong to this layer as well — they are not new tools, but sets of working disciplines that can be loaded by the skill tool.

When a coding agent receives requests like “add a feature” or “fix a bug”, the common practice is to modify the code directly. Without aligning designs first, writing tests after the fact, or identifying root causes, developers end up patching symptoms in the next iteration. The obra/superpowers project maintained by Jesse Vincent splits this workflow into composable skills: start with brainstorming, draft a plan, implement following the RED-GREEN-REFACTOR cycle, and debug by first investigating root causes. The upstream repository is open-sourced under the MIT license, and its official README provides installation methods for multiple tools including Claude Code, Cursor, Codex, Gemini CLI, etc., but DeepSeek Harness is not listed there.

superpowers-dsh was built for exactly this purpose: porting the core skills of Superpowers to DSH’s Cordis plugin architecture, distributing the SKILL.md files with the package, and registering them into the host-level skill list after installation. This article was written on 2026-08-17 after cross-checking the plugin directory page, GitHub repository README, package.json, lib/index.js, and upstream Superpowers resources.

What It Is¶

superpowers-dsh is a skill-type DSH plugin maintained by LayneChai, with the repository address at LayneChai/superpowers-dsh. The community plugin directory categorizes it under the “Skills” taxonomy, with an inclusion date of 2026-08-15. It is not an official component of DeepSeek / Magic Square; deepseek-harness-plugin.com is an independent community directory and has no affiliation with DeepSeek’s official team. The official discovery channel remains the GitHub dsh-plugin topic.

One-sentence positioning: After installation, every agent session in the current profile will see 14 Superpowers skills in the skill directory, and can load them on demand using DSH’s built-in skill tool. The skill content is stored in skills/<name>/SKILL.md within the package, located via import.meta.url, so no additional path configuration is required from users.

The repository was created on 2026-08-14, with JavaScript as the primary language. At the time of writing this article, GitHub shows 44 stars; the directory page still showed 27 stars at that moment, so refer to the repository page for the latest count. The npm package name is also superpowers-dsh, with the latest version 0.1.1 (released on 2026-08-14); the package.json in the GitHub main branch still lists 0.1.0. Installing from the GitHub specification will follow the current commit of the repository, while installing from npm will get the released version, and the two do not have to be considered the same artifact.

Core Features¶

The plugin registers a skill provider to the host-level ctx.skills registry. The host-level entry will enter the scope chain of each agent preset, so there is no need to install it separately for each agent. The implementation in lib/index.js is very lightweight: it only uses Node’s built-in fs / path / url modules, and consumes the injected ctx.skills service. The list() function scans the skills/ directory in the package, parses name, description, and whenToUse from the YAML frontmatter; the get() function reads the content on demand, and points resourceBase to the skill directory so that relative references (scripts, prompt templates) can be resolved correctly.

cordis.patch.yml inserts one line above the dsh-base layer:

- insert:
  - id: superpowers-dsh
    name: 'superpowers-dsh'

The subsequent profile layer and --patch overlay can still locate this line by its id.

The 14 skills listed in the README can be grouped by their purpose. The descriptions below are sourced from the repository’s skill list and the opened SKILL.md files, not based on usage experience.

Entry Point
- using-superpowers: How to find and call skills. The content requires: whenever there is even a slight possibility of applicability, first load the skill using the skill tool before speaking or taking action. Skills on DSH are addressed by their bare names, such as brainstorming, without the superpowers: prefix.

Planning & Collaboration
- brainstorming: Use collaborative conversation to converge ideas into a design.
- writing-plans: Draft an implementation plan based on specifications.
- executing-plans: Execute according to a written plan and leave review checkpoints.

Implementation & Validation
- test-driven-development: RED-GREEN-REFACTOR. The skill content in the repository hardcodes the rule: do not write production code until you have first seen a failing test; prototypes, generated code, and configuration files need to be confirmed with the user first.
- systematic-debugging: Four-stage debugging — root cause investigation, pattern comparison, single hypothesis verification, and then fixing the issue. The skill content explicitly states: do not propose a fix before completing the first stage.
- verification-before-completion: Produce evidence before claiming completion.

Multi-Agent
- subagent-driven-development: Dispatch new sub-agents for each task and conduct reviews.
- dispatching-parallel-agents: Fan out independent work to parallel agents. In the porting notes, sub-agent reference mappings are adapted to DSH’s subagent / subagent_fork; for large-scale fan-out, you can also use DSH’s own workflow tool.

Review & Wrap-Up
- requesting-code-review / receiving-code-review: Conduct strict reviews before merging, verify feedback before making changes, instead of accepting all requests verbatim.
- finishing-a-development-branch: Safely integrate completed work.
- using-git-worktrees: Use isolated workspaces for feature development.

Extension
- writing-skills: Write and validate new skills using TDD. Add a skills/<name>/SKILL.md with YAML frontmatter to the package, and it will be discovered by list() without modifying the plugin code.

Compared to the upstream project, several platform adaptations were made for this port, all documented in the “Porting Notes” section of the README:
1. Remove the namespace prefix to adapt to DSH’s bare name addressing.
2. using-superpowers points to skills/using-superpowers/references/dsh-tools.md, which provides a comparison of Claude Code tools to DSH tools (pwsh / bash, subagent, workflow, goal, etc.). DSH has no hook system, so workflow constraints are written directly into the skill content.
3. Visual companion for brainstorming: The Node service scripts/server.cjs runs on all platforms; the .sh helper script is only available under bash.

Installation & Activation¶

The installation command given on the directory page can be run in the DeepSeek Harness terminal:

dsh plugin add github:LayneChai/superpowers-dsh

The plugin runs with the permissions of the current dsh process, and may execute code during installation. Please review the source code repository and license before installing. For reproducible installations, pin the specification to a specific commit. When checking the main branch for this article, the latest commit was 49e2d65db55b4d3ec065ad824efe9b09465c8a26 (2026-08-14):

dsh plugin add github:LayneChai/superpowers-dsh#49e2d65db55b4d3ec065ad824efe9b09465c8a26

Commits will continue to advance, please refer to the repository page before installing.

The repository README adds several equivalent methods for users already using --profile. The dsh plugin command internally calls pnpm, so you need to have pnpm --version executable first. The dsh command is bundled with Harness, and the common startup method is npx @deepseek-ai/dsh web, so it is only available in that process environment. You can install it globally first, or prepend npx to all commands:

# Global installation (recommended in README)
npm install -g @deepseek-ai/dsh
dsh --version

# No global installation, use npx for all commands
npx @deepseek-ai/dsh --version

The “simplest one-liner” from the README (no prior global installation of dsh required):

npx @deepseek-ai/dsh plugin --profile web add github:LayneChai/superpowers-dsh

Installing from npm (package name superpowers-dsh):

dsh plugin --profile web add superpowers-dsh

Note: You must use dsh plugin. Direct npm install superpowers-dsh will only install the package as a regular library in the current directory, will not write any DeepSeek Harness profile, and the skills will not be loaded.

You can also use the full Git URL, tarball, or local folder:

dsh plugin --profile web add https://github.com/LayneChai/superpowers-dsh.git

The bundle layer is mounted when the profile starts. After installation, you need to stop and restart dsh web (or npx @deepseek-ai/dsh web), then refresh the browser. Confirm that the layer has been combined:

dsh --profile web --dump-config

The output should include the line superpowers-dsh. For headless / tui / custom profiles, replace --profile with the actual profile name in use. Uninstallation also requires specifying the profile, and you need to restart after removal:

dsh plugin --profile web remove superpowers-dsh

The README also mentions another method: create a new conversation in the web interface, send the repository link to the agent, and let it run dsh plugin --profile web add on your behalf. This depends on whether the current agent will execute installation commands, and cannot replace your own review of the source code.

Typical Usage¶

After installing and restarting the profile, these 14 skills will appear in the agent’s skill directory. The entry skill is using-superpowers. DSH uses the skill tool to load skill content by name, and the calling format in the repository’s reference documentation is:

skill(name: "brainstorming")

Other skills also use bare names, such as writing-plans, systematic-debugging, test-driven-development. using-superpowers specifies that instructions you write in AGENTS.md or the session system prompt take precedence over skills; skills then override default behaviors. Only when a human explicitly requests to skip the process should you bypass the skill workflow. DSH does not have automatic loading via CLAUDE.md like Claude Code, so persistent project documentation should be placed in AGENTS.md.

The basic workflow provided by the upstream Superpowers README is still understood in this order after porting (skill names have had the prefix removed):
1. When working on a new feature, first load brainstorming, clarify the goals and constraints, then proceed to design.
2. After the design is approved, use writing-plans to split it into an implementation plan with paths and validation steps.
3. In the implementation phase, load test-driven-development: first write a failing test and confirm it fails due to missing functionality, then write the minimal code to make it pass, and finally refactor.
4. When encountering failures or abnormal behaviors, first load systematic-debugging, complete the root cause investigation before modifying the code.
5. Use requesting-code-review between tasks; after all work is completed, follow finishing-a-development-branch.

These steps are derived from the correspondence between the upstream README and this plugin’s skill list, and are not a transcript of an actual conversation. The plugin itself does not add new business tools callable by the model; it only feeds the skill content into the context. Whether the model follows them depends on the current model and session instructions.

Applicable Scenarios & Notes¶

This project is suitable for users who are already running DeepSeek Harness and want their agents to follow software engineering practices: from design to planning for new features, first investigate root causes when fixing bugs, need to use sub-agents to split tasks or run parallel work, and want to reuse Superpowers’ skill naming convention in DSH. If you mainly use Claude Code / Cursor, you should directly install the upstream obra/superpowers instead of this ported package.

There are several important points to clarify before use:
1. Permissions & Trust: The plugin runs with the permissions of the current dsh process, and may execute build scripts during installation. Both the community directory and GitHub remind you to only install source code that you have reviewed. Pinning the commit hash enables reproducible installations.
2. License: The README, package.json, and npm page all indicate MIT, and note that the skill content is adapted from obra/superpowers (MIT, © Jesse Vincent and contributors). The repository currently does not have a separate LICENSE file, so the GitHub API does not recognize the license field. Please review the README and upstream license yourself before installing.
3. Ecosystem Affiliation: This is a community-maintained adaptation package, not a “certified application” in DeepSeek Harness’s official plugin store. The directory site is a third-party collection.
4. Installation Method: dsh plugin depends on pnpm; you must restart the profile after installation. Do not use bare npm install as a replacement. For domestic users needing to accelerate the npm source, the README mentions setting the registry to https://registry.npmmirror.com, which is the author’s suggestion and not a mandatory step.
5. Platform Limitations: The .sh script included with brainstorming is only available under bash; on Windows, you should use pwsh or the Node script provided in the repository. dsh-tools.md also notes that pwsh in read-only sandboxes runs in ConstrainedLanguage, and you may need to elevate sandbox_permissions when using .NET APIs.
6. Capability Boundaries: The plugin provides methodological text, it will not run tests for you, nor will it guarantee that the model always writes failing test cases first. The skill content has a firm tone, but it can still be overridden by user instructions.

Summary¶

superpowers-dsh connects the TDD, systematic debugging, planning and collaboration skills from obra/superpowers for coding agents into DSH’s host skill registry. Refer to the directory page for the installation command:

dsh plugin add github:LayneChai/superpowers-dsh

After installation, restart the profile, use dsh --profile web --dump-config to confirm the plugin line appears, then use the skill tool to load by bare name. Please review the source code and license yourself before installing.

Directory Page: https://deepseek-harness-plugin.com/zh-CN/plugins/superpowers-dsh/
GitHub: https://github.com/LayneChai/superpowers-dsh
Upstream Skill Library: https://github.com/obra/superpowers
DeepSeek Harness: https://github.com/deepseek-ai/deepseek-harness

### 正式专业译法（适配技术社区语境）： superpowers-dsh: Empowering DeepSeek Harness with TDD, Debugging and Planning Capabilities