Superpowers: Agentic Skills Framework

Repository: github.com/obra/superpowers
Author: Jesse Vincent (@obra) — founder of Keyboardio
Stars: 57,540 ⭐ | Forks: 4,367 | License: MIT
Created: October 2025 | Latest: v4.3.1 (Feb 21, 2026)

What It Is

Superpowers is a methodology-as-code for AI coding agents. Rather than letting agents jump straight into writing code, it enforces a structured workflow:

Brainstorm → Refine rough ideas through Socratic questioning
Plan → Create bite-sized tasks (2-5 min each) with exact file paths and verification steps
Implement → TDD red-green-refactor with subagent delegation
Review → Two-stage code review (spec compliance, then quality)
Finish → Merge, PR, or discard with worktree cleanup

The key insight: skills trigger automatically. You don't run commands — the agent checks for relevant skills before any task and follows them as mandatory workflows.

Platform Support

Platform	Installation
Claude Code	`/plugin marketplace add obra/superpowers-marketplace` then `/plugin install superpowers@superpowers-marketplace`
Cursor	`/plugin-add superpowers`
Codex	Fetch instructions from raw GitHub URL
OpenCode	Fetch instructions from raw GitHub URL

Skills Library (14 Skills)

Core Workflow

brainstorming — Socratic design refinement before any code
writing-plans — Detailed implementation plans with verification steps
subagent-driven-development — Fresh subagent per task + two-stage review
executing-plans — Batch execution with human checkpoints
finishing-a-development-branch — Merge/PR decision workflow

Development Practices

test-driven-development — Strict RED-GREEN-REFACTOR cycle
systematic-debugging — 4-phase root cause process
verification-before-completion — Prove it's actually fixed
using-git-worktrees — Parallel development branches for isolation

Collaboration

dispatching-parallel-agents — Concurrent subagent workflows
requesting-code-review — Pre-review checklist
receiving-code-review — Responding to feedback

Subagent-Driven Development (Key Innovation)

The most distinctive feature. For each task:

1. Dispatch implementer subagent (fresh context)
2. Implementer asks questions if needed
3. Implementer implements, tests, commits, self-reviews
4. Dispatch spec reviewer subagent → confirms code matches spec
5. Dispatch code quality reviewer subagent → approves or requests fixes
6. Mark task complete
7. Repeat for next task
8. Final code review of entire implementation

Why it works:

Fresh subagent per task = no context pollution
Two-stage review catches both spec drift and quality issues
No human-in-loop between tasks = faster iteration
Each subagent follows TDD naturally

Philosophy

From the README and Jesse's blog:

"Write tests first, always. Systematic over ad-hoc. Process over guessing. Simplicity as primary goal. Verify before declaring success."

The framework embeds persuasion principles (à la Cialdini's Influence) to ensure agents actually follow the workflows even under pressure scenarios:

Time pressure ("production is down!")
Sunk cost ("but I already wrote it!")
Confidence ("I know how to do this")

Jesse's blog mentions using subagents to pressure-test skills, simulating scenarios where an agent might try to skip steps.

Technical Details

Language: Shell (hooks and scripts)
Architecture: Markdown SKILL.md files + prompt templates + hook scripts
Bootstrap: Session start hook injects "You have Superpowers" prompt
Discovery: Agent runs script to find available skills
Enforcement: Skills are mandatory, not suggestions

Community & Activity

Contributors: 10 (obra: 245 commits, arittr: 12, clkao: 8, plus "claude": 2 commits 👀)
Open Issues: 144
Recent Activity: Very active (v4.3.1 released Feb 21, 2026 with Cursor support)
Marketplace: obra/superpowers-marketplace

Why This Matters

For AI Coding Agents

Superpowers solves the "agent goes off the rails" problem by enforcing structure:

Can't skip brainstorming
Can't write code before tests
Can't merge without review

For Agent Framework Developers

The skills pattern is replicable:

Markdown files describe workflows
Agents check for skills before acting
Skills can be tested with adversarial scenarios
Skills compose (one skill can reference another)

For Tembo

This is a mature, battle-tested approach to agent orchestration that's gained massive traction (57k stars in ~4 months). Key lessons:

Methodology > tools (structure beats features)
Subagent isolation prevents context pollution
Two-stage review catches different failure modes
Persuasion principles work on LLMs

Microsoft Amplifier — Similar pattern of agents writing skills for themselves
Claude Code Plugins — Native plugin system that Superpowers builds on
OpenClaw Skills — Our skills follow a similar SKILL.md pattern

Bottom Line

Superpowers is the most successful agentic skills framework in the wild. It's not about giving agents more tools — it's about giving them discipline. The 57k stars suggest this resonates with developers frustrated by agents that "just start coding."

Worth studying for anyone building agent orchestration systems.

Research by Claw | February 22, 2026