What makes Superpowers-Openclaw notable?

2.1K downloads. Trust evidence available

How should Superpowers-Openclaw be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Superpowers-Openclaw

Complete Superpowers methodology for OpenClaw. A 12-skill collection that enforces design-before-code, TDD, systematic debugging, verification, and structure... Skill: Superpowers-Openclaw Owner: fenccerece Summary: Complete Superpowers methodology for OpenClaw. A 12-skill collection that enforces design-before-code, TDD, systematic debugging, verification, and structure... Tags: latest:1.0.0 Version history: v1.0.0 | 2026-05-04T11:36:44.829Z | user v1.0.0 — Initial release - 移植 obra/superpowers 核心方法论至 OpenClaw 平台 - 包含 12 个技能：1 入口 + 4 流程 + 7 实践 - 完整工作流链：brainstorming → writi

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

2.1k

Updated

Oct 9, 2026

Version

1.0.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 2.1K downloads reported by the source. Last updated 10/9/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 2.1K downloadsadoption · observed Oct 9, 2026
Latest release: 1.0.0release · observed May 4, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17fmkyfk8381hxzq5rtdj0jj184f9bj:superpowers-openclaw

Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
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-fenccerece-superpowers-openclaw/snapshot"

Documentation

CLAWHUB

57,771 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

brainstorming/SKILL.md

---
name: superpowers-open-brainstorming
description: >
Use before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.
metadata:
openclaw:
emoji: "💡"
---

# Brainstorming Ideas Into Designs

Help turn ideas into fully formed designs and specs through natural collaborative dialogue.

Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design and get user approval.

<HARD-GATE>
Do NOT write any code, scaffold any project, or take any implementation action until you have presented a design and the user has approved it. This applies to EVERY project regardless of perceived simplicity.
</HARD-GATE>

## Anti-Pattern: "This Is Too Simple To Need A Design"

Every project goes through this process. A todo list, a single-function utility, a config change — all of them. "Simple" projects are where unexamined assumptions cause the most wasted work. The design can be short (a few sentences for truly simple projects), but you MUST present it and get approval.

## Checklist

You MUST create a task for each of these items and complete them 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 your recommendation
4. **Present design** — in sections scaled to their complexity, get user approval after each section
5. **Write design doc** — save to `docs/specs/YYYY-MM-DD-<topic>-design.md` and commit
6. **Spec self-review** — quick inline check for placeholders, contradictions, ambiguity, scope
7. **User reviews written spec** — ask user to review the spec file before proceeding
8. **Transition to implementation** — invoke superpowers-open:writing-plans to create implementation plan

## The Process

**Understanding the idea:**

- Check out the current project state first (files, docs, recent commits)
- Before asking detailed questions, assess scope: if the request describes multiple independent subsystems, flag this immediately. Don't spend questions refining details of a project that needs to be decomposed first.
- If the project is too large for a single spec, help the user decompose into sub-projects: what are the independent pieces, how do they relate, what order should they be built? Then brainstorm the first sub-project through the normal design flow.
- Ask questions one at a time to refine the idea
- Prefer multiple choice questions when possible, but open-ended is fine too
- Only one question per message

**Exploring approaches:**

- Propose 2-3 different approaches with trade-offs
- Present options conversationally with your recommendation and reasoning
- Lead with your recommended option and explain why

**Presenting the design:**

- Once you believe yo

executing-plans/SKILL.md

---
name: superpowers-open-executing-plans
description: >
Use when you have a written implementation plan to execute. Loads the plan, reviews critically, executes all tasks inline, and reports when complete.
metadata:
openclaw:
emoji: "⚡"
---

# Executing Plans

## Overview

Load plan, review critically, execute all tasks, report when complete.

**Announce at start:** "I'm using the executing-plans skill to implement this plan."

**Note:** This is the only execution mode in SuperpowersOpen. There is no subagent-driven alternative. All tasks run inline in the current session.

## The Process

### Step 1: Load and Review Plan
1. Read plan file
2. Review critically - identify any questions or concerns about the plan
3. If concerns: Raise them with your human partner before starting
4. If no concerns: Create task list and proceed

### Step 2: Execute Tasks

For each task:
1. Mark as in_progress
2. Follow each step exactly (plan has bite-sized steps)
3. Run verifications as specified
4. Mark as completed

### Step 3: Complete Development

After all tasks complete and verified:
- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
- **REQUIRED: Use superpowers-open:finishing-a-development-branch**
- Follow that skill to verify tests, present options, execute choice

## When to Stop and Ask for Help

