obra/superpowers: The Agent Skills Framework Gaining 10,000 Stars a Week

195,000 Stars and Still Climbing

obra/superpowers picked up roughly 10,000 new stars in the past week, landing it among the top trending repositories across all languages on GitHub. That kind of velocity on a developer tooling project rarely happens by accident. It reflects a genuine shift in how builders think about coding agents: less "give the LLM a task," more "give the LLM a methodology."

The repo was created by Jesse Vincent (obra), starting as a personal workflow experiment before growing into a multi-platform skills framework. Today it supports Claude Code, Codex CLI, Cursor, Gemini CLI, GitHub Copilot CLI, Factory Droid, and OpenCode. At 195,000 stars and 17,300 forks, it is one of the larger agentic tooling projects on GitHub that is not backed by a major AI lab.

The core claim is direct: agents that follow a structured process ship better code than agents that jump straight to implementation. Superpowers provides that structure as composable, plain-text skills that activate automatically once installed.

What It Does

Superpowers installs a library of skills that steer coding agents through structured development phases instead of letting them sprint to code the moment a task is described. The framework's philosophy is "systematic over ad-hoc" - every agent session should understand requirements first, design before implementing, and verify before marking anything complete.

The workflow breaks into seven phases:

Brainstorming - the agent asks clarifying questions, explores alternatives, and presents a design for human approval before touching a file.

Git worktree setup - all work happens on an isolated branch, keeping the main branch clean regardless of how messy the exploration gets.

Writing plans - tasks are broken into 2-5 minute chunks with exact file paths, expected outputs, and verification steps.

Subagent-driven development - fresh subagents handle each task with a two-stage review gate: spec compliance first, then code quality.

Test-driven development - red-green-refactor is enforced. Any pre-test code is deleted before the cycle starts.

Code review - the agent reviews its own output against the original plan, reporting issues by severity.

Branch completion - tests are verified, then the agent presents options: merge, open a PR, keep the branch open, or discard.

The full skills library spans testing, debugging, collaboration, and meta-skills. One stands out: a writing-skills skill that lets the framework extend itself. You describe a new skill, the agent scaffolds it following the existing pattern. All skills are written in plain shell and markdown - no proprietary runtime, no locked SDK, no server to configure.

Install and Try It

Installation is a single command per platform. Skills activate automatically after install with no additional configuration.

Claude Code (official marketplace):

/plugin install superpowers@claude-plugins-official

Codex CLI:

/plugins

Then search "superpowers" and select Install Plugin.

Gemini CLI:

gemini extensions install https://github.com/obra/superpowers

Cursor:

/add-plugin superpowers

GitHub Copilot CLI:

copilot plugin marketplace add obra/superpowers-marketplace
copilot plugin install superpowers@superpowers-marketplace

Once installed, the primary entry points are /brainstorming to start a feature conversation, /writing-plans to generate a task breakdown, and /test-driven-development to enforce the TDD cycle on a specific module. The using-superpowers skill walks through the full methodology if you want a structured introduction.

The repo is MIT licensed and the full source lives at https://github.com/obra/superpowers.

Who Should Use It

Superpowers is a strong fit for developers already running coding agents on production codebases who keep hitting two failure modes: agents that write code before understanding the problem, and agents that call a task done while tests are still red.

If you are running Claude Code or Codex on anything larger than a single-file script, the brainstorming and planning phases pay back their overhead quickly. The git worktree isolation is especially useful on active repositories where you cannot afford to contaminate main with half-finished agent work.

Solo developers benefit most from the systematic debugging skill - it forces the agent to form and test hypotheses before reaching for random fixes. Teams benefit from the structured handoff documentation skill, which creates context the next agent or developer can actually use rather than a wall of unstructured notes.

Developers working across multiple agent tools will appreciate the cross-platform coverage. A single methodology works across Claude Code, Codex, Cursor, and Gemini CLI. Switching tools does not mean rebuilding your workflow from scratch.

The framework is less useful for pure prototyping or one-shot scripts where the structure adds friction without payoff. It also requires a human approval step before the agent starts implementing, which some fully automated pipelines will want to skip.

How It Connects to the DevDigest Ecosystem

DevDigest uses a similar skills-as-methodology pattern. The skills directory at skills.developersdigest.tech powers content creation, QA audits, video-to-blog handoffs, and daily improvement workflows - all structured as composable commands that agents invoke.

Superpowers sits upstream of that layer. It handles the development process itself: planning, branching, testing, reviewing. DevDigest skills are domain-specific (content, SEO, site maintenance). Neither framework steps on the other.

The complementary fit is practical. You could use superpowers to structure how an agent builds a new feature or tool integration, then call DevDigest's /add-content or /qa skills once the code is merged to handle the content and quality layers. The methodology stack layers cleanly.

If you are building your own agent workflow - whether on Claude Code or another tool - the superpowers framework is worth studying as a pattern reference. The way it chains subagents for parallel task execution and enforces review gates between phases is the kind of design that scales without becoming a debugging nightmare.

Honest Assessment

The methodology behind superpowers is sound. Requiring agents to brainstorm before coding, plan before executing, and review before shipping reduces wasted iteration in practice. The cross-platform support is real and actively maintained. The plain-text skill format means you can read, fork, and audit exactly what your agent is being told to do - no black boxes, no vendor lock-in.

On the limitation side: the framework adds conversation overhead. For fast, simple tasks, the brainstorming and planning phases feel like ceremony that slows down work that could have shipped in two minutes. The project's policy is that external skill contributions are generally not accepted, which means the built-in library grows slowly and on the maintainer's timeline. Support for newer platforms like OpenCode is thinner than for Claude Code or Codex.

The star count is high partly because the framework is genuinely useful and partly because agentic methodology is a hot category right now. Both things can be true at once. The GitHub issue tracker shows enough real users that the framework is being stress-tested on actual production work - which matters more than the star count when deciding whether to adopt it.

References

• GitHub repository: https://github.com/obra/superpowers
• Original announcement post: https://blog.fsck.com/2025/10/09/superpowers/
• Docs and release announcements: https://primeradiant.com/superpowers/
• Community Discord: https://discord.gg/35wsABTejz
• DevDigest skills directory: https://skills.developersdigest.tech