{"id":"553c9c79-9901-48e1-beeb-59ef2c73d4d3","entityType":"agent","slug":"clawhub-fenccerece-superpowers-openclaw","name":"Superpowers-Openclaw","canonicalUrl":"https://www.xpersona.co/agent/clawhub-fenccerece-superpowers-openclaw","canonicalPath":"/agent/clawhub-fenccerece-superpowers-openclaw","generatedAt":"2026-10-10T08:45:32.562Z","source":"CLAWHUB","claimStatus":"UNCLAIMED","verificationTier":"NONE","summary":{"evidence":{"source":"editorial-content","verified":true,"confidence":"high","updatedAt":"2026-10-09T18:50:43.337Z","emptyReason":null},"description":"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","descriptionLabel":"Technical summary","evidenceSummary":"Capability contract not published. No trust telemetry is available yet. 2.1K downloads reported by the source. Last updated 10/9/2026.","installCommand":"clawhub skill install s17fmkyfk8381hxzq5rtdj0jj184f9bj:superpowers-openclaw","sourceUrl":"https://clawhub.ai/fenccerece/superpowers-openclaw","homepage":"https://clawhub.ai/fenccerece/skills/superpowers-openclaw","primaryLinks":[{"label":"View on ClawHub","url":"https://clawhub.ai/fenccerece/superpowers-openclaw","kind":"source"},{"label":"Homepage","url":"https://clawhub.ai/fenccerece/skills/superpowers-openclaw","kind":"homepage"}],"safetyScore":84,"overallRank":62,"popularityScore":66,"trustScore":null,"claimedByName":null,"isOwner":false,"seoDescription":"Complete Superpowers methodology for OpenClaw. A 12-skill collection that enforces design-before-code, TDD, systematic debugging, verification, and structure..."},"coverage":{"evidence":{"source":"public-profile","verified":false,"confidence":"medium","updatedAt":"2026-10-09T18:50:43.337Z","emptyReason":null},"protocols":[{"protocol":"OPENCLEW","label":"OpenClaw","status":"self-declared","notes":"Declared in the public agent profile."}],"capabilities":[],"verifiedCount":0,"selfDeclaredCount":1,"capabilityMatrix":{"rows":[{"key":"OPENCLEW","type":"protocol","support":"unknown","confidenceSource":"profile","notes":"Listed on profile"}],"flattenedTokens":"protocol:OPENCLEW|unknown|profile"}},"adoption":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-09T18:50:43.337Z","emptyReason":null},"stars":null,"forks":null,"downloads":2110,"packageName":null,"latestVersion":"1.0.0","tractionLabel":"2.1K downloads"},"release":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-09T18:50:43.336Z","emptyReason":null},"lastUpdatedAt":"2026-10-09T18:50:43.337Z","lastCrawledAt":"2026-10-09T18:50:43.336Z","lastIndexedAt":null,"nextCrawlAt":"2026-10-10T18:50:43.336Z","lastVerifiedAt":null,"highlights":[{"version":"1.0.0","createdAt":"2026-05-04T11:36:44.829Z","changelog":"v1.0.0 — Initial release - 移植 obra/superpowers 核心方法论至 OpenClaw 平台 - 包含 12 个技能：1 入口 + 4 流程 + 7 实践 - 完整工作流链：brainstorming → writing-plans → executing-plans → finishing - 保留 TDD、系统化调试、完成前验证等严格纪律技能 - 移除 subagent 依赖，适配 OpenClaw 内联执行模式 - 所有交叉引用使用 superpowers-open: 命名空间 - using-superpowers-open 入口技能包含完整工具映射表","fileCount":22,"zipByteSize":63566}]},"execution":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No published capability contract is available yet."},"installCommand":"clawhub skill install s17fmkyfk8381hxzq5rtdj0jj184f9bj:superpowers-openclaw","setupComplexity":"low","setupSteps":["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":{"contractStatus":"missing","authModes":[],"requires":[],"forbidden":[],"supportsMcp":false,"supportsA2a":false,"supportsStreaming":false,"inputSchemaRef":null,"outputSchemaRef":null,"dataRegion":null,"contractUpdatedAt":null,"sourceUpdatedAt":null,"freshnessSeconds":null},"invocationGuide":{"preferredApi":{"snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/trust"},"curlExamples":["curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/snapshot\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/contract\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/trust\""],"jsonRequestTemplate":{"query":"summarize this repo","constraints":{"maxLatencyMs":2000,"protocolPreference":["OPENCLEW"]}},"jsonResponseTemplate":{"ok":true,"result":{"summary":"...","confidence":0.9},"meta":{"source":"CLAWHUB","generatedAt":"2026-10-10T08:45:32.560Z"}},"retryPolicy":{"maxAttempts":3,"backoffMs":[500,1500,3500],"retryableConditions":["HTTP_429","HTTP_503","NETWORK_TIMEOUT"]}},"endpoints":{"dossierUrl":"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/dossier","snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-fenccerece-superpowers-openclaw/trust"}},"reliability":{"evidence":{"source":"runtime-metrics","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No trust, reliability, or runtime telemetry is available."},"trust":{"status":"unavailable","handshakeStatus":"UNKNOWN","verificationFreshnessHours":null,"reputationScore":null,"p95LatencyMs":null,"successRate30d":null,"fallbackRate":null,"attempts30d":null,"trustUpdatedAt":null,"trustConfidence":"unknown","sourceUpdatedAt":null,"freshnessSeconds":null},"decisionGuardrails":{"doNotUseIf":["Contract metadata is missing or unavailable for deterministic execution."],"safeUseWhen":[],"riskFlags":["missing_or_unavailable_contract","trust_data_unavailable","schema_references_missing"],"operationalConfidence":"low"},"executionMetrics":{"observedLatencyMsP50":null,"observedLatencyMsP95":null,"estimatedCostUsd":null,"uptime30d":null,"rateLimitRpm":null,"rateLimitBurst":null,"lastVerifiedAt":null,"verificationSource":null},"runtimeMetrics":{"successRate":null,"avgLatencyMs":null,"avgCostUsd":null,"hallucinationRate":null,"retryRate":null,"disputeRate":null,"p50Latency":null,"p95Latency":null,"lastUpdated":null}},"benchmarks":{"evidence":{"source":"no-benchmark-data","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No benchmark suites or observed failure patterns are available."},"suites":[],"failurePatterns":[]},"artifacts":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"high","updatedAt":"2026-10-09T18:50:43.337Z","emptyReason":null},"readme":"Skill: Superpowers-Openclaw\n\nOwner: fenccerece\n\nSummary: Complete Superpowers methodology for OpenClaw. A 12-skill collection that enforces design-before-code, TDD, systematic debugging, verification, and structure...\n\nTags: latest:1.0.0\n\nVersion history:\n\nv1.0.0 | 2026-05-04T11:36:44.829Z | user\n\nv1.0.0 — Initial release\n\n  - 移植 obra/superpowers 核心方法论至 OpenClaw 平台\n  - 包含 12 个技能：1 入口 + 4 流程 + 7 实践\n  - 完整工作流链：brainstorming → writing-plans → executing-plans → finishing\n  - 保留 TDD、系统化调试、完成前验证等严格纪律技能\n  - 移除 subagent 依赖，适配 OpenClaw 内联执行模式\n  - 所有交叉引用使用 superpowers-open: 命名空间\n  - using-superpowers-open 入口技能包含完整工具映射表\n\nArchive index:\n\nArchive v1.0.0: 22 files, 63566 bytes\n\nFiles: brainstorming/SKILL.md (5644b), executing-plans/SKILL.md (2400b), finishing-a-development-branch/SKILL.md (3558b), README.md (2177b), receiving-code-review/SKILL.md (5055b), requesting-code-review/SKILL.md (3438b), skill-card.md (2365b), SKILL.md (2142b), systematic-debugging/condition-based-waiting.md (3516b), systematic-debugging/defense-in-depth.md (3650b), systematic-debugging/root-cause-tracing.md (5327b), systematic-debugging/SKILL.md (8262b), test-driven-development/SKILL.md (8907b), test-driven-development/testing-anti-patterns.md (8251b), using-git-worktrees/SKILL.md (4785b), using-superpowers-open/SKILL.md (3054b), verification-before-completion/SKILL.md (3976b), writing-plans/SKILL.md (4795b), writing-skills/anthropic-best-practices.md (45820b), writing-skills/persuasion-principles.md (5919b), writing-skills/SKILL.md (9518b), _meta.json (139b)\n\nFile v1.0.0:brainstorming/SKILL.md\n\n---\nname: superpowers-open-brainstorming\ndescription: >\n  Use before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.\nmetadata:\n  openclaw:\n    emoji: \"💡\"\n---\n\n# Brainstorming Ideas Into Designs\n\nHelp turn ideas into fully formed designs and specs through natural collaborative dialogue.\n\nStart 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.\n\n<HARD-GATE>\nDo 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.\n</HARD-GATE>\n\n## Anti-Pattern: \"This Is Too Simple To Need A Design\"\n\nEvery 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.\n\n## Checklist\n\nYou MUST create a task for each of these items and complete them in order:\n\n1. **Explore project context** — check files, docs, recent commits\n2. **Ask clarifying questions** — one at a time, understand purpose/constraints/success criteria\n3. **Propose 2-3 approaches** — with trade-offs and your recommendation\n4. **Present design** — in sections scaled to their complexity, get user approval after each section\n5. **Write design doc** — save to `docs/specs/YYYY-MM-DD-<topic>-design.md` and commit\n6. **Spec self-review** — quick inline check for placeholders, contradictions, ambiguity, scope\n7. **User reviews written spec** — ask user to review the spec file before proceeding\n8. **Transition to implementation** — invoke superpowers-open:writing-plans to create implementation plan\n\n## The Process\n\n**Understanding the idea:**\n\n- Check out the current project state first (files, docs, recent commits)\n- 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.\n- 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.\n- Ask questions one at a time to refine the idea\n- Prefer multiple choice questions when possible, but open-ended is fine too\n- Only one question per message\n\n**Exploring approaches:**\n\n- Propose 2-3 different approaches with trade-offs\n- Present options conversationally with your recommendation and reasoning\n- Lead with your recommended option and explain why\n\n**Presenting the design:**\n\n- Once you believe you understand what you're building, present the design\n- Scale each section to its complexity\n- Ask after each section whether it looks right so far\n- Cover: architecture, components, data flow, error handling, testing\n\n**Design for isolation and clarity:**\n\n- Break the system into smaller units that each have one clear purpose, communicate through well-defined interfaces, and can be understood and tested independently\n- Can someone understand what a unit does without reading its internals? Can you change the internals without breaking consumers? If not, the boundaries need work.\n\n**Working in existing codebases:**\n\n- Explore the current structure before proposing changes. Follow existing patterns.\n- Where existing code has problems that affect the work, include targeted improvements as part of the design.\n- Don't propose unrelated refactoring. Stay focused on what serves the current goal.\n\n## After the Design\n\n**Documentation:**\n\n- Write the validated design (spec) to `docs/specs/YYYY-MM-DD-<topic>-design.md`\n- Commit the design document to git\n\n**Spec Self-Review:**\nAfter writing the spec document, look at it with fresh eyes:\n\n1. **Placeholder scan:** Any \"TBD\", \"TODO\", incomplete sections, or vague requirements? Fix them.\n2. **Internal consistency:** Do any sections contradict each other? Does the architecture match the feature descriptions?\n3. **Scope check:** Is this focused enough for a single implementation plan, or does it need decomposition?\n4. **Ambiguity check:** Could any requirement be interpreted two different ways? If so, pick one and make it explicit.\n\nFix any issues inline.\n\n**User Review Gate:**\nAfter the spec review loop passes, ask the user to review the written spec before proceeding:\n\n> \"Spec written and committed to `<path>`. Please review it and let me know if you want to make any changes before we start writing out the implementation plan.\"\n\nWait for the user's response. Only proceed once the user approves.\n\n**Implementation:**\n\n- Invoke superpowers-open:writing-plans to create a detailed implementation plan\n- The terminal state of brainstorming is writing-plans. Do NOT start coding directly.\n\n## Key Principles\n\n- **One question at a time** - Don't overwhelm with multiple questions\n- **Multiple choice preferred** - Easier to answer than open-ended when possible\n- **YAGNI ruthlessly** - Remove unnecessary features from all designs\n- **Explore alternatives** - Always propose 2-3 approaches before settling\n- **Incremental validation** - Present design, get approval before moving on\n- **Be flexible** - Go back and clarify when something doesn't make sense\n\nFile v1.0.0:executing-plans/SKILL.md\n\n---\nname: superpowers-open-executing-plans\ndescription: >\n  Use when you have a written implementation plan to execute. Loads the plan, reviews critically, executes all tasks inline, and reports when complete.\nmetadata:\n  openclaw:\n    emoji: \"⚡\"\n---\n\n# Executing Plans\n\n## Overview\n\nLoad plan, review critically, execute all tasks, report when complete.\n\n**Announce at start:** \"I'm using the executing-plans skill to implement this plan.\"\n\n**Note:** This is the only execution mode in SuperpowersOpen. There is no subagent-driven alternative. All tasks run inline in the current session.\n\n## The Process\n\n### Step 1: Load and Review Plan\n1. Read plan file\n2. Review critically - identify any questions or concerns about the plan\n3. If concerns: Raise them with your human partner before starting\n4. If no concerns: Create task list and proceed\n\n### Step 2: Execute Tasks\n\nFor each task:\n1. Mark as in_progress\n2. Follow each step exactly (plan has bite-sized steps)\n3. Run verifications as specified\n4. Mark as completed\n\n### Step 3: Complete Development\n\nAfter all tasks complete and verified:\n- Announce: \"I'm using the finishing-a-development-branch skill to complete this work.\"\n- **REQUIRED: Use superpowers-open:finishing-a-development-branch**\n- Follow that skill to verify tests, present options, execute choice\n\n## When to Stop and Ask for Help\n\n**STOP executing immediately when:**\n- Hit a blocker (missing dependency, test fails, instruction unclear)\n- Plan has critical gaps preventing starting\n- You don't understand an instruction\n- Verification fails repeatedly\n\n**Ask for clarification rather than guessing.**\n\n## When to Revisit Earlier Steps\n\n**Return to Review (Step 1) when:**\n- Partner updates the plan based on your feedback\n- Fundamental approach needs rethinking\n\n**Don't force through blockers** - stop and ask.\n\n## Remember\n- Review plan critically first\n- Follow plan steps exactly\n- Don't skip verifications\n- Reference skills when plan says to\n- Stop when blocked, don't guess\n- Never start implementation on main/master branch without explicit user consent\n\n## Integration\n\n**Required workflow skills:**\n- **superpowers-open:using-git-worktrees** — Set up isolated workspace before starting\n- **superpowers-open:writing-plans** — Creates the plan this skill executes\n- **superpowers-open:finishing-a-development-branch** — Complete development after all tasks\n\nFile v1.0.0:finishing-a-development-branch/SKILL.md\n\n---\nname: superpowers-open-finishing-a-development-branch\ndescription: >\n  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.\nmetadata:\n  openclaw:\n    emoji: \"🏁\"\n---\n\n# Finishing a Development Branch\n\n## Overview\n\nGuide completion of development work by presenting clear options and handling chosen workflow.\n\n**Core principle:** Verify tests → Present options → Execute choice → Clean up.\n\n**Announce at start:** \"I'm using the finishing-a-development-branch skill to complete this work.\"\n\n## The Process\n\n### Step 1: Verify Tests\n\n**Before presenting options, verify tests pass:**\n\n```bash\n# Run project's test suite\nnpm test / cargo test / pytest / go test ./...\n```\n\n**If tests fail:**\n```\nTests failing (<N> failures). Must fix before completing:\n\n[Show failures]\n\nCannot proceed with merge/PR until tests pass.\n```\n\nStop. Don't proceed to Step 2.\n\n**If tests pass:** Continue to Step 2.\n\n### Step 2: Determine Base Branch\n\n```bash\n# Try common base branches\ngit merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null\n```\n\nOr ask: \"This branch split from main - is that correct?\"\n\n### Step 3: Present Options\n\nPresent exactly these 4 options:\n\n```\nImplementation complete. What would you like to do?\n\n1. Merge back to <base-branch> locally\n2. Push and create a Pull Request\n3. Keep the branch as-is (I'll handle it later)\n4. Discard this work\n\nWhich option?\n```\n\n**Don't add explanation** - keep options concise.\n\n### Step 4: Execute Choice\n\n#### Option 1: Merge Locally\n\n```bash\n# Switch to base branch\ngit checkout <base-branch>\n\n# Pull latest\ngit pull\n\n# Merge feature branch\ngit merge <feature-branch>\n\n# Verify tests on merged result\n<test command>\n\n# If tests pass\ngit branch -d <feature-branch>\n```\n\n#### Option 2: Push and Create PR\n\n```bash\n# Push branch\ngit push -u origin <feature-branch>\n\n# Create PR\ngh pr create --title \"<title>\" --body \"$(cat <<'EOF'\n## Summary\n<2-3 bullets of what changed>\n\n## Test Plan\n- [ ] <verification steps>\nEOF\n)\"\n```\n\nIf `gh` CLI not available, instruct the user to create the PR manually via their Git platform.\n\n#### Option 3: Keep As-Is\n\nReport: \"Keeping branch <name>.\"\n\n**Don't delete anything.**\n\n#### Option 4: Discard\n\n**Confirm first:**\n```\nThis will permanently delete:\n- Branch <name>\n- All commits: <commit-list>\n\nType 'discard' to confirm.\n```\n\nWait for exact confirmation.\n\nIf confirmed:\n```bash\ngit checkout <base-branch>\ngit branch -D <feature-branch>\n```\n\n### Non-Git Projects\n\nIf the project is not a git repository, skip branch operations. Instead:\n- Confirm all changes are saved\n- Ask the user what to do next\n\n## Quick Reference\n\n| Option | Merge | Push | Cleanup Branch |\n|--------|-------|------|----------------|\n| 1. Merge locally | ✓ | - | ✓ |\n| 2. Create PR | - | ✓ | - |\n| 3. Keep as-is | - | - | - |\n| 4. Discard | - | - | ✓ (force) |\n\n## Red Flags\n\n**Never:**\n- Proceed with failing tests\n- Merge without verifying tests on result\n- Delete work without confirmation\n- Force-push without explicit request\n\n**Always:**\n- Verify tests before offering options\n- Present exactly 4 options\n- Get typed confirmation for Option 4\n\n## Integration\n\n**Called by:**\n- **superpowers-open:executing-plans** — After all tasks complete\n- **superpowers-open:writing-plans** — After plan execution complete\n\n**Pairs with:**\n- **superpowers-open:using-git-worktrees** — For worktree created by that skill\n\nFile v1.0.0:receiving-code-review/SKILL.md\n\n---\nname: superpowers-open-receiving-code-review\ndescription: >\n  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.\nmetadata:\n  openclaw:\n    emoji: \"👀\"\n---\n\n# Code Review Reception\n\n## Overview\n\nCode review requires technical evaluation, not emotional performance.\n\n**Core principle:** Verify before implementing. Ask before assuming. Technical correctness over social comfort.\n\n## The Response Pattern\n\n```\nWHEN receiving code review feedback:\n\n1. READ: Complete feedback without reacting\n2. UNDERSTAND: Restate requirement in own words (or ask)\n3. VERIFY: Check against codebase reality\n4. EVALUATE: Technically sound for THIS codebase?\n5. RESPOND: Technical acknowledgment or reasoned pushback\n6. IMPLEMENT: One item at a time, test each\n```\n\n## Forbidden Responses\n\n**NEVER:**\n- \"You're absolutely right!\" (performative agreement)\n- \"Great point!\" / \"Excellent feedback!\" (performative)\n- \"Let me implement that now\" (before verification)\n\n**INSTEAD:**\n- Restate the technical requirement\n- Ask clarifying questions\n- Push back with technical reasoning if wrong\n- Just start working (actions > words)\n\n## Handling Unclear Feedback\n\n```\nIF any item is unclear:\n  STOP - do not implement anything yet\n  ASK for clarification on unclear items\n\nWHY: Items may be related. Partial understanding = wrong implementation.\n```\n\n**Example:**\n```\nYour human partner: \"Fix 1-6\"\nYou understand 1,2,3,6. Unclear on 4,5.\n\n❌ WRONG: Implement 1,2,3,6 now, ask about 4,5 later\n✅ RIGHT: \"I understand items 1,2,3,6. Need clarification on 4 and 5 before proceeding.\"\n```\n\n## Source-Specific Handling\n\n### From your human partner\n- **Trusted** - implement after understanding\n- **Still ask** if scope unclear\n- **No performative agreement**\n- **Skip to action** or technical acknowledgment\n\n### From External Reviewers\n```\nBEFORE implementing:\n  1. Check: Technically correct for THIS codebase?\n  2. Check: Breaks existing functionality?\n  3. Check: Reason for current implementation?\n  4. Check: Works on all platforms/versions?\n  5. Check: Does reviewer understand full context?\n\nIF suggestion seems wrong:\n  Push back with technical reasoning\n\nIF can't easily verify:\n  Say so: \"I can't verify this without [X]. Should I [investigate/ask/proceed]?\"\n\nIF conflicts with your human partner's prior decisions:\n  Stop and discuss with your human partner first\n```\n\n## YAGNI Check for \"Professional\" Features\n\n```\nIF reviewer suggests \"implementing properly\":\n  grep codebase for actual usage\n\n  IF unused: \"This endpoint isn't called. Remove it (YAGNI)?\"\n  IF used: Then implement properly\n```\n\n## Implementation Order\n\n```\nFOR multi-item feedback:\n  1. Clarify anything unclear FIRST\n  2. Then implement in this order:\n     - Blocking issues (breaks, security)\n     - Simple fixes (typos, imports)\n     - Complex fixes (refactoring, logic)\n  3. Test each fix individually\n  4. Verify no regressions\n```\n\n## When To Push Back\n\nPush back when:\n- Suggestion breaks existing functionality\n- Reviewer lacks full context\n- Violates YAGNI (unused feature)\n- Technically incorrect for this stack\n- Legacy/compatibility reasons exist\n- Conflicts with your human partner's architectural decisions\n\n**How to push back:**\n- Use technical reasoning, not defensiveness\n- Ask specific questions\n- Reference working tests/code\n- Involve your human partner if architectural\n\n## Acknowledging Correct Feedback\n\nWhen feedback IS correct:\n```\n✅ \"Fixed. [Brief description of what changed]\"\n✅ \"Good catch - [specific issue]. Fixed in [location].\"\n✅ [Just fix it and show in the code]\n\n❌ \"You're absolutely right!\"\n❌ \"Great point!\"\n❌ \"Thanks for catching that!\"\n❌ ANY gratitude expression\n```\n\n**Why no thanks:** Actions speak. Just fix it. The code itself shows you heard the feedback.\n\n**If you catch yourself about to write \"Thanks\":** DELETE IT. State the fix instead.\n\n## Gracefully Correcting Your Pushback\n\nIf you pushed back and were wrong:\n```\n✅ \"You were right - I checked [X] and it does [Y]. Implementing now.\"\n✅ \"Verified this and you're correct. My initial understanding was wrong because [reason]. Fixing.\"\n\n❌ Long apology\n❌ Defending why you pushed back\n❌ Over-explaining\n```\n\nState the correction factually and move on.\n\n## Common Mistakes\n\n| Mistake | Fix |\n|---------|-----|\n| Performative agreement | State requirement or just act |\n| Blind implementation | Verify against codebase first |\n| Batch without testing | One at a time, test each |\n| Assuming reviewer is right | Check if breaks things |\n| Avoiding pushback | Technical correctness > comfort |\n| Partial implementation | Clarify all items first |\n| Can't verify, proceed anyway | State limitation, ask for direction |\n\n## The Bottom Line\n\n**External feedback = suggestions to evaluate, not orders to follow.**\n\nVerify. Question. Then implement.\n\nNo performative agreement. Technical rigor always.\n\nFile v1.0.0:requesting-code-review/SKILL.md\n\n---\nname: superpowers-open-requesting-code-review\ndescription: >\n  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.\nmetadata:\n  openclaw:\n    emoji: \"🔍\"\n---\n\n# Requesting Code Review\n\nSelf-review your work to catch issues before they reach a human reviewer.\n\n**Core principle:** Review early, review often. Since subagent-based review is not available on OpenClaw, use this structured self-review checklist.\n\n## When to Review\n\n**Mandatory:**\n- After each task in plan execution\n- After completing major feature\n- Before merge to main\n\n**Optional but valuable:**\n- When stuck (fresh perspective)\n- Before refactoring (baseline check)\n- After fixing complex bug\n\n## Self-Review Checklist\n\nRun this checklist against your changes. Be honest — you're looking for real issues, not validation.\n\n### 1. Spec Compliance\n\n```\n- [ ] Every requirement in the spec/plan has been implemented\n- [ ] Nothing extra was added beyond the spec (YAGNI)\n- [ ] All specified edge cases are handled\n- [ ] No spec requirements were skipped or deferred\n```\n\n### 2. Code Quality\n\n```\n- [ ] Code is minimal — no over-engineering or premature abstraction\n- [ ] Names are clear and describe what things do\n- [ ] No magic numbers — constants are named\n- [ ] No dead code or commented-out blocks\n- [ ] Error handling is present where needed (and absent where not)\n- [ ] No \"TODO\" or \"FIXME\" without a tracking issue\n```\n\n### 3. Testing\n\n```\n- [ ] Every new function/method has a test\n- [ ] Tests use real code (mocks only if unavoidable)\n- [ ] Edge cases are covered (empty input, null, boundary values)\n- [ ] Error paths are tested\n- [ ] All tests pass with clean output\n- [ ] **REQUIRED: superpowers-open:test-driven-development** was followed\n```\n\n### 4. Safety\n\n```\n- [ ] No credentials, tokens, or secrets in code\n- [ ] User input is validated at boundaries\n- [ ] No unsafe shell command construction\n- [ ] Dependencies are appropriate and necessary\n```\n\n### 5. Git Hygiene\n\n```\n- [ ] Changes are focused — one concern per commit\n- [ ] Commit messages describe WHY, not WHAT\n- [ ] No unrelated files accidentally included\n- [ ] Branch is up to date with base\n```\n\n## What To Do With Findings\n\n| Severity | Action |\n|----------|--------|\n| **Spec gap** (missing requirement) | Implement before proceeding |\n| **Bug** (incorrect behavior) | Fix with TDD cycle |\n| **Quality issue** (naming, magic number) | Fix now, one commit |\n| **Minor** (style nit) | Note, fix if touching file anyway |\n\n## If You Find Nothing\n\nIf the checklist is clean:\n- **REQUIRED: Use superpowers-open:verification-before-completion** — run actual verification commands\n- Only then proceed to **superpowers-open:finishing-a-development-branch** or the next task\n\n## Common Mistakes\n\n**Skipping review because \"it's simple\"**\n- Simple code has simple bugs. Review it.\n\n**Rubber-stamping your own work**\n- You'll naturally overlook your own mistakes. Be skeptical.\n\n**Fixing spec gaps silently**\n- If you find a gap, tell your human partner. Don't just fill it in.\n\n## Red Flags\n\n**Never:**\n- Skip review because \"it's simple\"\n- Proceed with known issues unfixed\n- Add \"quick improvements\" during review\n\n**Always:**\n- Complete the full checklist\n- Fix spec gaps before proceeding\n- Verify with real commands (not assumptions)\n\nFile v1.0.0:SKILL.md\n\n---\nname: superpowers-open\ndescription: >\n  Complete Superpowers methodology for OpenClaw. A 12-skill collection that enforces design-before-code, TDD, systematic debugging, verification, and structured code review. Use when you want rigorous AI-assisted development workflow.\nmetadata:\n  openclaw:\n    emoji: \"⚡\"\n    homepage: https://github.com/superpowers-open/superpowers-open\n---\n\n# SuperpowersOpen\n\nSuperpowers 方法论在 OpenClaw 平台上的完整技能集合。12 个技能协同工作，形成端到端的严格开发工作流。\n\n## How This Collection Works\n\nThis is a **skill collection**. The root SKILL.md acts as the manifest. Individual skills live in subdirectories and are auto-discovered by OpenClaw via their `description` fields.\n\n## Skills\n\n### Entry Point\n- **using-superpowers-open** — Tool mapping, trigger coordination, instruction priority (always active)\n\n### Workflow Chain\n- **brainstorming** — Design-first: no code before design approval\n- **writing-plans** — Decompose designs into bite-sized implementation tasks\n- **executing-plans** — Load plan, execute tasks inline, verify completion\n- **finishing-a-development-branch** — Structured merge/PR/keep/discard workflow\n\n### Practice Disciplines\n- **test-driven-development** — RED-GREEN-REFACTOR: test first, watch it fail, minimal code\n- **systematic-debugging** — 4-phase debugging: root cause → pattern → hypothesis → fix\n- **verification-before-completion** — Evidence before claims, always\n- **receiving-code-review** — Verify before implementing, no performative agreement\n- **requesting-code-review** — 5-dimension self-review checklist\n- **writing-skills** — TDD methodology applied to skill documentation\n- **using-git-worktrees** — Isolated git worktree workspaces\n\n## Installation\n\n```bash\ncp -r superpowers-open ~/.openclaw/skills/\n```\n\nRestart OpenClaw Gateway. All 12 skills are auto-discovered.\n\n## Requirements\n\n- OpenClaw (any version supporting SKILL.md format)\n- No additional dependencies\n\n## License\n\nMIT-0\n\n## Credits\n\nAdapted from [obra/superpowers](https://github.com/obra/superpowers) methodology.\n\nFile v1.0.0:systematic-debugging/SKILL.md\n\n---\nname: superpowers-open-systematic-debugging\ndescription: >\n  Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes. Requires finding root cause before attempting any fix. Symptom fixes are failure.\nmetadata:\n  openclaw:\n    emoji: \"🔍\"\n---\n\n# Systematic Debugging\n\n## Overview\n\nRandom fixes waste time and create new bugs. Quick patches mask underlying issues.\n\n**Core principle:** ALWAYS find root cause before attempting fixes. Symptom fixes are failure.\n\n**Violating the letter of this process is violating the spirit of debugging.**\n\n## The Iron Law\n\n```\nNO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST\n```\n\nIf you haven't completed Phase 1, you cannot propose fixes.\n\n## When to Use\n\nUse for ANY technical issue:\n- Test failures\n- Bugs in production\n- Unexpected behavior\n- Performance problems\n- Build failures\n- Integration issues\n\n**Use this ESPECIALLY when:**\n- Under time pressure (emergencies make guessing tempting)\n- \"Just one quick fix\" seems obvious\n- You've already tried multiple fixes\n- Previous fix didn't work\n- You don't fully understand the issue\n\n**Don't skip when:**\n- Issue seems simple (simple bugs have root causes too)\n- You're in a hurry (rushing guarantees rework)\n- Manager wants it fixed NOW (systematic is faster than thrashing)\n\n## The Four Phases\n\nYou MUST complete each phase before proceeding to the next.\n\n### Phase 1: Root Cause Investigation\n\n**BEFORE attempting ANY fix:**\n\n1. **Read Error Messages Carefully**\n   - Don't skip past errors or warnings\n   - They often contain the exact solution\n   - Read stack traces completely\n   - Note line numbers, file paths, error codes\n\n2. **Reproduce Consistently**\n   - Can you trigger it reliably?\n   - What are the exact steps?\n   - Does it happen every time?\n   - If not reproducible → gather more data, don't guess\n\n3. **Check Recent Changes**\n   - What changed that could cause this?\n   - Git diff, recent commits\n   - New dependencies, config changes\n   - Environmental differences\n\n4. **Gather Evidence in Multi-Component Systems**\n\n   **WHEN system has multiple components (CI → build → signing, API → service → database):**\n\n   **BEFORE proposing fixes, add diagnostic instrumentation:**\n   ```\n   For EACH component boundary:\n     - Log what data enters component\n     - Log what data exits component\n     - Verify environment/config propagation\n     - Check state at each layer\n\n   Run once to gather evidence showing WHERE it breaks\n   THEN analyze evidence to identify failing component\n   THEN investigate that specific component\n   ```\n\n5. **Trace Data Flow**\n\n   **WHEN error is deep in call stack:**\n\n   See `root-cause-tracing.md` in this directory for the complete backward tracing technique.\n\n   **Quick version:**\n   - Where does bad value originate?\n   - What called this with bad value?\n   - Keep tracing up until you find the source\n   - Fix at source, not at symptom\n\n### Phase 2: Pattern Analysis\n\n**Find the pattern before fixing:**\n\n1. **Find Working Examples**\n   - Locate similar working code in same codebase\n   - What works that's similar to what's broken?\n\n2. **Compare Against References**\n   - If implementing pattern, read reference implementation COMPLETELY\n   - Don't skim - read every line\n   - Understand the pattern fully before applying\n\n3. **Identify Differences**\n   - What's different between working and broken?\n   - List every difference, however small\n   - Don't assume \"that can't matter\"\n\n4. **Understand Dependencies**\n   - What other components does this need?\n   - What settings, config, environment?\n   - What assumptions does it make?\n\n### Phase 3: Hypothesis and Testing\n\n**Scientific method:**\n\n1. **Form Single Hypothesis**\n   - State clearly: \"I think X is the root cause because Y\"\n   - Write it down\n   - Be specific, not vague\n\n2. **Test Minimally**\n   - Make the SMALLEST possible change to test hypothesis\n   - One variable at a time\n   - Don't fix multiple things at once\n\n3. **Verify Before Continuing**\n   - Did it work? Yes → Phase 4\n   - Didn't work? Form NEW hypothesis\n   - DON'T add more fixes on top\n\n4. **When You Don't Know**\n   - Say \"I don't understand X\"\n   - Don't pretend to know\n   - Ask for help\n   - Research more\n\n### Phase 4: Implementation\n\n**Fix the root cause, not the symptom:**\n\n1. **Create Failing Test Case**\n   - Simplest possible reproduction\n   - Automated test if possible\n   - One-off test script if no framework\n   - MUST have before fixing\n   - Use **superpowers-open:test-driven-development** for writing proper failing tests\n\n2. **Implement Single Fix**\n   - Address the root cause identified\n   - ONE change at a time\n   - No \"while I'm here\" improvements\n   - No bundled refactoring\n\n3. **Verify Fix**\n   - Test passes now?\n   - No other tests broken?\n   - Issue actually resolved?\n\n4. **If Fix Doesn't Work**\n   - STOP\n   - Count: How many fixes have you tried?\n   - If < 3: Return to Phase 1, re-analyze with new information\n   - **If ≥ 3: STOP and question the architecture (step 5 below)**\n   - DON'T attempt Fix #4 without architectural discussion\n\n5. **If 3+ Fixes Failed: Question Architecture**\n\n   **Pattern indicating architectural problem:**\n   - Each fix reveals new shared state/coupling/problem in different place\n   - Fixes require \"massive refactoring\" to implement\n   - Each fix creates new symptoms elsewhere\n\n   **STOP and question fundamentals:**\n   - Is this pattern fundamentally sound?\n   - Are we \"sticking with it through sheer inertia\"?\n   - Should we refactor architecture vs. continue fixing symptoms?\n\n   **Discuss with your human partner before attempting more fixes**\n\n## Red Flags - STOP and Follow Process\n\nIf you catch yourself thinking:\n- \"Quick fix for now, investigate later\"\n- \"Just try changing X and see if it works\"\n- \"Add multiple changes, run tests\"\n- \"Skip the test, I'll manually verify\"\n- \"It's probably X, let me fix that\"\n- \"I don't fully understand but this might work\"\n- \"Pattern says X but I'll adapt it differently\"\n- \"Here are the main problems: [lists fixes without investigation]\"\n- Proposing solutions before tracing data flow\n- **\"One more fix attempt\" (when already tried 2+)**\n- **Each fix reveals new problem in different place**\n\n**ALL of these mean: STOP. Return to Phase 1.**\n\n**If 3+ fixes failed:** Question the architecture (see Phase 4.5)\n\n## Common Rationalizations\n\n| Excuse | Reality |\n|--------|---------|\n| \"Issue is simple, don't need process\" | Simple issues have root causes too. Process is fast for simple bugs. |\n| \"Emergency, no time for process\" | Systematic debugging is FASTER than guess-and-check thrashing. |\n| \"Just try this first, then investigate\" | First fix sets the pattern. Do it right from the start. |\n| \"I'll write test after confirming fix works\" | Untested fixes don't stick. Test first proves it. |\n| \"Multiple fixes at once saves time\" | Can't isolate what worked. Causes new bugs. |\n| \"Reference too long, I'll adapt the pattern\" | Partial understanding guarantees bugs. Read it completely. |\n| \"I see the problem, let me fix it\" | Seeing symptoms ≠ understanding root cause. |\n| \"One more fix attempt\" (after 2+ failures) | 3+ failures = architectural problem. |\n\n## Quick Reference\n\n| Phase | Key Activities | Success Criteria |\n|-------|---------------|------------------|\n| **1. Root Cause** | Read errors, reproduce, check changes, gather evidence | Understand WHAT and WHY |\n| **2. Pattern** | Find working examples, compare | Identify differences |\n| **3. Hypothesis** | Form theory, test minimally | Confirmed or new hypothesis |\n| **4. Implementation** | Create test, fix, verify | Bug resolved, tests pass |\n\n## Supporting Techniques\n\nThese techniques are part of systematic debugging and available in this directory:\n\n- **`root-cause-tracing.md`** - Trace bugs backward through call stack to find original trigger\n- **`defense-in-depth.md`** - Add validation at multiple layers after finding root cause\n- **`condition-based-waiting.md`** - Replace arbitrary timeouts with condition polling\n\n**Related skills:**\n- **superpowers-open:test-driven-development** - For creating failing test case (Phase 4, Step 1)\n- **superpowers-open:verification-before-completion** - Verify fix worked before claiming success\n\nFile v1.0.0:test-driven-development/SKILL.md\n\n---\nname: superpowers-open-test-driven-development\ndescription: >\n  Use when implementing any feature or bugfix, before writing implementation code. Enforces test-first discipline: write the test, watch it fail, write minimal code to pass.\nmetadata:\n  openclaw:\n    emoji: \"🧪\"\n---\n\n# Test-Driven Development (TDD)\n\n## Overview\n\nWrite the test first. Watch it fail. Write minimal code to pass.\n\n**Core principle:** If you didn't watch the test fail, you don't know if it tests the right thing.\n\n**Violating the letter of the rules is violating the spirit of the rules.**\n\n## When to Use\n\n**Always:**\n- New features\n- Bug fixes\n- Refactoring\n- Behavior changes\n\n**Exceptions (ask your human partner):**\n- Throwaway prototypes\n- Generated code\n- Configuration files\n\nThinking \"skip TDD just this once\"? Stop. That's rationalization.\n\n## The Iron Law\n\n```\nNO PRODUCTION CODE WITHOUT A FAILING TEST FIRST\n```\n\nWrite code before the test? Delete it. Start over.\n\n**No exceptions:**\n- Don't keep it as \"reference\"\n- Don't \"adapt\" it while writing tests\n- Don't look at it\n- Delete means delete\n\nImplement fresh from tests. Period.\n\n## Red-Green-Refactor\n\n### RED - Write Failing Test\n\nWrite one minimal test showing what should happen.\n\n```typescript\n// GOOD example:\ntest('retries failed operations 3 times', async () => {\n  let attempts = 0;\n  const operation = () => {\n    attempts++;\n    if (attempts < 3) throw new Error('fail');\n    return 'success';\n  };\n\n  const result = await retryOperation(operation);\n\n  expect(result).toBe('success');\n  expect(attempts).toBe(3);\n});\n// Clear name, tests real behavior, one thing\n\n// BAD example:\ntest('retry works', async () => {\n  const mock = jest.fn()\n    .mockRejectedValueOnce(new Error())\n    .mockRejectedValueOnce(new Error())\n    .mockResolvedValueOnce('success');\n  await retryOperation(mock);\n  expect(mock).toHaveBeenCalledTimes(3);\n});\n// Vague name, tests mock not code\n```\n\n**Requirements:**\n- One behavior\n- Clear name\n- Real code (no mocks unless unavoidable)\n\n### Verify RED - Watch It Fail\n\n**MANDATORY. Never skip.**\n\n```bash\nnpm test path/to/test.test.ts\n```\n\nConfirm:\n- Test fails (not errors)\n- Failure message is expected\n- Fails because feature missing (not typos)\n\n**Test passes?** You're testing existing behavior. Fix test.\n\n**Test errors?** Fix error, re-run until it fails correctly.\n\n### GREEN - Minimal Code\n\nWrite simplest code to pass the test.\n\n```typescript\n// GOOD - just enough to pass:\nasync function retryOperation<T>(fn: () => Promise<T>): Promise<T> {\n  for (let i = 0; i < 3; i++) {\n    try {\n      return await fn();\n    } catch (e) {\n      if (i === 2) throw e;\n    }\n  }\n  throw new Error('unreachable');\n}\n\n// BAD - over-engineered:\nasync function retryOperation<T>(\n  fn: () => Promise<T>,\n  options?: {\n    maxRetries?: number;\n    backoff?: 'linear' | 'exponential';\n    onRetry?: (attempt: number) => void;\n  }\n): Promise<T> {\n  // YAGNI\n}\n```\n\nDon't add features, refactor other code, or \"improve\" beyond the test.\n\n### Verify GREEN - Watch It Pass\n\n**MANDATORY.**\n\n```bash\nnpm test path/to/test.test.ts\n```\n\nConfirm:\n- Test passes\n- Other tests still pass\n- Output pristine (no errors, warnings)\n\n**Test fails?** Fix code, not test.\n\n**Other tests fail?** Fix now.\n\n### REFACTOR - Clean Up\n\nAfter green only:\n- Remove duplication\n- Improve names\n- Extract helpers\n\nKeep tests green. Don't add behavior.\n\n### Repeat\n\nNext failing test for next feature.\n\n## Good Tests\n\n| Quality | Good | Bad |\n|---------|------|-----|\n| **Minimal** | One thing. \"and\" in name? Split it. | `test('validates email and domain and whitespace')` |\n| **Clear** | Name describes behavior | `test('test1')` |\n| **Shows intent** | Demonstrates desired API | Obscures what code should do |\n\n## Why Order Matters\n\n**\"I'll write tests after to verify it works\"**\n\nTests written after code pass immediately. Passing immediately proves nothing:\n- Might test wrong thing\n- Might test implementation, not behavior\n- Might miss edge cases you forgot\n- You never saw it catch the bug\n\nTest-first forces you to see the test fail, proving it actually tests something.\n\n**\"I already manually tested all the edge cases\"**\n\nManual testing is ad-hoc. You think you tested everything but:\n- No record of what you tested\n- Can't re-run when code changes\n- Easy to forget cases under pressure\n\nAutomated tests are systematic. They run the same way every time.\n\n**\"Deleting X hours of work is wasteful\"**\n\nSunk cost fallacy. The time is already gone. Your choice now:\n- Delete and rewrite with TDD (X more hours, high confidence)\n- Keep it and add tests after (30 min, low confidence, likely bugs)\n\nThe \"waste\" is keeping code you can't trust.\n\n**\"TDD is dogmatic, being pragmatic means adapting\"**\n\nTDD IS pragmatic:\n- Finds bugs before commit (faster than debugging after)\n- Prevents regressions (tests catch breaks immediately)\n- Documents behavior (tests show how to use code)\n- Enables refactoring (change freely, tests catch breaks)\n\n**\"Tests after achieve the same goals - it's spirit not ritual\"**\n\nNo. Tests-after answer \"What does this do?\" Tests-first answer \"What should this do?\"\n\nTests-after are biased by your implementation. You test what you built, not what's required. You verify remembered edge cases, not discovered ones.\n\nTests-first force edge case discovery before implementing.\n\n## Common Rationalizations\n\n| Excuse | Reality |\n|--------|---------|\n| \"Too simple to test\" | Simple code breaks. Test takes 30 seconds. |\n| \"I'll test after\" | Tests passing immediately prove nothing. |\n| \"Tests after achieve same goals\" | Tests-after = \"what does this do?\" Tests-first = \"what should this do?\" |\n| \"Already manually tested\" | Ad-hoc ≠ systematic. No record, can't re-run. |\n| \"Deleting X hours is wasteful\" | Sunk cost fallacy. Keeping unverified code is technical debt. |\n| \"Keep as reference, write tests first\" | You'll adapt it. That's testing after. Delete means delete. |\n| \"Need to explore first\" | Fine. Throw away exploration, start with TDD. |\n| \"Test hard = design unclear\" | Listen to test. Hard to test = hard to use. |\n| \"TDD will slow me down\" | TDD faster than debugging. Pragmatic = test-first. |\n| \"Manual test faster\" | Manual doesn't prove edge cases. You'll re-test every change. |\n| \"Existing code has no tests\" | You're improving it. Add tests for existing code. |\n\n## Red Flags - STOP and Start Over\n\n- Code before test\n- Test after implementation\n- Test passes immediately\n- Can't explain why test failed\n- Tests added \"later\"\n- Rationalizing \"just this once\"\n- \"I already manually tested it\"\n- \"Tests after achieve the same purpose\"\n- \"It's about spirit not ritual\"\n- \"Keep as reference\" or \"adapt existing code\"\n- \"Already spent X hours, deleting is wasteful\"\n- \"TDD is dogmatic, I'm being pragmatic\"\n- \"This is different because...\"\n\n**All of these mean: Delete code. Start over with TDD.**\n\n## Example: Bug Fix\n\n**Bug:** Empty email accepted\n\n**RED**\n```typescript\ntest('rejects empty email', async () => {\n  const result = await submitForm({ email: '' });\n  expect(result.error).toBe('Email required');\n});\n```\n\n**Verify RED**\n```bash\n$ npm test\nFAIL: expected 'Email required', got undefined\n```\n\n**GREEN**\n```typescript\nfunction submitForm(data: FormData) {\n  if (!data.email?.trim()) {\n    return { error: 'Email required' };\n  }\n  // ...\n}\n```\n\n**Verify GREEN**\n```bash\n$ npm test\nPASS\n```\n\n**REFACTOR**\nExtract validation for multiple fields if needed.\n\n## Verification Checklist\n\nBefore marking work complete:\n\n- [ ] Every new function/method has a test\n- [ ] Watched each test fail before implementing\n- [ ] Each test failed for expected reason (feature missing, not typo)\n- [ ] Wrote minimal code to pass each test\n- [ ] All tests pass\n- [ ] Output pristine (no errors, warnings)\n- [ ] Tests use real code (mocks only if unavoidable)\n- [ ] Edge cases and errors covered\n\nCan't check all boxes? You skipped TDD. Start over.\n\n## When Stuck\n\n| Problem | Solution |\n|---------|----------|\n| Don't know how to test | Write wished-for API. Write assertion first. Ask your human partner. |\n| Test too complicated | Design too complicated. Simplify interface. |\n| Must mock everything | Code too coupled. Use dependency injection. |\n| Test setup huge | Extract helpers. Still complex? Simplify design. |\n\n## Debugging Integration\n\nBug found? Write failing test reproducing it. Follow TDD cycle. Test proves fix and prevents regression.\n\nNever fix bugs without a test.\n\n## Testing Anti-Patterns\n\nWhen adding mocks or test utilities, read `testing-anti-patterns.md` (same directory) to avoid common pitfalls:\n- Testing mock behavior instead of real behavior\n- Adding test-only methods to production classes\n- Mocking without understanding dependencies\n\n## Final Rule\n\n```\nProduction code → test exists and failed first\nOtherwise → not TDD\n```\n\nNo exceptions without your human partner's permission.\n\nFile v1.0.0:using-git-worktrees/SKILL.md\n\n---\nname: superpowers-open-using-git-worktrees\ndescription: >\n  Use when starting feature work that needs isolation from current workspace or before executing implementation plans. Creates isolated git worktrees with smart directory selection and safety verification.\nmetadata:\n  openclaw:\n    emoji: \"🌲\"\n---\n\n# Using Git Worktrees\n\n## Overview\n\nGit worktrees create isolated workspaces sharing the same repository, allowing work on multiple branches simultaneously without switching.\n\n**Core principle:** Systematic directory selection + safety verification = reliable isolation.\n\n**Announce at start:** \"I'm using the using-git-worktrees skill to set up an isolated workspace.\"\n\n## Directory Selection Process\n\nFollow this priority order:\n\n### 1. Check Existing Directories\n\n```bash\n# Check in priority order\nls -d .worktrees 2>/dev/null     # Preferred (hidden)\nls -d worktrees 2>/dev/null      # Alternative\n```\n\n**If found:** Use that directory. If both exist, `.worktrees` wins.\n\n### 2. Check CLAUDE.md\n\n```bash\ngrep -i \"worktree.*director\" CLAUDE.md 2>/dev/null\n```\n\n**If preference specified:** Use it without asking.\n\n### 3. Ask User\n\nIf no directory exists and no CLAUDE.md preference:\n\n```\nNo worktree directory found. Where should I create worktrees?\n\n1. .worktrees/ (project-local, hidden)\n2. ~/.openclaw/worktrees/<project-name>/ (global location)\n\nWhich would you prefer?\n```\n\n## Safety Verification\n\n### For Project-Local Directories (.worktrees or worktrees)\n\n**MUST verify directory is ignored before creating worktree:**\n\n```bash\n# Check if directory is ignored\ngit check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null\n```\n\n**If NOT ignored:**\n1. Add appropriate line to .gitignore\n2. Commit the change\n3. Proceed with worktree creation\n\n### For Global Directory (~/.openclaw/worktrees)\n\nNo .gitignore verification needed - outside project entirely.\n\n## Creation Steps\n\n### 1. Detect Project Name\n\n```bash\nproject=$(basename \"$(git rev-parse --show-toplevel)\")\n```\n\n### 2. Create Worktree\n\n```bash\n# Determine full path\ncase $LOCATION in\n  .worktrees|worktrees)\n    path=\"$LOCATION/$BRANCH_NAME\"\n    ;;\n  ~/.openclaw/worktrees/*)\n    path=\"$HOME/.openclaw/worktrees/$project/$BRANCH_NAME\"\n    ;;\nesac\n\n# Create worktree with new branch\ngit worktree add \"$path\" -b \"$BRANCH_NAME\"\ncd \"$path\"\n```\n\n### 3. Run Project Setup\n\nAuto-detect and run appropriate setup:\n\n```bash\n# Node.js\nif [ -f package.json ]; then npm install; fi\n\n# Rust\nif [ -f Cargo.toml ]; then cargo build; fi\n\n# Python\nif [ -f requirements.txt ]; then pip install -r requirements.txt; fi\nif [ -f pyproject.toml ]; then poetry install; fi\n\n# Go\nif [ -f go.mod ]; then go mod download; fi\n```\n\n### 4. Verify Clean Baseline\n\nRun tests to ensure worktree starts clean:\n\n```bash\nnpm test / cargo test / pytest / go test ./...\n```\n\n**If tests fail:** Report failures, ask whether to proceed or investigate.\n\n**If tests pass:** Report ready.\n\n### 5. Report Location\n\n```\nWorktree ready at <full-path>\nTests passing (<N> tests, 0 failures)\nReady to implement <feature-name>\n```\n\n## Quick Reference\n\n| Situation | Action |\n|-----------|--------|\n| `.worktrees/` exists | Use it (verify ignored) |\n| `worktrees/` exists | Use it (verify ignored) |\n| Both exist | Use `.worktrees/` |\n| Neither exists | Check CLAUDE.md → Ask user |\n| Directory not ignored | Add to .gitignore + commit |\n| Tests fail during baseline | Report failures + ask |\n| No package.json/Cargo.toml | Skip dependency install |\n\n## Common Mistakes\n\n### Skipping ignore verification\n- **Problem:** Worktree contents get tracked, pollute git status\n- **Fix:** Always use `git check-ignore` before creating project-local worktree\n\n### Assuming directory location\n- **Problem:** Creates inconsistency, violates project conventions\n- **Fix:** Follow priority: existing > CLAUDE.md > ask\n\n### Proceeding with failing tests\n- **Problem:** Can't distinguish new bugs from pre-existing issues\n- **Fix:** Report failures, get explicit permission to proceed\n\n## Red Flags\n\n**Never:**\n- Create worktree without verifying it's ignored (project-local)\n- Skip baseline test verification\n- Proceed with failing tests without asking\n- Assume directory location when ambiguous\n- Skip CLAUDE.md check\n\n**Always:**\n- Follow directory priority: existing > CLAUDE.md > ask\n- Verify directory is ignored for project-local\n- Auto-detect and run project setup\n- Verify clean test baseline\n\n## Integration\n\n**Called by:**\n- **superpowers-open:brainstorming** — When design is approved and implementation follows\n- **superpowers-open:executing-plans** — Before executing any tasks\n- Any skill needing isolated workspace\n\n**Pairs with:**\n- **superpowers-open:finishing-a-development-branch** — For cleanup after work complete\n\nFile v1.0.0:using-superpowers-open/SKILL.md\n\n---\nname: superpowers-open-using-superpowers-open\ndescription: >\n  Use when starting any conversation with OpenClaw. Establishes how to find and use SuperpowersOpen skills. Requires checking for applicable skills before any response, including clarifying questions.\nmetadata:\n  openclaw:\n    always: true\n    emoji: \"⚡\"\n    homepage: https://github.com/superpowers-open/superpowers-open\n---\n\n# Using SuperpowersOpen\n\n## Instruction Priority\n\nSuperpowersOpen skills override default system prompt behavior, but **user instructions always take precedence**:\n\n1. **User's explicit instructions** (CLAUDE.md, GEMINI.md, AGENTS.md, direct requests) — highest priority\n2. **SuperpowersOpen skills** — override default system behavior where they conflict\n3. **Default system prompt** — lowest priority\n\nIf CLAUDE.md says \"don't use TDD\" and a skill says \"always use TDD,\" follow the user's instructions. The user is in control.\n\n## How SuperpowersOpen Skills Work\n\nSuperpowersOpen skills are installed under `~/.openclaw/skills/superpowers-open/`. OpenClaw discovers them automatically via their `description` frontmatter field. Each skill's description specifies triggering conditions — when OpenClaw encounters a matching situation, the skill loads and guides behavior.\n\nYou do NOT need to manually invoke skills. Check each skill's description to determine if it applies to the current task.\n\n## Tool Mapping\n\nSuperpowersOpen skills are adapted from the Claude Code superpowers ecosystem. This table maps original tool references to OpenClaw equivalents:\n\n| Superpowers (Claude Code) | OpenClaw equivalent |\n|---|---|\n| `Skill` tool | Skills auto-load via description matching |\n| `Task` tool (dispatch subagent) | **Not available.** Guide the user to open a new session and manually perform the task. |\n| `TodoWrite` / task tracking | Native task/list tools or checkbox (`- [ ]`) syntax |\n| `Read`, `Write`, `Edit` | OpenClaw native file tools |\n| `Bash` | OpenClaw native shell tools |\n| `EnterPlanMode` / `ExitPlanMode` | **Not available.** Skills that reference these have been adapted to remove them. |\n\n## Unavailable Skills\n\nTwo superpowers skills require subagent support and are NOT included in SuperpowersOpen:\n- `subagent-driven-development` — requires dispatching subagents per task\n- `dispatching-parallel-agents` — requires parallel subagent dispatch\n\nWhen a workflow would normally use these, use `superpowers-open:executing-plans` (inline execution) instead.\n\n## Cross-Skill References\n\nWhen one SuperpowersOpen skill references another, it uses the format:\n\n```\n**REQUIRED:** Use superpowers-open:brainstorming\n```\n\nWhen you see this, look for the matching skill in `~/.openclaw/skills/superpowers-open/` and follow its guidance.\n\n## Skill Types\n\n**Rigid** (TDD, debugging, verification): Follow exactly. Don't adapt away discipline.\n\n**Flexible** (patterns): Adapt principles to context.\n\nThe skill itself tells you which.\n\n## User Instructions\n\nInstructions say WHAT, not HOW. \"Add X\" or \"Fix Y\" doesn't mean skip workflows.\n\nFile v1.0.0:verification-before-completion/SKILL.md\n\n---\nname: superpowers-open-verification-before-completion\ndescription: >\n  Use when about to claim work is complete, fixed, or passing, before committing or creating PRs. Requires running verification commands and confirming output before making any success claims. Evidence before assertions always.\nmetadata:\n  openclaw:\n    emoji: \"✅\"\n---\n\n# Verification Before Completion\n\n## Overview\n\nClaiming work is complete without verification is dishonesty, not efficiency.\n\n**Core principle:** Evidence before claims, always.\n\n**Violating the letter of this rule is violating the spirit of this rule.**\n\n## The Iron Law\n\n```\nNO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE\n```\n\nIf you haven't run the verification command in this message, you cannot claim it passes.\n\n## The Gate Function\n\n```\nBEFORE claiming any status or expressing satisfaction:\n\n1. IDENTIFY: What command proves this claim?\n2. RUN: Execute the FULL command (fresh, complete)\n3. READ: Full output, check exit code, count failures\n4. VERIFY: Does output confirm the claim?\n   - If NO: State actual status with evidence\n   - If YES: State claim WITH evidence\n5. ONLY THEN: Make the claim\n\nSkip any step = lying, not verifying\n```\n\n## Common Failures\n\n| Claim | Requires | Not Sufficient |\n|-------|----------|----------------|\n| Tests pass | Test command output: 0 failures | Previous run, \"should pass\" |\n| Linter clean | Linter output: 0 errors | Partial check, extrapolation |\n| Build succeeds | Build command: exit 0 | Linter passing, logs look good |\n| Bug fixed | Test original symptom: passes | Code changed, assumed fixed |\n| Regression test works | Red-green cycle verified | Test passes once |\n| Agent completed | VCS diff shows changes | Agent reports \"success\" |\n| Requirements met | Line-by-line checklist | Tests passing |\n\n## Red Flags - STOP\n\n- Using \"should\", \"probably\", \"seems to\"\n- Expressing satisfaction before verification (\"Great!\", \"Perfect!\", \"Done!\", etc.)\n- About to commit/push/PR without verification\n- Trusting agent success reports\n- Relying on partial verification\n- Thinking \"just this once\"\n- Tired and wanting work over\n- **ANY wording implying success without having run verification**\n\n## Rationalization Prevention\n\n| Excuse | Reality |\n|--------|---------|\n| \"Should work now\" | RUN the verification |\n| \"I'm confident\" | Confidence ≠ evidence |\n| \"Just this once\" | No exceptions |\n| \"Linter passed\" | Linter ≠ compiler |\n| \"Agent said success\" | Verify independently |\n| \"I'm tired\" | Exhaustion ≠ excuse |\n| \"Partial check is enough\" | Partial proves nothing |\n| \"Different words so rule doesn't apply\" | Spirit over letter |\n\n## Key Patterns\n\n**Tests:**\n```\n✅ [Run test command] [See: 34/34 pass] \"All tests pass\"\n❌ \"Should pass now\" / \"Looks correct\"\n```\n\n**Regression tests (TDD Red-Green):**\n```\n✅ Write → Run (pass) → Revert fix → Run (MUST FAIL) → Restore → Run (pass)\n❌ \"I've written a regression test\" (without red-green verification)\n```\n\n**Build:**\n```\n✅ [Run build] [See: exit 0] \"Build passes\"\n❌ \"Linter passed\" (linter doesn't check compilation)\n```\n\n**Requirements:**\n```\n✅ Re-read plan → Create checklist → Verify each → Report gaps or completion\n❌ \"Tests pass, phase complete\"\n```\n\n## Why This Matters\n\n- Claiming \"done\" without evidence breaks trust\n- Undefined functions shipped crash\n- Missing requirements shipped = incomplete features\n- Time wasted on false completion → redirect → rework\n\n## When To Apply\n\n**ALWAYS before:**\n- ANY variation of success/completion claims\n- ANY expression of satisfaction\n- ANY positive statement about work state\n- Committing, PR creation, task completion\n- Moving to next task\n\n**Rule applies to:**\n- Exact phrases\n- Paraphrases and synonyms\n- Implications of success\n- ANY communication suggesting completion/correctness\n\n## The Bottom Line\n\n**No shortcuts for verification.**\n\nRun the command. Read the output. THEN claim the result.\n\nThis is non-negotiable.\n\nFile v1.0.0:writing-plans/SKILL.md\n\n---\nname: superpowers-open-writing-plans\ndescription: >\n  Use when you have a spec or requirements for a multi-step task, before touching code. Creates detailed implementation plans with exact file paths, complete code, and TDD steps.\nmetadata:\n  openclaw:\n    emoji: \"📋\"\n---\n\n# Writing Plans\n\n## Overview\n\nWrite comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.\n\nAssume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.\n\n**Announce at start:** \"I'm using the writing-plans skill to create the implementation plan.\"\n\n**Save plans to:** `docs/plans/YYYY-MM-DD-<feature-name>.md`\n\n## Scope Check\n\nIf the spec covers multiple independent subsystems, it should have been broken into sub-project specs during brainstorming. If it wasn't, suggest breaking this into separate plans — one per subsystem. Each plan should produce working, testable software on its own.\n\n## File Structure\n\nBefore defining tasks, map out which files will be created or modified and what each one is responsible for.\n\n- Design units with clear boundaries and well-defined interfaces. Each file should have one clear responsibility.\n- Prefer smaller, focused files over large ones that do too much.\n- Files that change together should live together. Split by responsibility, not by technical layer.\n- In existing codebases, follow established patterns.\n\n## Bite-Sized Task Granularity\n\n**Each step is one action (2-5 minutes):**\n- \"Write the failing test\" - step\n- \"Run it to make sure it fails\" - step\n- \"Implement the minimal code to make the test pass\" - step\n- \"Run the tests and make sure they pass\" - step\n- \"Commit\" - step\n\n## Plan Document Header\n\n**Every plan MUST start with this header:**\n\n```markdown\n# [Feature Name] Implementation Plan\n\n> **For agentic workers:** Use superpowers-open:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.\n\n**Goal:** [One sentence describing what this builds]\n\n**Architecture:** [2-3 sentences about approach]\n\n**Tech Stack:** [Key technologies/libraries]\n\n---\n```\n\n## Task Structure\n\n````markdown\n### Task N: [Component Name]\n\n**Files:**\n- Create: `exact/path/to/file.py`\n- Modify: `exact/path/to/existing.py:123-145`\n- Test: `tests/exact/path/to/test.py`\n\n- [ ] **Step 1: Write the failing test**\n\n```python\ndef test_specific_behavior():\n    result = function(input)\n    assert result == expected\n```\n\n- [ ] **Step 2: Run test to verify it fails**\n\nRun: `pytest tests/path/test.py::test_name -v`\nExpected: FAIL with \"function not defined\"\n\n- [ ] **Step 3: Write minimal implementation**\n\n```python\ndef function(input):\n    return expected\n```\n\n- [ ] **Step 4: Run test to verify it passes**\n\nRun: `pytest tests/path/test.py::test_name -v`\nExpected: PASS\n\n- [ ] **Step 5: Commit**\n\n```bash\ngit add tests/path/test.py src/path/file.py\ngit commit -m \"feat: add specific feature\"\n```\n````\n\n## No Placeholders\n\nEvery step must contain the actual content an engineer needs. These are **plan failures** — never write them:\n- \"TBD\", \"TODO\", \"implement later\", \"fill in details\"\n- \"Add appropriate error handling\" / \"add validation\" / \"handle edge cases\"\n- \"Write tests for the above\" (without actual test code)\n- \"Similar to Task N\" (repeat the code — the engineer may be reading tasks out of order)\n- Steps that describe what to do without showing how (code blocks required for code steps)\n\n## Self-Review\n\nAfter writing the complete plan, check the plan against the spec:\n\n**1. Spec coverage:** Skim each section/requirement in the spec. Can you point to a task that implements it? List any gaps.\n\n**2. Placeholder scan:** Search your plan for red flags — any of the patterns from the \"No Placeholders\" section above. Fix them.\n\n**3. Type consistency:** Do the types, method signatures, and property names you used in later tasks match what you defined in earlier tasks?\n\nIf you find issues, fix them inline. If you find a spec requirement with no task, add the task.\n\n## Execution Handoff\n\nAfter saving the plan:\n\n> \"Plan complete and saved to `docs/plans/<filename>.md`. Shall I execute it using superpowers-open:executing-plans?\"\n\n**REQUIRED: Use superpowers-open:executing-plans** to execute the plan. There is no subagent-driven option in SuperpowersOpen.\n\n## Remember\n- Exact file paths always\n- Complete code in every step — if a step changes code, show the code\n- Exact commands with expected output\n- DRY, YAGNI, TDD, frequent commits","readmeExcerpt":"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","codeSnippets":[],"executableExamples":[{"language":"bash","snippet":"# Run project's test suite\nnpm test / cargo test / pytest / go test ./..."},{"language":"text","snippet":"Tests failing (<N> failures). Must fix before completing:\n\n[Show failures]\n\nCannot proceed with merge/PR until tests pass."},{"language":"bash","snippet":"# Try common base branches\ngit merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null"},{"language":"text","snippet":"Implementation complete. What would you like to do?\n\n1. Merge back to <base-branch> locally\n2. Push and create a Pull Request\n3. Keep the branch as-is (I'll handle it later)\n4. Discard this work\n\nWhich option?"},{"language":"bash","snippet":"# Switch to base branch\ngit checkout <base-branch>\n\n# Pull latest\ngit pull\n\n# Merge feature branch\ngit merge <feature-branch>\n\n# Verify tests on merged result\n<test command>\n\n# If tests pass\ngit branch -d <feature-branch>"},{"language":"bash","snippet":"# Push branch\ngit push -u origin <feature-branch>\n\n# Create PR\ngh pr create --title \"<title>\" --body \"$(cat <<'EOF'\n## Summary\n<2-3 bullets of what changed>\n\n## Test Plan\n- [ ] <verification steps>\nEOF\n)\""}],"parameters":null,"dependencies":[],"permissions":[],"extractedFiles":[{"path":"brainstorming/SKILL.md","content":"---\nname: superpowers-open-brainstorming\ndescription: >\n  Use before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.\nmetadata:\n  openclaw:\n    emoji: \"💡\"\n---\n\n# Brainstorming Ideas Into Designs\n\nHelp turn ideas into fully formed designs and specs through natural collaborative dialogue.\n\nStart 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.\n\n<HARD-GATE>\nDo 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.\n</HARD-GATE>\n\n## Anti-Pattern: \"This Is Too Simple To Need A Design\"\n\nEvery 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.\n\n## Checklist\n\nYou MUST create a task for each of these items and complete them in order:\n\n1. **Explore project context** — check files, docs, recent commits\n2. **Ask clarifying questions** — one at a time, understand purpose/constraints/success criteria\n3. **Propose 2-3 approaches** — with trade-offs and your recommendation\n4. **Present design** — in sections scaled to their complexity, get user approval after each section\n5. **Write design doc** — save to `docs/specs/YYYY-MM-DD-<topic>-design.md` and commit\n6. **Spec self-review** — quick inline check for placeholders, contradictions, ambiguity, scope\n7. **User reviews written spec** — ask user to review the spec file before proceeding\n8. **Transition to implementation** — invoke superpowers-open:writing-plans to create implementation plan\n\n## The Process\n\n**Understanding the idea:**\n\n- Check out the current project state first (files, docs, recent commits)\n- 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.\n- 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.\n- Ask questions one at a time to refine the idea\n- Prefer multiple choice questions when possible, but open-ended is fine too\n- Only one question per message\n\n**Exploring approaches:**\n\n- Propose 2-3 different approaches with trade-offs\n- Present options conversationally with your recommendation and reasoning\n- Lead with your recommended option and explain why\n\n**Presenting the design:**\n\n- Once you believe yo"},{"path":"executing-plans/SKILL.md","content":"---\nname: superpowers-open-executing-plans\ndescription: >\n  Use when you have a written implementation plan to execute. Loads the plan, reviews critically, executes all tasks inline, and reports when complete.\nmetadata:\n  openclaw:\n    emoji: \"⚡\"\n---\n\n# Executing Plans\n\n## Overview\n\nLoad plan, review critically, execute all tasks, report when complete.\n\n**Announce at start:** \"I'm using the executing-plans skill to implement this plan.\"\n\n**Note:** This is the only execution mode in SuperpowersOpen. There is no subagent-driven alternative. All tasks run inline in the current session.\n\n## The Process\n\n### Step 1: Load and Review Plan\n1. Read plan file\n2. Review critically - identify any questions or concerns about the plan\n3. If concerns: Raise them with your human partner before starting\n4. If no concerns: Create task list and proceed\n\n### Step 2: Execute Tasks\n\nFor each task:\n1. Mark as in_progress\n2. Follow each step exactly (plan has bite-sized steps)\n3. Run verifications as specified\n4. Mark as completed\n\n### Step 3: Complete Development\n\nAfter all tasks complete and verified:\n- Announce: \"I'm using the finishing-a-development-branch skill to complete this work.\"\n- **REQUIRED: Use superpowers-open:finishing-a-development-branch**\n- Follow that skill to verify tests, present options, execute choice\n\n## When to Stop and Ask for Help\n\n**STOP executing immediately when:**\n- Hit a blocker (missing dependency, test fails, instruction unclear)\n- Plan has critical gaps preventing starting\n- You don't understand an instruction\n- Verification fails repeatedly\n\n**Ask for clarification rather than guessing.**\n\n## When to Revisit Earlier Steps\n\n**Return to Review (Step 1) when:**\n- Partner updates the plan based on your feedback\n- Fundamental approach needs rethinking\n\n**Don't force through blockers** - stop and ask.\n\n## Remember\n- Review plan critically first\n- Follow plan steps exactly\n- Don't skip verifications\n- Reference skills when plan says to\n- Stop when blocked, don't guess\n- Never start implementation on main/master branch without explicit user consent\n\n## Integration\n\n**Required workflow skills:**\n- **superpowers-open:using-git-worktrees** — Set up isolated workspace before starting\n- **superpowers-open:writing-plans** — Creates the plan this skill executes\n- **superpowers-open:finishing-a-development-branch** — Complete development after all tasks"},{"path":"finishing-a-development-branch/SKILL.md","content":"---\nname: superpowers-open-finishing-a-development-branch\ndescription: >\n  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.\nmetadata:\n  openclaw:\n    emoji: \"🏁\"\n---\n\n# Finishing a Development Branch\n\n## Overview\n\nGuide completion of development work by presenting clear options and handling chosen workflow.\n\n**Core principle:** Verify tests → Present options → Execute choice → Clean up.\n\n**Announce at start:** \"I'm using the finishing-a-development-branch skill to complete this work.\"\n\n## The Process\n\n### Step 1: Verify Tests\n\n**Before presenting options, verify tests pass:**\n\n```bash\n# Run project's test suite\nnpm test / cargo test / pytest / go test ./...\n```\n\n**If tests fail:**\n```\nTests failing (<N> failures). Must fix before completing:\n\n[Show failures]\n\nCannot proceed with merge/PR until tests pass.\n```\n\nStop. Don't proceed to Step 2.\n\n**If tests pass:** Continue to Step 2.\n\n### Step 2: Determine Base Branch\n\n```bash\n# Try common base branches\ngit merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null\n```\n\nOr ask: \"This branch split from main - is that correct?\"\n\n### Step 3: Present Options\n\nPresent exactly these 4 options:\n\n```\nImplementation complete. What would you like to do?\n\n1. Merge back to <base-branch> locally\n2. Push and create a Pull Request\n3. Keep the branch as-is (I'll handle it later)\n4. Discard this work\n\nWhich option?\n```\n\n**Don't add explanation** - keep options concise.\n\n### Step 4: Execute Choice\n\n#### Option 1: Merge Locally\n\n```bash\n# Switch to base branch\ngit checkout <base-branch>\n\n# Pull latest\ngit pull\n\n# Merge feature branch\ngit merge <feature-branch>\n\n# Verify tests on merged result\n<test command>\n\n# If tests pass\ngit branch -d <feature-branch>\n```\n\n#### Option 2: Push and Create PR\n\n```bash\n# Push branch\ngit push -u origin <feature-branch>\n\n# Create PR\ngh pr create --title \"<title>\" --body \"$(cat <<'EOF'\n## Summary\n<2-3 bullets of what changed>\n\n## Test Plan\n- [ ] <verification steps>\nEOF\n)\"\n```\n\nIf `gh` CLI not available, instruct the user to create the PR manually via their Git platform.\n\n#### Option 3: Keep As-Is\n\nReport: \"Keeping branch <name>.\"\n\n**Don't delete anything.**\n\n#### Option 4: Discard\n\n**Confirm first:**\n```\nThis will permanently delete:\n- Branch <name>\n- All commits: <commit-list>\n\nType 'discard' to confirm.\n```\n\nWait for exact confirmation.\n\nIf confirmed:\n```bash\ngit checkout <base-branch>\ngit branch -D <feature-branch>\n```\n\n### Non-Git Projects\n\nIf the project is not a git repository, skip branch operations. Instead:\n- Confirm all changes are saved\n- Ask the user what to do next\n\n## Quick Reference\n\n| Option | Merge | Push | Cleanup Branch |\n|--------|-------|------|----------------|\n| 1. Merge locally | ✓ | - | ✓ |\n| 2. Create PR | - | ✓ | - |\n| 3. Keep as-is | - | - | - |\n| 4. Discard | - | - | ✓ (force) |\n\n## Red Flags\n\n*"},{"path":"receiving-code-review/SKILL.md","content":"---\nname: superpowers-open-receiving-code-review\ndescription: >\n  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.\nmetadata:\n  openclaw:\n    emoji: \"👀\"\n---\n\n# Code Review Reception\n\n## Overview\n\nCode review requires technical evaluation, not emotional performance.\n\n**Core principle:** Verify before implementing. Ask before assuming. Technical correctness over social comfort.\n\n## The Response Pattern\n\n```\nWHEN receiving code review feedback:\n\n1. READ: Complete feedback without reacting\n2. UNDERSTAND: Restate requirement in own words (or ask)\n3. VERIFY: Check against codebase reality\n4. EVALUATE: Technically sound for THIS codebase?\n5. RESPOND: Technical acknowledgment or reasoned pushback\n6. IMPLEMENT: One item at a time, test each\n```\n\n## Forbidden Responses\n\n**NEVER:**\n- \"You're absolutely right!\" (performative agreement)\n- \"Great point!\" / \"Excellent feedback!\" (performative)\n- \"Let me implement that now\" (before verification)\n\n**INSTEAD:**\n- Restate the technical requirement\n- Ask clarifying questions\n- Push back with technical reasoning if wrong\n- Just start working (actions > words)\n\n## Handling Unclear Feedback\n\n```\nIF any item is unclear:\n  STOP - do not implement anything yet\n  ASK for clarification on unclear items\n\nWHY: Items may be related. Partial understanding = wrong implementation.\n```\n\n**Example:**\n```\nYour human partner: \"Fix 1-6\"\nYou understand 1,2,3,6. Unclear on 4,5.\n\n❌ WRONG: Implement 1,2,3,6 now, ask about 4,5 later\n✅ RIGHT: \"I understand items 1,2,3,6. Need clarification on 4 and 5 before proceeding.\"\n```\n\n## Source-Specific Handling\n\n### From your human partner\n- **Trusted** - implement after understanding\n- **Still ask** if scope unclear\n- **No performative agreement**\n- **Skip to action** or technical acknowledgment\n\n### From External Reviewers\n```\nBEFORE implementing:\n  1. Check: Technically correct for THIS codebase?\n  2. Check: Breaks existing functionality?\n  3. Check: Reason for current implementation?\n  4. Check: Works on all platforms/versions?\n  5. Check: Does reviewer understand full context?\n\nIF suggestion seems wrong:\n  Push back with technical reasoning\n\nIF can't easily verify:\n  Say so: \"I can't verify this without [X]. Should I [investigate/ask/proceed]?\"\n\nIF conflicts with your human partner's prior decisions:\n  Stop and discuss with your human partner first\n```\n\n## YAGNI Check for \"Professional\" Features\n\n```\nIF reviewer suggests \"implementing properly\":\n  grep codebase for actual usage\n\n  IF unused: \"This endpoint isn't called. Remove it (YAGNI)?\"\n  IF used: Then implement properly\n```\n\n## Implementation Order\n\n```\nFOR multi-item feedback:\n  1. Clarify anything unclear FIRST\n  2. Then implement in this order:\n     - Blocking issues (breaks, security)\n     - Simple fixes (typos, imports)\n     - Complex fixes (refactoring"},{"path":"requesting-code-review/SKILL.md","content":"---\nname: superpowers-open-requesting-code-review\ndescription: >\n  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.\nmetadata:\n  openclaw:\n    emoji: \"🔍\"\n---\n\n# Requesting Code Review\n\nSelf-review your work to catch issues before they reach a human reviewer.\n\n**Core principle:** Review early, review often. Since subagent-based review is not available on OpenClaw, use this structured self-review checklist.\n\n## When to Review\n\n**Mandatory:**\n- After each task in plan execution\n- After completing major feature\n- Before merge to main\n\n**Optional but valuable:**\n- When stuck (fresh perspective)\n- Before refactoring (baseline check)\n- After fixing complex bug\n\n## Self-Review Checklist\n\nRun this checklist against your changes. Be honest — you're looking for real issues, not validation.\n\n### 1. Spec Compliance\n\n```\n- [ ] Every requirement in the spec/plan has been implemented\n- [ ] Nothing extra was added beyond the spec (YAGNI)\n- [ ] All specified edge cases are handled\n- [ ] No spec requirements were skipped or deferred\n```\n\n### 2. Code Quality\n\n```\n- [ ] Code is minimal — no over-engineering or premature abstraction\n- [ ] Names are clear and describe what things do\n- [ ] No magic numbers — constants are named\n- [ ] No dead code or commented-out blocks\n- [ ] Error handling is present where needed (and absent where not)\n- [ ] No \"TODO\" or \"FIXME\" without a tracking issue\n```\n\n### 3. Testing\n\n```\n- [ ] Every new function/method has a test\n- [ ] Tests use real code (mocks only if unavoidable)\n- [ ] Edge cases are covered (empty input, null, boundary values)\n- [ ] Error paths are tested\n- [ ] All tests pass with clean output\n- [ ] **REQUIRED: superpowers-open:test-driven-development** was followed\n```\n\n### 4. Safety\n\n```\n- [ ] No credentials, tokens, or secrets in code\n- [ ] User input is validated at boundaries\n- [ ] No unsafe shell command construction\n- [ ] Dependencies are appropriate and necessary\n```\n\n### 5. Git Hygiene\n\n```\n- [ ] Changes are focused — one concern per commit\n- [ ] Commit messages describe WHY, not WHAT\n- [ ] No unrelated files accidentally included\n- [ ] Branch is up to date with base\n```\n\n## What To Do With Findings\n\n| Severity | Action |\n|----------|--------|\n| **Spec gap** (missing requirement) | Implement before proceeding |\n| **Bug** (incorrect behavior) | Fix with TDD cycle |\n| **Quality issue** (naming, magic number) | Fix now, one commit |\n| **Minor** (style nit) | Note, fix if touching file anyway |\n\n## If You Find Nothing\n\nIf the checklist is clean:\n- **REQUIRED: Use superpowers-open:verification-before-completion** — run actual verification commands\n- Only then proceed to **superpowers-open:finishing-a-development-branch** or the next task\n\n## Common Mistakes\n\n**Skipping review because \"it's simple\"**\n- Simple code has simple bugs. Review it.\n\n**Rubber-stamping your own work"}],"languages":[],"docsSourceLabel":"CLAWHUB","editorialOverview":"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","editorialQuality":{"score":100,"threshold":65,"status":"ready","wordCount":1758,"uniquenessScore":46,"reasons":[]}},"media":{"evidence":{"source":"no-media","verified":false,"confidence":"low","updatedAt":"2026-10-09T18:50:43.337Z","emptyReason":"No screenshots, media assets, or demo links are available."},"primaryImageUrl":null,"mediaAssetCount":0,"assets":[],"demoUrl":null},"ownerResources":{"evidence":{"source":"unclaimed","verified":false,"confidence":"low","updatedAt":"2026-10-09T18:50:43.337Z","emptyReason":"This page has not been claimed by the agent owner."},"hasCustomPage":false,"customPageUpdatedAt":null,"customLinks":[],"structuredLinks":{"docsUrl":null,"demoUrl":null,"supportUrl":null,"pricingUrl":null,"statusUrl":null},"customPage":null},"relatedAgents":{"evidence":{"source":"protocol-neighbors","verified":false,"confidence":"medium","updatedAt":"2026-10-10T08:45:32.562Z","emptyReason":null},"items":[{"id":"8ebccd8e-3863-4187-8355-c3f14e1f9edf","entityType":"agent","canonicalPath":"/agent/iofficeai-aionui","slug":"iofficeai-aionui","name":"AionUi","description":"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!","url":"https://github.com/iOfficeAI/AionUi","homepage":"https://www.aionui.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-10-09T19:11:12.944Z","createdAt":"2026-02-25T03:38:16.584Z","downloads":null},{"id":"b917f68a-ebff-438e-84f8-3f4b2494c0bc","entityType":"agent","canonicalPath":"/agent/activepieces-activepieces","slug":"activepieces-activepieces","name":"activepieces","description":"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","url":"https://github.com/activepieces/activepieces","homepage":"https://www.activepieces.com","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-15T02:22:12.426Z","createdAt":"2026-02-25T03:38:12.412Z","downloads":null},{"id":"5cb26759-3a39-483f-94cf-276a98c13bb8","entityType":"agent","canonicalPath":"/agent/cherryhq-cherry-studio","slug":"cherryhq-cherry-studio","name":"cherry-studio","description":"AI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMs","url":"https://github.com/CherryHQ/cherry-studio","homepage":"https://cherry-ai.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-11T14:38:40.986Z","createdAt":"2026-02-25T03:38:19.379Z","downloads":null},{"id":"6f6582d0-5d76-4f0f-b81d-86520247950b","entityType":"agent","canonicalPath":"/agent/copilotkit-copilotkit","slug":"copilotkit-copilotkit","name":"CopilotKit","description":"The Frontend for Agents & Generative UI. React + Angular","url":"https://github.com/CopilotKit/CopilotKit","homepage":"https://docs.copilotkit.ai","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-03-25T09:50:57.846Z","createdAt":"2026-02-25T03:39:14.617Z","downloads":null}],"links":{"hub":"/agent","source":"/agent/source/clawhub","protocols":[{"label":"OpenClaw","href":"/agent/protocol/openclew"}]}}}