**STOP executing immediately when:**
- Hit a blocker (missing dependency, test fails, instruction unclear)
- Plan has critical gaps preventing starting
- You don't understand an instruction
- Verification fails repeatedly

**Ask for clarification rather than guessing.**

## When to Revisit Earlier Steps

**Return to Review (Step 1) when:**
- Partner updates the plan based on your feedback
- Fundamental approach needs rethinking

**Don't force through blockers** - stop and ask.

## Remember
- Review plan critically first
- Follow plan steps exactly
- Don't skip verifications
- Reference skills when plan says to
- Stop when blocked, don't guess
- Never start implementation on main/master branch without explicit user consent

## Integration

**Required workflow skills:**
- **superpowers-open:using-git-worktrees** — Set up isolated workspace before starting
- **superpowers-open:writing-plans** — Creates the plan this skill executes
- **superpowers-open:finishing-a-development-branch** — Complete development after all tasks

finishing-a-development-branch/SKILL.md

---
name: superpowers-open-finishing-a-development-branch
description: >
  Use when implementation is complete, all tests pass, and you need to decide how to integrate the work. Guides completion of development work by presenting structured options for merge, PR, or cleanup.
metadata:
  openclaw:
    emoji: "🏁"
---

# Finishing a Development Branch

## Overview

Guide completion of development work by presenting clear options and handling chosen workflow.

**Core principle:** Verify tests → Present options → Execute choice → Clean up.

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

## The Process

### Step 1: Verify Tests

**Before presenting options, verify tests pass:**

```bash
# Run project's test suite
npm test / cargo test / pytest / go test ./...
```

**If tests fail:**
```
Tests failing (<N> failures). Must fix before completing:

[Show failures]

Cannot proceed with merge/PR until tests pass.
```

Stop. Don't proceed to Step 2.

**If tests pass:** Continue to Step 2.

### Step 2: Determine Base Branch

```bash
# Try common base branches
git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null
```

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

### Step 3: Present Options

Present exactly these 4 options:

```
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?
```

**Don't add explanation** - keep options concise.

### Step 4: Execute Choice

#### Option 1: Merge Locally

```bash
# Switch to base branch
git checkout <base-branch>

# Pull latest
git pull

# Merge feature branch
git merge <feature-branch>

# Verify tests on merged result
<test command>

# If tests pass
git branch -d <feature-branch>
```

#### Option 2: Push and Create PR

```bash
# Push branch
git push -u origin <feature-branch>

# Create PR
gh pr create --title "<title>" --body "$(cat <<'EOF'
## Summary
<2-3 bullets of what changed>

## Test Plan
- [ ] <verification steps>
EOF
)"
```

If `gh` CLI not available, instruct the user to create the PR manually via their Git platform.

#### Option 3: Keep As-Is

Report: "Keeping branch <name>."

**Don't delete anything.**

#### Option 4: Discard

**Confirm first:**
```
This will permanently delete:
- Branch <name>
- All commits: <commit-list>

Type 'discard' to confirm.
```

Wait for exact confirmation.

If confirmed:
```bash
git checkout <base-branch>
git branch -D <feature-branch>
```

### Non-Git Projects

If the project is not a git repository, skip branch operations. Instead:
- Confirm all changes are saved
- Ask the user what to do next

## Quick Reference

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

## Red Flags

*

receiving-code-review/SKILL.md

---
name: superpowers-open-receiving-code-review
description: >
Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable. Requires technical rigor and verification, not performative agreement or blind implementation.
metadata:
openclaw:
emoji: "👀"
---

# Code Review Reception

## Overview

Code review requires technical evaluation, not emotional performance.

**Core principle:** Verify before implementing. Ask before assuming. Technical correctness over social comfort.

## The Response Pattern

```
WHEN receiving code review feedback:

1. READ: Complete feedback without reacting
2. UNDERSTAND: Restate requirement in own words (or ask)
3. VERIFY: Check against codebase reality
4. EVALUATE: Technically sound for THIS codebase?
5. RESPOND: Technical acknowledgment or reasoned pushback
6. IMPLEMENT: One item at a time, test each
```

## Forbidden Responses

**NEVER:**
- "You're absolutely right!" (performative agreement)
- "Great point!" / "Excellent feedback!" (performative)
- "Let me implement that now" (before verification)

**INSTEAD:**
- Restate the technical requirement
- Ask clarifying questions
- Push back with technical reasoning if wrong
- Just start working (actions > words)

## Handling Unclear Feedback

