superpowers-optimized

Superpowers Optimized

The production-grade fork of obra/superpowers — same trusted workflow, dramatically leaner, safer, and more intelligent.

Built on the trusted obra/superpowers workflow and refined through research into LLM agent behavior, it adds automatic 3-tier workflow routing, proactive safety hooks, self-consistency verification at critical decision points, cross-session memory, and adversarial red-teaming — everything the original does, plus the discipline layer it was missing.

Cross-session memory changes the experience fundamentally. Without it, every session starts blind: the AI re-explores structure it already mapped, re-proposes approaches that were already rejected, re-debugs errors that were already solved. With the memory stack, it arrives knowing what was tried, what was decided, and why — and with a pre-computed snapshot of what was committed since the last session — and builds forward instead of sideways.

Five research-backed principles run throughout: less is more (minimal always-on instructions), fresh context beats accumulated context (subagents get clean scoped prompts, not polluted history), compliance ≠ competence (instructions must be carefully engineered, not just comprehensive), verify your own reasoning (multi-path self-consistency catches confident-but-wrong failures before they become expensive), and accountability drives accuracy (agents that know their output has real downstream consequences perform better).

Why developers switch

Feature	Original Superpowers	Superpowers Optimized	Real-world impact
Workflow selection	Manual	Automatic 3-tier (micro / lightweight / full)	Zero overhead on simple tasks
Safety & hooks	None	10 proactive hooks overall, with platform-specific subsets on Codex/OpenCode	Strongest safety on Claude; partial hook parity on Codex/OpenCode
Security review	None	Built into code review with OWASP checklist	Security catches before merge
Adversarial red team	None	Red team agent + auto-fix pipeline	Finds bugs checklists miss, fixes them with TDD
Error recovery	None	Project-specific known-issues.md	No rediscovering the same bug
Token efficiency	Standard	Always-on context hygiene + exploration tracking + automatic Bash output compression (76% savings on mixed sessions)	Less re-discovery, fewer wasted iterations
Discipline enforcement	Instructional tone	Rationalization tables, red flags, iron laws	Fewer LLM shortcuts
Progress visibility	None	Session stats (skills used, duration, actions)	See what the plugin did for you
Cross-session memory	None	Four-file memory stack: project-map.md (structure cache) + session-log.md (decision history) + state.md (task snapshot) + known-issues.md (error map) + automatic context-snapshot.json (git blast radius, written every session start)	The AI starts every session with full project context — no re-exploring, no re-explaining, no re-debugging

Try it in 30 seconds

In any supported agent IDE, start a new chat and paste:

Activate Superpowers Optimized and plan a secure user-authentication endpoint with full TDD and security review.

The agent will automatically route to the correct workflow, apply safety guards, and run an integrated security review during code review — no manual skill selection required.

See Installation for install, update, and uninstall commands on all platforms.

[!NOTE] Codex parity boundary: Claude Code gets the full 11-hook lifecycle. Codex now has verified live support for SessionStart, UserPromptSubmit, and PreToolUse(Bash) on macOS/Linux with codex_hooks = true and codex-cli 0.118.0+ (tested on 0.118.0). This repo now also ships a Codex-specific PostToolUse(Bash) smart-compress hook that can replace noisy Bash output after execution using the existing compression rules. Stop is implemented for Codex, but visible reminder surfacing should still be revalidated after install/update. Codex still does not expose Claude's PostToolUse(Edit|Write|Skill), PreToolUse(Skill), SubagentStop, Read/Edit/Write interception, or Claude's pre-execution Bash rewrite path, so full Claude parity is not possible today.

---

[!IMPORTANT] Compatibility Note: This plugin includes a comprehensive workflow router and 24 specialized skills covering debugging, planning, code review, TDD, execution, and more.

Other plugins or custom skills/agents in your .claude/skills/ and .claude/agents/ folders may interfere if they cover overlapping domains. Duplicate or competing skills can cause trigger conflicts, contradictory instructions, and unnecessary context bloat/rot, which will degrade the model's performance.

For the best experience and peak AI reasoning, we recommend disabling or removing all other plugins and existing SKILL.md or AGENTS.md files. This ensures a clean environment with zero risk of conflicting instructions.

---

Upon initiating a session with your coding agent, the plugin immediately pauses to establish a precise understanding of your objective rather than proceeding directly to code. It collaborates with you through a structured dialogue to refine a clear, complete specification, presenting each element in concise, easily digestible segments for your review and approval.

Once the design is approved, the agent constructs a detailed implementation plan that enforces genuine red/green TDD cycles, strict adherence to YAGNI and DRY principles, and token-efficient instructions that eliminate unnecessary verbosity.

When you confirm to proceed, the plugin automatically routes the task to the appropriate workflow—either subagent-driven-development or executing-plans—and executes it through mandatory review gates: subagent-driven-development reviews every task with a single reviewer that must return both a specification-compliance verdict and a code-quality verdict, both workflows close with a whole-branch review on the most capable model available, and security analysis (per OWASP guidelines) is integrated on any sensitive changes. For complex logic, the red-team agent conducts adversarial testing to surface concrete failure scenarios. Each critical finding is automatically converted by the auto-fix pipeline into a failing test, followed by a targeted fix and regression verification.

The agent evaluates relevant skills before every task. These workflows are enforced as mandatory processes, never optional suggestions. Overhead remains strictly proportional to complexity:

• Micro-tasks bypass all gates entirely
• Lightweight tasks receive a single verification checkpoint
• Full-complexity tasks engage the complete pipeline

---

How It Works