superpowers-reasonix skill

A Superpowers port for the Reasonix agent on DeepSeek models: 12 skills for test-first work, plans and evidence-based debugging.

  • 102 ★ on the repository
  • Last commit
  • MIT
Skill

Extended access

Why this level

  • The installer downloads a release and copies files into the `~/.reasonix/skills/` home folder.
  • The skills shape how the agent works: it runs tests and git commands.
All reasons and checks

christopherarter/superpowers-reasonix

Install

Works in

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/superpowers-reasonix

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • The installer downloads a release and copies files into the `~/.reasonix/skills/` home folder.
  • The skills shape how the agent works: it runs tests and git commands.

This is third-party code. Review the repository files before installing.

What it does

A port of the obra/superpowers set for the Reasonix CLI (DeepSeek-Reasonix) and DeepSeek models. Twelve skills take a project from idea to merge: design brainstorming, plans, TDD, systematic debugging, verification before saying done, git worktrees, branch finishing, receiving code review and writing new skills. The skills are rewritten for Reasonix tools. Delegation, review, waiting and code exploration are handled by the built-in `task`, `review`, `wait` and `explore`, so there are no separate skills for them. The "load a skill first" rule lives in an `AGENTS.md` file that you copy into the project.

Who it is for. Reasonix and DeepSeek users who want the Superpowers discipline in its familiar order: test, plan, verify.

Good fit when

  • A new feature: start with `superpowers-brainstorming`, then plan and TDD.
  • A test fails or code behaves oddly and the cause is traced from evidence.
  • Before saying done you must run the checks.
  • Work happens in an isolated branch through git worktrees.
  • A slow or odd Reasonix session is analyzed from its transcript with `superpowers-diagnosing-superpowers`.

Not a fit when

  • You work in Claude Code: the original superpowers exists for it, and this port is built around Reasonix tools.
  • You need separate subagent skills: Reasonix built-in commands replaced delegation.
  • Your model is outside the DeepSeek family: the port's benchmarks ran on `deepseek-flash`.

Example request

Add pagination to the orders list: discuss the design first, write a plan and code with TDD.

Limitations

The `install.sh` installer puts skills into `~/.reasonix/skills/`. The structural check on 2026-10-13 passed for all 12 skills, while the behavioral stage was skipped without a DeepSeek key, so the diagnosis skill is untested on a model. The `SessionStart` hook in Reasonix does not pass text into context, so `AGENTS.md` provides the always-on discipline and must be copied into the project by hand. The skills are adapted to Reasonix, so on other agents they need separate verification.

How to disable. Delete the `superpowers-*` folders from `~/.reasonix/skills/` and the `AGENTS.md` file from the project.

FAQ

How do I install superpowers for Reasonix?

Run `curl -fsSL https://raw.githubusercontent.com/christopherarter/superpowers-reasonix/main/install.sh | bash`. Rerunning upgrades the skills, `--force` reinstalls and `--version v1.0.0` pins a release.

How does the port differ from the original superpowers?

It is not a literal translation. Skills for subagents, review and code exploration are replaced by the built-in `task`, `review`, `wait` and `explore`, and `superpowers-sync-upstream` and `superpowers-diagnosing-superpowers` are added.

Why is AGENTS.md needed?

Reasonix has no hook that force-loads a starting skill. The "load a skill before acting" rule therefore sits in `AGENTS.md`, which is read in every session.

Which skills does the port include?

Twelve: brainstorming, plans, plan execution, TDD, systematic debugging, verification before completion, git worktrees, branch finishing, receiving code review, writing skills, upstream sync and session diagnosis.

How do I check that the skills loaded?

In a Reasonix session run `/skill paths` to confirm the directory is seen and `/skills` to list the discovered skills.

Discussion

No questions or reviews yet.

Skills

A plugin that ports 15 superpowers skills into DeepSeek Harness: planning, TDD, debugging, review and parallel agents.

PluginMinimal access159Repository stars

Coding-agent skills built on Superpowers plus a board where the agent draws options and a person chooses and comments.

PluginExtended access401Repository stars
Editors’ pick

A skills library that gives coding agents a development process: brainstorming, planning, TDD, subagents and code review

PluginExtended access316.7KRepository stars

A set of 17 engineering skills: evidence-driven debugging, code review, git worktrees, SSH tunnels and mobile automation.

SkillBroad access78Repository stars

A Chinese edition of the superpowers skill set: translated development methods plus a few original skills, installed with one command across many agents

PluginExtended access8.5KRepository stars

Skills for DeepSeek: short plan, verify and review loops, each with a hard stop condition and real command output as proof.

SkillBroad access267Repository stars

README in short

The port includes 12 skills, an installer and two `deepseek-flash` benchmarks: a skill structure gate and skill selection on realistic prompts. Configuration examples live in `reasonix.toml.example` and `AGENTS.md.example`.

README badge

Original SKILL.md

---
name: superpowers-test-driven-development
description: Writing or fixing any code? Load first — write the failing test before the code.
---

# Test-Driven Development (TDD)

## Overview

Test first. Watch it fail. Write minimal code to pass.

**Core principle:** Didn't watch the test fail? You don't know it tests the right thing.

**Break the letter of the rules = break the spirit.**

## When to Use

Always: new features, bug fixes, refactors, behavior changes.

Exceptions (ask your human partner): throwaway prototypes, generated code, config files.

"Skip TDD just this once"? Stop. That's rationalization.

## The Iron Law

```
NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
```

Code before the test? Delete it. Start over. Don't keep it as "reference", don't "adapt" it, don't look at it. Delete means delete. Implement fresh from tests.

## Red-Green-Refactor

```dot
digraph tdd_cycle {
    rankdir=LR;
    red [label="RED\nWrite failing test", shape=box, style=filled, fillcolor="#ffcccc"];
    verify_red [label="Verify fails\ncorrectly", shape=diamond];
    green [label="GREEN\nMinimal code", shape=box, style=filled, fillcolor="#ccffcc"];
    verify_green [label="Verify passes\nAll green", shape=diamond];
    refactor [label="REFACTOR\nClean up", shape=box, style=filled, fillcolor="#ccccff"];
    next [label="Next", shape=ellipse];

    red -> verify_red;
    verify_red -> green [label="yes"];

Report a problem