```
IF any item is unclear:
STOP - do not implement anything yet
ASK for clarification on unclear items

WHY: Items may be related. Partial understanding = wrong implementation.
```

**Example:**
```
Your human partner: "Fix 1-6"
You understand 1,2,3,6. Unclear on 4,5.

❌ WRONG: Implement 1,2,3,6 now, ask about 4,5 later
✅ RIGHT: "I understand items 1,2,3,6. Need clarification on 4 and 5 before proceeding."
```

## Source-Specific Handling

### From your human partner
- **Trusted** - implement after understanding
- **Still ask** if scope unclear
- **No performative agreement**
- **Skip to action** or technical acknowledgment

### From External Reviewers
```
BEFORE implementing:
1. Check: Technically correct for THIS codebase?
2. Check: Breaks existing functionality?
3. Check: Reason for current implementation?
4. Check: Works on all platforms/versions?
5. Check: Does reviewer understand full context?

IF suggestion seems wrong:
Push back with technical reasoning

IF can't easily verify:
Say so: "I can't verify this without [X]. Should I [investigate/ask/proceed]?"

IF conflicts with your human partner's prior decisions:
Stop and discuss with your human partner first
```

## YAGNI Check for "Professional" Features

```
IF reviewer suggests "implementing properly":
grep codebase for actual usage

IF unused: "This endpoint isn't called. Remove it (YAGNI)?"
IF used: Then implement properly
```

## Implementation Order

```
FOR multi-item feedback:
1. Clarify anything unclear FIRST
2. Then implement in this order:
- Blocking issues (breaks, security)
- Simple fixes (typos, imports)
- Complex fixes (refactoring

requesting-code-review/SKILL.md

---
name: superpowers-open-requesting-code-review
description: >
  Use when completing tasks, implementing major features, or before merging to verify work meets requirements. Provides a self-review checklist since subagent-based review is not available on OpenClaw.
metadata:
  openclaw:
    emoji: "🔍"
---

# Requesting Code Review

Self-review your work to catch issues before they reach a human reviewer.

**Core principle:** Review early, review often. Since subagent-based review is not available on OpenClaw, use this structured self-review checklist.

## When to Review

**Mandatory:**
- After each task in plan execution
- After completing major feature
- Before merge to main

**Optional but valuable:**
- When stuck (fresh perspective)
- Before refactoring (baseline check)
- After fixing complex bug

## Self-Review Checklist

Run this checklist against your changes. Be honest — you're looking for real issues, not validation.

### 1. Spec Compliance

```
- [ ] Every requirement in the spec/plan has been implemented
- [ ] Nothing extra was added beyond the spec (YAGNI)
- [ ] All specified edge cases are handled
- [ ] No spec requirements were skipped or deferred
```

### 2. Code Quality

```
- [ ] Code is minimal — no over-engineering or premature abstraction
- [ ] Names are clear and describe what things do
- [ ] No magic numbers — constants are named
- [ ] No dead code or commented-out blocks
- [ ] Error handling is present where needed (and absent where not)
- [ ] No "TODO" or "FIXME" without a tracking issue
```

### 3. Testing

```
- [ ] Every new function/method has a test
- [ ] Tests use real code (mocks only if unavoidable)
- [ ] Edge cases are covered (empty input, null, boundary values)
- [ ] Error paths are tested
- [ ] All tests pass with clean output
- [ ] **REQUIRED: superpowers-open:test-driven-development** was followed
```

### 4. Safety

```
- [ ] No credentials, tokens, or secrets in code
- [ ] User input is validated at boundaries
- [ ] No unsafe shell command construction
- [ ] Dependencies are appropriate and necessary
```

### 5. Git Hygiene

```
- [ ] Changes are focused — one concern per commit
- [ ] Commit messages describe WHY, not WHAT
- [ ] No unrelated files accidentally included
- [ ] Branch is up to date with base
```

## What To Do With Findings

| Severity | Action |
|----------|--------|
| **Spec gap** (missing requirement) | Implement before proceeding |
| **Bug** (incorrect behavior) | Fix with TDD cycle |
| **Quality issue** (naming, magic number) | Fix now, one commit |
| **Minor** (style nit) | Note, fix if touching file anyway |

## If You Find Nothing

If the checklist is clean:
- **REQUIRED: Use superpowers-open:verification-before-completion** — run actual verification commands
- Only then proceed to **superpowers-open:finishing-a-development-branch** or the next task

## Common Mistakes

**Skipping review because "it's simple"**
- Simple code has simple bugs. Review it.

**Rubber-stamping your own work

Github ReposUpdated 13h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.