Xpersona
S

Superpowers Dev Workflow

CLAWHUB · Unverified

Spec-first, TDD, subagent-driven software development workflow. Use when: (1) building any new feature or app — triggers brainstorm → plan → subagent executi... Skill: Superpowers Dev Workflow Owner: wlshlad85 Summary: Spec-first, TDD, subagent-driven software development workflow. Use when: (1) building any new feature or app — triggers brainstorm → plan → subagent executi... Tags: latest:1.0.0 Version history: v1.0.0 | 2026-02-27T21:17:44.279Z | user Initial port of obra/superpowers for OpenClaw — spec-first, TDD, subagent-driven development workflow Archive index: Archive

62
Rank
84
Safety
32k
Downloads

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 31.5K downloads reported by the source. Last updated 11/16/2026.

Avoid when

  • Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Install and run

Setup complexity: low.

clawhub skill install s17f2yfxj46m8sn9jyk0tvm0z9884wpk:superpowers
  1. Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
  2. Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-wlshlad85-superpowers-erpowers-2/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

22,816 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: superpowers
description: >
  Spec-first, TDD, subagent-driven software development workflow. Use when:
  (1) building any new feature or app — triggers brainstorm → plan → subagent execution loop,
  (2) debugging a bug or test failure — triggers systematic root-cause process,
  (3) user says "let's build", "help me plan", "I want to add X", or "this is broken",
  (4) completing a feature branch — triggers test verification + merge/PR options.
  NOT for: one-liner fixes (just edit), reading code, or non-code tasks.
  Requires exec tool and sessions_spawn.
---

# Superpowers — OpenClaw Edition

