dsh-superpower: Integrating 14 developer skills from obra/superpowers into DeepSeek Harness

Introduction¶

When building a coding Agent with DeepSeek Harness (DSH), a common pain point is the difficulty of reusing methodological capabilities: requirements clarification, TDD, systematic debugging, etc., usually exist as SKILL.md skill files. To use them, one has to write their own loading and registration logic, handling injection timing and compatibility across different presets. Existing approaches often involve manually copying skill files into each project and writing the loading code from scratch for each.

dsh-superpower turns this into a plugin: after installing with a single command, the 14 skills from obra/superpowers automatically enter the DSH skill registry, and the accompanying session discipline is injected at the appropriate time. Below, I introduce its features, installation methods, and working principles.

What is it¶

dsh-superpower (pai535Huang/dsh-superpower) is a DSH plugin positioned as a “DSH plugin bundle for obra/superpowers skills and development workflows”: it bundles obra/superpowers (a set of development methodologies for coding Agents maintained by Jesse Vincent, including 14 SKILL.md skills such as brainstorming, TDD, systematic-debugging, subagent-driven-development, etc.) and integrates them into DeepSeek Harness. It is licensed under MIT, current version 0.1.0, and requires Node >= 20.

Implementation-wise, it is a host bundle (bundle patch mounted via ./cordis.patch.yml): it registers the bundled skills into the DSH skill registry via ctx.skills.registerProvider(), and injects the using-superpowers discipline (the “1% rule”) at the beginning of every session that has a skill tool.

Core Features¶

Bundling and Registering 14 Skills¶

The 14 SKILL.md files are distributed directly with the package. The namespace has been rewritten (superpowers:<name> → bare <name>), and the upstream platform adaptation file references/dsh-tools.md has been merged. Registration is handled by lib/index.js: it mounts a provider to the registry, list() scans the skills/ directory, and get() parses the frontmatter and body as needed, returning definitions with the directory resource base.

Injection of Discipline at Session Start¶

lib/bootstrap.mjs mounts agent/pre-step and decides whether to inject based on the visibility of ctx.tools.get('skill', agent). There are three injection rules:

1. The full body of using-superpowers is only injected once at the very first request of the session, and re-injected after compaction, not in every round of prompts (consistent with the upstream SessionStart semantics);
2. Sub-agents (delegationDepth > 0) skip injection;
3. The injected body is fetched in real-time from the registry; references/dsh-tools.md is read from the skill resource base and injected with the envelope.

Preset Compatibility¶

Any preset that provides a skill loading surface can see the bundled skills. The specific behaviors are as follows:

No Build Step, Add Custom Skills Directly¶

Just place a new <kebab-name>/SKILL.md in skills/; the plugin will discover it automatically at runtime without needing to modify any code. Skill files start with YAML frontmatter, where name + description are required and whenToUse is optional:

---
name: my-review-flow
description: Triggered in code review scenarios, checking items one by one according to the checklist
---

Triggering follows description matching; the directory only displays name + description.

Local Shadowing of Same-Named Skills¶

Same-named skills in the project/user skill root will shadow the bundled version (the bundled provider rank is lower than the local skill root). This is intentional: user intent takes priority; if you want to override a bundled skill, simply place a file with the same name locally.

Installation and Activation¶

The official installation command is as follows, replace <name> with your profile name:

dsh plugin --profile <name> add github:pai535Huang/dsh-superpower

After restarting the profile, the new session is ready to use.

Typical Usage¶

The upstream acceptance test cases are recorded in docs/acceptance-test.md: inputting “Let’s make a react todo list” under the standard preset will trigger the brainstorming skill to clarify requirements first, then move into the coding phase. This document also retains execution records and evidence lists, which can be used for self-verification.

If you want to extend the skill set, add a SKILL.md in skills/ following the format above; no code changes are needed, and the provider will automatically discover it.

Development and Verification¶

After cloning the repository, run:

npm ci
npm run check

npm run check will run tests and validations sequentially. Broken down:

1. npm test: Unit tests, covering manifest loading, registration, bootstrap guards/frequency, and migration cleanup;
2. npm run validate: Consistency validation for skill collection, frontmatter, and manifest;
3. docs/acceptance-test.md: Execution records and evidence lists for upstream acceptance test cases.

devDependencies only includes js-yaml ^4.1.0, there is no build step, and the source code can be read directly.

Applicable Scenarios and Notes¶

It is suitable for two groups of people: developers already using DSH who want to introduce the obra/superpowers methodology but don’t want to write the loading and injection logic manually; and teams that want skills distributed with the plugin while retaining the ability to override with local same-named skills.

There are a few points to confirm before installation:

1. The plugin runs with the permissions of the current DSH process; you should check the source code and license before installing. This plugin and its skill content are both MIT (the skill content is derived from obra/superpowers, Copyright (c) 2025 Jesse Vincent); see LICENSE in the repository root for details;
2. The minimal preset has no skill row and does not inject any skills by design; if your preset does not provide a skill loading surface, these skills will not take effect;
3. Discipline injection only occurs on the first request of the session and after compaction; if you expect it to be forcibly carried in every round of prompts, you need to handle it separately.

Conclusion¶

dsh-superpower solves a specific problem: integrating a set of mature development methodology skills into DSH, eliminating the repetitive work of loading, registering, and timing injections, while not sacrificing the space for local overrides and custom extensions.

• GitHub Repository: https://github.com/pai535Huang/dsh-superpower
• Community Directory Page (Third-party site, no official affiliation with DeepSeek / Hyperbolic): https://www.skillhub.cn/plugins/pai535Huang/dsh-superpower