Adapted from [obra/superpowers](https://github.com/obra/superpowers). Mandatory workflow — not suggestions.

## The Pipeline

```
Idea → Brainstorm → Plan → Subagent-Driven Build (TDD) → Code Review → Finish Branch
```

Every coding task follows this pipeline. "Too simple to need a design" is always wrong.

---

## Phase 1: Brainstorming

**Trigger:** User wants to build something. Activate before touching any code.

**See:** [references/brainstorming.md](references/brainstorming.md)

**Summary:**
1. Explore project context (files, docs, recent commits)
2. Ask clarifying questions — **one at a time**, prefer multiple choice
3. Propose 2–3 approaches with trade-offs + recommendation
4. Present design in sections, get approval after each
5. Write design doc → `docs/plans/YYYY-MM-DD-<topic>-design.md` → commit
6. Hand off to **Phase 2: Writing Plans**

**HARD GATE:** Do NOT write any code until user approves design.

---

## Phase 2: Writing Plans

**Trigger:** Design approved. Activated by brainstorming phase.

**See:** [references/writing-plans.md](references/writing-plans.md)

**Summary:**
- Write a detailed task-by-task implementation plan
- Each task = 2–5 minutes: write test → watch fail → implement → watch pass → commit
- Save to `docs/plans/YYYY-MM-DD-<feature>.md`
- Announce: `"I'm using the writing-plans skill to create the implementation plan."`
- After saving, offer two execution modes:
  - **Subagent-driven (current session):** `sessions_spawn` per task + two-stage review
  - **Manual execution:** User runs tasks themselves

---

## Phase 3: Subagent-Driven Development

**Trigger:** Plan exists, user chooses subagent-driven execution.

**See:** [references/subagent-development.md](references/subagent-development.md)

**Per-task loop (OpenClaw):**
1. `sessions_spawn` an implementer subagent with task + full plan context
2. Wait for completion announcement
3. `sessions_spawn` a spec-reviewer subagent → must confirm code matches spec
4. `sessions_spawn` a code-quality reviewer subagent → must approve quality
5. Fix any issues, re-review if needed
6. Mark task done, move to next
7. Final: dispatch overall code reviewer → hand off to Phase 5

**TDD is mandatory in every task.** See [references/tdd.md](references/tdd.md).

---

## Phase 4: Systematic Debugging

**Trigger:** Bug, test failure, unexpected behaviour — any technical issue.

**See:*

_meta.json

{
  "ownerId": "kn70str3hbwe1ep2af4v1nb9rd80bs9h",
  "slug": "superpowers",
  "version": "1.0.0",
  "publishedAt": 1772227064279
}

references/brainstorming.md

# Brainstorming Reference

Source: obra/superpowers brainstorming skill

## Checklist (in order)

1. **Explore project context** — check files, docs, recent commits
2. **Ask clarifying questions** — one at a time, understand purpose/constraints/success criteria
3. **Propose 2–3 approaches** — with trade-offs and recommendation
4. **Present design** — in sections scaled to complexity, get approval after each section
5. **Write design doc** — `docs/plans/YYYY-MM-DD-<topic>-design.md` → commit
6. **Transition** — invoke writing-plans phase

## Rules

- One question per message only
- Multiple choice preferred over open-ended
- Every project goes through this process — no exceptions for "simple" ones
- HARD GATE: Do NOT write code, scaffold, or implement anything until design is approved
- Propose 2–3 approaches before settling, lead with recommendation

## Questions to Ask

- What are you really trying to do? (purpose)
- What constraints exist? (time, tech stack, dependencies)
- What does success look like? (success criteria)
- What should this NOT do? (scope boundaries)

## Design Sections to Cover

- Architecture overview
- Components and their responsibilities
- Data flow
- Error handling approach
- Testing strategy

## After Design Approval

- Write design to `docs/plans/YYYY-MM-DD-<topic>-design.md`
- Commit the design doc
- Hand off to writing-plans — no other skill, no implementation

references/finishing-branch.md

# Finishing a Development Branch Reference

Source: obra/superpowers finishing-a-development-branch skill

## Overview

Verify tests → Present options → Execute choice.

Announce at start: "I'm using the finishing-a-development-branch skill to complete this work."

## Step 1: Verify Tests

Run the project's test suite. If tests fail — stop. Do not proceed.

```bash
# Python
pytest -q

# Node/TS
pnpm test

# Rust
cargo test

# Go
go test ./...
```

Show failures clearly. Cannot merge/PR until tests pass.

## Step 2: Determine Base Branch

```bash
git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null
git branch --show-current
```

Or ask: "This branch split from main — is that correct?"

## Step 3: Present Options

Present exactly these 4 options — no extra explanation:

```
Implementation complete. What would you like to do?

1. Merge back to <base-branch> locally
2. Push and create a Pull Request
3. Keep the branch as-is (I'll handle it later)
4. Discard this work

Which option?
```

## Step 4: Execute Choice

### Option 1: Merge Locally

```bash
git checkout <base-branch>
git pull
git merge <feature-branch>
<run tests>
git branch -d <feature-branch>
```

### Option 2: Push + PR

```bash
git push -u origin <feature-branch>
gh pr create --title "<title>" --body "## Summary
- <bullet 1>
- <bullet 2>

## Test Plan
- [ ] <verification step>"
```

### Option 3: Keep As-Is

Report: "Keeping branch `<name>`. You can return to it later."

### Option 4: Discard

**Confirm first:**
```
This will permanently delete:
- Branch <name>
- All commits since <base-branch>

Type 'discard' to confirm.
```

Wait for exact word "discard". Then:
```bash
git checkout <base-branch>
git branch -D <feature-branch>
```

## Quick Reference

| Option | Merge | Push | Keep Branch | Delete Branch |
|--------|-------|------|-------------|---------------|
| 1. Merge locally | ✓ | — | — | ✓ |
| 2. Create PR | — | ✓ | ✓ | — |
| 3. Keep as-is | — | — | ✓ | — |
| 4. Discard | — | — | — | ✓ (force) |

## Common Mistakes

- Skipping test verification before offering options → always verify first
- Merging without pulling latest base → always `git pull` before merge
- Deleting branch before confirming PR merged → wait for merge confirmation

references/subagent-development.md

# Subagent-Driven Development Reference

Source: obra/superpowers subagent-driven-development skill
Adapted for OpenClaw (sessions_spawn instead of Claude Code Task tool)

## Core Principle

Fresh sub-agent per task + two-stage review (spec then quality) = high quality, fast iteration.

## OpenClaw Dispatch Pattern

Use `sessions_spawn` for each role. Pass a structured prompt:

```
GOAL: [one sentence — what outcome]
CONTEXT: [plan file path + relevant background]
FILES: [specific paths to touch]
CONSTRAINTS: [TDD mandatory, no scope creep, no untested code]
VERIFY: [test command + expected output]
TASK: [paste full task text from plan doc]
```

## Per-Task Loop

For each task in the plan:

1. **Dispatch implementer sub-agent** via `sessions_spawn`
   - Include: full task text, plan file path, TDD constraint
   - Wait for completion announcement

2. **Dispatch spec-reviewer sub-agent** via `sessions_spawn`
   - Include: what was implemented, plan requirements, git diff
   - Must confirm: code matches spec exactly
   - If gaps found → dispatch implementer again to fix

3. **Dispatch code-quality reviewer sub-agent** via `sessions_spawn`
   - Include: git diff, description of implementation
   - Must approve: clean code, no dead code, DRY, YAGNI
   - If issues found → dispatch implementer to fix, re-review

4. Mark task complete, move to next task

## After All Tasks Complete

1. Dispatch final overall reviewer sub-agent (full diff, all tasks)
2. Fix any critical/important issues found
3. Hand off to finishing-branch phase

## Implementer Sub-Agent Prompt Template

```
You are implementing a coding task. Follow TDD strictly.

PLAN FILE: [path]
TASK: [task N text verbatim]

CONSTRAINTS:
- Write failing test FIRST. Run it. Confirm it fails. Then implement.
- Minimal implementation only — YAGNI
- Commit after each green test: git add <files> && git commit -m "..."
- Do NOT change files outside this task's scope
- Do NOT add features not in the task

VERIFY:
- Run: [test command]
- Expected: [expected output]

Report when done: what you implemented, test results, commit SHA.
```

## Spec-Reviewer Sub-Agent Prompt Template

```
You are reviewing code for spec compliance only.

PLAN FILE: [path]
TASK BEING REVIEWED: [task N text]
GIT RANGE: [base_sha..head_sha]

Review ONLY whether the implementation matches the spec.
Report:
- PASS or FAIL
- Any spec gaps (what was specified but not implemented)
- Do NOT comment on code style or quality
```

## Code-Quality Reviewer Sub-Agent Prompt Template

```
You are reviewing code quality only (not spec compliance).

GIT RANGE: [base_sha..head_sha]
DESCRIPTION: [what was implemented]

Review for:
- DRY violations
- Dead code
- YAGNI violations (unnecessary features)
- Poor naming
- Missing error handling

Severity: Critical / Important / Minor
Report: approve or list issues by severity.
```

## Review Severity Actions

| Severity | Action |
|----------|--------|
| Critical | Fix before proceeding — blocks next task

Sponsored

Ads related to Superpowers Dev Workflow and adjacent AI workflows.