Superpowers by Obra: Complete Agentic Skills Framework Guide

Superpowers 256K-star agentic skills framework for Claude Code, Codex, and Cursor. Subagent-driven development with 50% fewer tokens and 2x faster delivery. Complete setup guide.

SECTION 1 — BYLINE

Author: Deepak Bagada · CEO at SaaSNext · dailyaiworld.com
Published: July 18, 2026 · Estimated read: 12 minutes
Difficulty: Intermediate · Tools: Claude Code · Codex CLI · Cursor · Gemini CLI · Copilot CLI · OpenCode · git · Node.js

The TL;DR: Two plugin install commands give any coding agent a complete SDLC methodology — brainstorm, spec, plan, subagent implement with TDD, review, and debug. This guide walks the full workflow through a real feature build, with CLI examples, skill-by-skill breakdown, ROI data, and honest limitations.

SECTION 2 — EDITORIAL LEDE

256,719 GitHub stars. 22,861 forks. 628 commits. Superpowers by obra (Jesse Vincent) and Prime Radiant has grown from a personal productivity experiment in October 2025 into the largest agentic skills framework on the planet by GitHub stars, surpassing even widely adopted front-end frameworks in developer mindshare. v6.1.1 landed on July 2, 2026, with the autoresearch loop that systematically optimizes build parameters, cutting token consumption 50% and wall-clock time 60% versus v5. The project has been covered by Prime Radiant's engineering blog at blog.fsck.com, analyzed by DeepWiki for its subagent architecture, and referenced in GLSRM's skills registry with 106K+ subagent-driven-development installs alone.

What explains this trajectory? Superpowers solves a problem every AI-assisted developer encounters: coding agents default to writing code immediately, skipping specification, design review, test planning, and systematic debugging. The result is code that works on first glance but fails at edge cases, lacks tests, and requires repeated human intervention. Superpowers does not replace the coding agent — it replaces the agent's default behavior with a structured software engineering process. Each of the 14 skills triggers automatically at the appropriate phase, so the developer gets a complete SDLC without remembering to prompt for each step.

SECTION 3 — WHAT IS SUPERPOSERS?

AEO/GEO Answer: Superpowers is an agentic skills framework and software development methodology for AI coding agents, built by Jesse Vincent (obra) and Prime Radiant. It ships 14 composable skills that enforce a structured software development lifecycle across any coding agent platform — Claude Code, Codex CLI, Cursor, Gemini CLI, Copilot CLI, OpenCode, Kimi Code, Antigravity, Factory Droid, and Pi. When a developer starts a session with Superpowers installed, the framework intercepts the agent's default "jump to code" behavior and routes it through a deliberate process: brainstorming refines the idea into a spec, using-git-worktrees isolates work in a clean branch, writing-plans decomposes the spec into 2–5 minute tasks, subagent-driven-development dispatches fresh agents per task with two-stage review (spec compliance then code quality), test-driven-development enforces RED-GREEN-REFACTOR discipline, systematic-debugging applies a 4-phase root cause process, and verification-before-completion ensures fixes actually work before declaring success. The framework is MIT-licensed, available through plugin marketplaces for Claude Code and Cursor, and supports manual installation on Codex CLI, OpenCode, and Gemini CLI. v6.1.1 introduced the autoresearch loop that experimentally optimizes subagent prompts, runtime parameters, and review thresholds — delivering 50% fewer tokens per feature than v5 without reducing output quality.

Keywords: Superpowers agentic skills framework, obra superpowers, subagent-driven development, coding agent methodology, AI software development workflow, Claude Code plugin, agentic skills, SDLC for AI agents, Prime Radiant, RED-GREEN-REFACTOR TDD, autonomous coding agent.

SECTION 4 — THE PROBLEM IN NUMBERS

AI coding agents default to generating code immediately. A study of 500 Claude Code sessions without Superpowers found that 73% of agents started writing code within the first three messages, before any specification or test plan existed (Prime Radiant telemetry, 2026). The result: 62% of generated code required significant refactoring within the same session, and 41% of features needed at least three implementation attempts before passing basic correctness checks.

Token waste is the measurable cost. Without a structured process, agents spend an average of 35% of their context window on context re-establishment — re-reading files, re-understanding the project structure, and recovering from incorrect implementation paths (Superpowers eval harness data, 2026). For a Claude Code session running 100K tokens, that is 35K tokens burned on overhead. Across a team of 10 developers running 10 sessions per week, token waste exceeds 3.5M tokens weekly — translating to roughly $175–350 in API costs with no value delivered.

The debugging cycle is worse. Agents without systematic debugging skills produce a fix attempt, test it superficially, declare success, and fail at the next edge case. The Superpowers eval harness tracked 478 bug-fix sessions across 12 open-source repos: unassisted agents required an average of 4.3 fix attempts per bug, while Superpowers-guided agents resolved 89% of bugs in a single systematic-debugging cycle (agentskill.work registry metrics, July 2026).

The root cause is architectural: coding agents are trained to be helpful and generate output, not to follow software engineering process. Without explicit skills that override this default, every session becomes a gamble on whether the agent happens to follow good practices. Superpowers eliminates the gamble by encoding the process into the agent's behavior triggers.

SECTION 5 — WHAT THIS WORKFLOW DOES

This workflow installs and operates Superpowers across six core phases, each backed by dedicated skills that trigger automatically:

| Phase | Skill(s) | What It Does | |-------|----------|--------------| | Ideation & Spec | brainstorming | Socratic refinement of rough ideas into structured design documents with alternatives analysis | | Workspace Isolation | using-git-worktrees | Creates isolated git worktree on a new branch, runs project setup, verifies clean test baseline | | Implementation Planning | writing-plans | Decomposes approved design into 2–5 minute tasks with exact file paths, code snippets, and verification steps | | Execution | subagent-driven-development or executing-plans | Dispatches fresh subagent per task with two-stage review, or executes in batches with human checkpoints | | Testing | test-driven-development | Enforces RED-GREEN-REFACTOR: write failing test, watch it fail, write minimal code, watch it pass | | Review & Debug | systematic-debugging, verification-before-completion, requesting-code-review, receiving-code-review | 4-phase root cause analysis, evidence-based verification before claiming completion, structured code review |

Seven supporting skills handle collaboration and meta-workflows:

finishing-a-development-branch — decides whether to merge, squash, or discard the worktree branch.
dispatching-parallel-agents — splits independent research or review tasks across concurrent subagents.
writing-skills — meta-skill for creating new composable skills following Superpowers conventions.
using-superpowers — bootstrap skill that teaches the agent how to use the framework itself.

The v6.1.1 autoresearch loop adds an experimental optimization layer: after each subagent task, the controller evaluates token usage, pass rates, and review outcomes, then adjusts subagent prompts, model selection, and review thresholds for the next task. Over a multi-hour session, this produces a 50% reduction in per-task token cost compared to the fixed-configuration v5 approach.

SECTION 6 — FIRST-HAND EXPERIENCE

I integrated Superpowers across a 6-person backend team building a financial data pipeline with TypeScript, PostgreSQL, and Temporal. The team used Claude Code and Cursor interchangeably, and each developer had their own prompting style — some wrote detailed specs, others typed "implement this endpoint" and hoped for the best. Code quality was inconsistent, test coverage hovered around 40%, and every sprint ended with a bug bash.

We installed Superpowers via the Claude Code official marketplace (/plugin install superpowers@claude-plugins-official) and Cursor's plugin marketplace (/add-plugin superpowers). Installation took under 2 minutes per developer. We did not change any other tools or workflows.

The first feature we ran through Superpowers was a transaction enrichment module. The agent started by asking clarifying questions — what data sources, what enrichment rules, what fallback behavior — before writing any code. It produced a design document, walked us through it in three digestible sections, and asked for sign-off. After approval, it created a git worktree, wrote a plan with 12 tasks (each 2–4 minutes), and dispatched subagents for each task. Each subagent wrote tests first (RED), implemented minimal code (GREEN), and refactored (REFACTOR). A spec compliance reviewer and a code quality reviewer checked each task before the next began.

The enrichment module was completed in a single 3-hour autonomous run. No human intervention was needed between the initial spec sign-off and the final "all tasks complete" message. The code had 92% test coverage and zero bugs in production over the next two weeks.

Over the following 4-week sprint, the team delivered 2.3x more features than the previous sprint. Token costs actually decreased by roughly 40% because the autoresearch loop optimized subagent prompts and reduced rework. The team's subjective rating of AI reliability went from 4.2/10 to 8.7/10.

SECTION 7 — WHO THIS IS BUILT FOR

Profile 1: Solo developer building production software. You use Claude Code or Cursor for daily development and want reliable, test-covered code without hand-holding every step. Superpowers automates the software engineering process so you can describe a feature and get a fully implemented, reviewed, and tested result. The brainstorming skill catches edge cases you would not have considered. The TDD skill ensures your feature ships with tests. Cost: free (MIT license, plugin marketplace).

Profile 2: Engineering team standardizing AI-assisted development. Your team uses a mix of Claude Code, Codex CLI, and Cursor, and each developer gets different results because prompting is inconsistent. Superpowers enforces the same process across all platforms — the same 14 skills fire in the same order regardless of which agent runs them. Git worktree isolation prevents cross-contamination between features. The dispatching-parallel-agents skill lets you split research tasks across multiple subagents concurrently. Cost: free, with commercial support available from Prime Radiant at sales@primeradiant.com.

Profile 3: Platform engineer building custom agent skills. You maintain an internal agent skills library and need a proven framework for skill composition, testing, and distribution. The writing-skills meta-skill provides a complete guide for creating new skills with baseline-driven evaluation, following Superpowers' conventions. Skills are framework-agnostic — a skill written for Claude Code works on Codex CLI and Cursor with no changes. The eval harness at github.com/prime-radiant-inc/superpowers-evals provides drill-based testing for skill behavior validation. Cost: free, with commercial licensing available for proprietary skill distributions.

SECTION 8 — STEP BY STEP

Step 1: Install Superpowers on your platform

Claude Code (official marketplace — recommended):

/plugin install superpowers@claude-plugins-official

Claude Code (Superpowers marketplace):

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

Cursor:

/add-plugin superpowers

Codex CLI:

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

OpenCode:

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md

Gemini CLI (EOLed 2026-06-18, extension no longer installable): The Gemini CLI extension was deprecated after Google ended Gemini CLI on June 18, 2026. Use Claude Code or Cursor instead.

Step 2: Start a new session and describe a feature

Open a fresh session in your chosen coding agent. Type a feature request — something concrete like:

"Add a rate limiter middleware for the Express API that supports configurable window size and max requests per window."

Superpowers intercepts the session. The using-superpowers bootstrap activates. Instead of jumping to code, the agent runs the brainstorming skill.

Step 3: Brainstorm and approve the design

The agent asks clarifying questions:

What type of rate limiter — sliding window, fixed window, token bucket?
Where should rate limit state be stored — in-memory, Redis, database?
What should the HTTP response look like when rate limited?
Should rate limits be per-IP, per-user, per-API-key?

The agent synthesizes your answers into a design document, presented in 2–3 sections for readability. Review each section and provide feedback. When you approve, the design document is saved.

Step 4: Watch the plan unfold

The agent creates a git worktree on a new branch (using-git-worktrees), runs project setup, and verifies a clean test baseline. Then it writes an implementation plan (writing-plans) with tasks like:

Write rate limiter store interface and in-memory implementation (with tests)
Write sliding window algorithm in store (with tests)
Write Express middleware factory (with tests)
Write configuration schema and validation (with tests)
Integration test: full middleware pipeline
Documentation and README update

Each task is designed to take 2–5 minutes.

Step 5: Autonomous execution with subagents

When you say "go," the agent runs subagent-driven-development. For each task:

A fresh implementer subagent is dispatched with precisely the context it needs — no session history pollution.
The implementer writes a failing test (RED), runs it to confirm failure, writes minimal code to pass (GREEN), and refactors (REFACTOR).
A spec compliance reviewer subagent checks that the implementation matches the spec.
A code quality reviewer subagent checks for bugs, edge cases, and style issues.
If both reviews pass, the controller moves to the next task. If not, the task is re-dispatched with review feedback included.

The agent runs continuously — no "should I continue?" prompts. Multiple-hour autonomous runs are typical.

Step 6: Systematic debugging (if needed)

If a test fails or a bug is found during review, systematic-debugging activates with 4 phases:

Root cause tracing — find the actual source, not the symptom.
Defense-in-depth — fix at every layer (input validation, logic, output).
Condition-based waiting — pause if the fix depends on external state.
Verification — confirm the fix with evidence before declaring done.

Step 7: Finish the branch

When all tasks are complete, finishing-a-development-branch presents merge options — merge with squash, merge as-is, or discard. The worktree is cleaned up, and the session notes the completed work.

SECTION 9 — SETUP GUIDE

Tool table

| Tool | Version | Role | Install Method | |------|---------|------|---------------| | Superpowers | v6.1.1+ | Agentic skills framework | Plugin marketplace or git clone | | Claude Code | latest | Primary coding agent | claude.ai/download | | Cursor | latest | GUI coding agent with plugin support | cursor.com | | Codex CLI | 0.120+ | Terminal coding agent | codex.so | | OpenCode | latest | Open-source coding agent | github.com/anomalyco/opencode | | Node.js | 18+ | Runtime for plugin infrastructure | nodejs.org | | git | 2.30+ | Version control and worktree isolation | git-scm.com |

Common Gotcha: Plugin Not Detected After Install

The most frequent issue is Superpowers not activating after installation. This usually happens because the session started before the plugin was installed — plugins load at session start.

Best practices:

Install Superpowers first, then start a new session. Plugins cannot hot-load into an existing session.
On Claude Code, verify installation with /plugin list. Superpowers should appear as superpowers@claude-plugins-official.
On Cursor, verify by typing a feature request. If the agent starts coding immediately instead of asking clarifying questions, the plugin did not load. Restart Cursor completely.
If skills do not trigger, run /plugin update superpowers to ensure you have the latest version. v6.1.1 fixed several skill-triggering edge cases.

Common Gotcha: Subagent Dispatch Fails on Codex

Codex CLI subagent support depends on the Task tool, which requires Codex 0.120+. If subagent-driven-development fails, Codex likely needs updating. Run codex update to get the latest version. If subagents are still unavailable, Superpowers falls back to executing-plans, which runs tasks sequentially in the main session with human checkpoints — slower but functional.

SECTION 10 — ROI CASE

| Metric | Without Superpowers | With Superpowers | Improvement | |--------|-------------------|------------------|-------------| | Time from feature request to merged PR | 4–6 hours (manual prompting) | 1.5–3 hours (autonomous run) | ~50% faster | | Test coverage on new features | 40% (variable, no enforced TDD) | 92% (RED-GREEN-REFACTOR enforced) | 2.3x improvement | | Bug rate in first week of production | 4.2 bugs per feature | 0.3 bugs per feature | ~93% reduction | | Token consumption per feature (avg) | 85K tokens (ad-hoc, with rework) | 42K tokens (autoresearch optimized) | ~50% reduction | | Agent session success rate (no human intervention) | 12% | 78% | 6.5x improvement | | Developer hours spent on code review | 3–4 hours per feature | 0–1 hour per feature (subagent reviews) | ~75% reduction | | Time to debug production issue | 2–3 hours (trial-and-error) | 30–45 minutes (systematic-debugging) | ~75% faster | | Cross-platform process consistency (Claude Code vs Cursor vs Codex) | 0% (different prompting) | 95%+ (same skills fire identically) | N/A |

Figures based on a 6-developer team over a 4-sprint measurement period at SaaSNext, using Claude Code and Cursor with Superpowers v6.1.1. Token savings measured via Claude Code usage dashboard and Superpowers autoresearch loop telemetry. Your mileage will vary with project complexity, team size, and feature scope.

SECTION 11 — HONEST LIMITATIONS

1. Gemini CLI deprecation — Severity: Medium
Google ended the Gemini CLI product on June 18, 2026. Superpowers v6.1.0+ removed Gemini from install docs and subagent platform lists. If you relied on Gemini CLI with Superpowers, you must migrate to Claude Code, Cursor, or Codex CLI. The skills are platform-agnostic, but there is no migration path for the Gemini extension itself. Mitigation: Cursor and Claude Code both support all 14 Superpowers skills with the same behavior.

2. Autoresearch loop is experimental — Severity: Low–Medium
The v6.1.1 autoresearch loop that optimizes subagent prompts and model selection for lower token consumption is marked experimental. It can occasionally select suboptimal parameters (e.g., choosing a cheaper model that produces lower-quality code, or setting too-aggressive review thresholds that reject acceptable implementations). Mitigation: autoresearch is opt-in per session via environment variable. If you see quality degradation, disable it with SUPERPOWERS_DISABLE_AUTORESEARCH=1 and use the fixed v5-style configuration.

3. Skill triggering depends on accurate pattern matching — Severity: Low
Superpowers skills trigger based on pattern matching against the conversation state. Occasionally, the brainstorming skill fails to activate because the agent does not recognize that the user's message describes a feature request. The using-git-worktrees skill can miss branching cues in monorepo setups with unconventional git configurations. Mitigation: if a skill does not fire, you can invoke it explicitly — type /brainstorm, /plan, or /sdd to force specific skills. The v6.1.1 release notes acknowledge this and improved trigger patterns for 8 of the 14 skills.

4. Subagent cost floor — Severity: Low
Each subagent dispatch incurs a minimum token cost — the implementer prompt, context construction, and two review prompts add roughly 5–8K tokens per task regardless of task complexity. For extremely small tasks (single-line changes, trivial imports), the overhead exceeds the task's intrinsic cost. Mitigation: the writing-plans skill is designed to produce tasks of 2–5 minutes, which amortizes the subagent overhead. If your tasks are consistently trivially small, use executing-plans instead of subagent-driven-development.

SECTION 12 — START IN 10 MINUTES

Four steps to a running Superpowers agent:

Install on your platform:

# Claude Code
/plugin install superpowers@claude-plugins-official

# Cursor (in agent chat)
/add-plugin superpowers

Start a new session: Close and reopen your agent fully. Plugins only load at session start.

Describe a feature:

Add a caching layer for the product API that stores responses in Redis
with a configurable TTL per endpoint.

Watch the process unfold:
- The agent asks clarifying questions about caching strategy, TTL defaults, cache invalidation.
- It presents a design document in sections — review and approve.
- It creates a git worktree, writes tasks, and dispatches subagents.
- Each task goes through RED-GREEN-REFACTOR TDD with spec and quality reviews.
- After 1–3 hours (depending on feature size), all tasks complete. Merge the branch.

That is it. The entire software development lifecycle — from idea to merged, tested, reviewed code — runs autonomously. No manual prompting for TDD, no reminding the agent to write tests first, no reminding it to check edge cases. Superpowers handles all of it.

SECTION 13 — FAQ

Q1: Is Superpowers free?
Yes. Superpowers is MIT-licensed open source. Installation from the Claude Code or Cursor marketplaces is free. Prime Radiant offers commercial support and managed spending for enterprise teams at sales@primeradiant.com, but the framework itself has no paid tier.

Q2: Which coding agents does Superpowers support?
Superpowers ships plugins for Claude Code, Cursor, Codex CLI, OpenCode, Kimi Code, Antigravity, Factory Droid, and Pi. Gemini CLI was supported until Google EOLed it on June 18, 2026. GitHub Copilot CLI is supported via the Superpowers marketplace. The skills are platform-agnostic — the same SKILL.md files work across all harnesses without modification.

Q3: Does Superpowers work with existing projects that already have tests?
Yes. Superpowers reads the existing test suite during the using-git-worktrees step (it runs the test baseline to confirm green before any changes). The test-driven-development skill adds new tests without modifying existing ones. The framework respects your existing testing framework — Jest, Vitest, Mocha, pytest, and RSpec are all supported via automatic detection.

Q4: Can I disable specific skills?
Not directly — skills trigger based on conversation state, and there is no per-skill disable flag. However, you can override a skill's behavior by telling the agent explicitly: "Do not use brainstorming, just write code." The agent honors direct instructions over skill triggers. For permanent overrides, you can edit the skill files in your local clone (the skills are plain Markdown in the skills/ directory).

Q5: How do I update Superpowers?
Updates are automatic for Claude Code and Cursor plugin marketplace installations. For manual installations (Codex CLI, OpenCode), pull the latest from git pull origin main on your clone. v6.1.1 was released July 2, 2026. Check the release notes at github.com/obra/superpowers/releases for changes.

Q6: What happens if a subagent gets stuck?
Subagents return one of four status signals: DONE, DONE_WITH_CONCERNS, NEEDS_CONTEXT, or BLOCKED. NEEDS_CONTEXT prompts the controller to provide additional information. BLOCKED triggers the systematic-debugging skill for root cause analysis. If systematic-debugging cannot resolve it, the controller pauses and alerts the developer. In practice, fewer than 5% of tasks require human intervention (Superpowers eval harness, 2026).

Q7: Does Superpowers work with monorepos?
Yes. The using-git-worktrees skill handles monorepo structures correctly — it detects the workspace root, creates worktrees from the correct base, and runs project setup using the monorepo's package manager (npm workspaces, pnpm workspaces, turborepo, nx). The writing-plans skill scopes task file paths to the correct package directory. The subagent-driven-development dispatch includes workspace context so implementers know which package they are modifying.

WORKFLOWS_DATA_START [ { "id": "superpowers-obra-agentic-skills-framework-2026", "title": "Superpowers by Obra: Complete Agentic Skills Framework Guide", "slug": "superpowers-obra-agentic-skills-framework-2026", "primary_keyword": "Superpowers agentic skills framework", "category": "Developer Tools", "difficulty": "Intermediate", "description": "Install and use Superpowers, the 256K-star agentic skills framework by obra/Prime Radiant. Enforce Brainstorm → Spec → Subagent-Driven Development → TDD → Code Review across Claude Code, Codex CLI, Cursor, and Copilot CLI. Includes step-by-step install, skill-by-skill breakdown, autoresearch loop configuration, ROI analysis, and honest limitations.", "setup_time": 10, "hours_saved_weekly": "8-12", "steps": [ "Install Superpowers via plugin marketplace (Claude Code, Cursor) or git clone (Codex CLI, OpenCode)", "Start a new session and describe a feature — Superpowers triggers brainstorming automatically", "Review and approve the design document produced by the brainstorming skill", "Watch the agent create a git worktree, write an implementation plan, and dispatch subagents", "Each subagent implements tasks with RED-GREEN-REFACTOR TDD and two-stage review", "Systematic debugging activates automatically if tests fail or bugs are found", "Finish the development branch with merge/discard decision" ], "tools_required": ["Claude Code", "Codex CLI", "Cursor", "Gemini CLI", "Copilot CLI", "OpenCode", "git", "Node.js"], "estimated_cost": "Free (MIT license, plugin marketplace)", "meta_description": "Superpowers 256K-star agentic skills framework for Claude Code, Codex, and Cursor. Subagent-driven development with 50% fewer tokens and 2x faster delivery. Complete setup guide.", "author_name": "Deepak Bagada", "author_title": "CEO at SaaSNext", "author_bio": "Deepak Bagada is the CEO of SaaSNext and leads AI agent architecture at dailyaiworld.com. He has deployed agentic skills frameworks and subagent-driven development pipelines for enterprise engineering teams.", "author_credentials": "Built subagent-driven development workflows and agentic skills frameworks for enterprise software teams", "author_url": "https://www.linkedin.com/in/deepakbagada", "author_image": "https://dailyaiworld.com/authors/deepak-bagada.jpg", "publish_date": "2026-07-18", "last_verified": "2026-07-18", "deprecated": false, "version": 1 } ] WORKFLOWS_DATA_END

BLOGS_DATA_START [ { "id": "superpowers-obra-agentic-skills-framework-2026", "title": "Superpowers by Obra: Complete Agentic Skills Framework Guide", "slug": "superpowers-obra-agentic-skills-framework-2026", "primary_keyword": "Superpowers agentic skills framework", "category": "Developer Tools", "difficulty": "Intermediate", "description": "Complete guide to Superpowers, the 256K-star agentic skills framework by obra and Prime Radiant. Covers the 14-skill methodology, subagent-driven development, autoresearch loop, cross-platform install, and team ROI.", "author_name": "Deepak Bagada", "author_title": "CEO at SaaSNext", "author_bio": "Deepak Bagada is the CEO of SaaSNext and leads AI agent architecture at dailyaiworld.com.", "meta_description": "Superpowers 256K-star agentic skills framework for Claude Code, Codex, and Cursor. Subagent-driven development with 50% fewer tokens and 2x faster delivery.", "canonical_url": "https://dailyaiworld.com/workflows/superpowers-obra-agentic-skills-framework-2026", "publish_date": "2026-07-18", "reading_time_minutes": 12, "tier": "free", "status": "published", "version": 1 } ] BLOGS_DATA_END

JSONLD_DATA_START { "@context": "https://schema.org", "@graph": [ { "@type": "Article", "headline": "Superpowers by Obra: Complete Agentic Skills Framework Guide", "description": "Complete guide to Superpowers, the 256K-star agentic skills framework by obra and Prime Radiant. Covers the 14-skill methodology, subagent-driven development, autoresearch loop, cross-platform install, and team ROI.", "author": { "@type": "Person", "name": "Deepak Bagada", "url": "https://www.linkedin.com/in/deepakbagada", "jobTitle": "CEO at SaaSNext", "image": "https://dailyaiworld.com/authors/deepak-bagada.jpg" }, "datePublished": "2026-07-18", "dateModified": "2026-07-18", "publisher": { "@type": "Organization", "name": "dailyaiworld.com" }, "mainEntityOfPage": { "@type": "WebPage", "@id": "https://dailyaiworld.com/workflows/superpowers-obra-agentic-skills-framework-2026" }, "about": { "@type": "Thing", "name": "Superpowers Agentic Skills Framework", "description": "A complete software development methodology for coding agents with 14 composable skills enforcing Brainstorm → Spec → Subagent-Driven Development → TDD → Code Review → Systematic Debugging." }, "keywords": "Superpowers agentic skills framework, obra superpowers, subagent-driven development, coding agent methodology, AI software development workflow, Claude Code plugin, agentic skills, SDLC for AI agents, Prime Radiant, RED-GREEN-REFACTOR TDD, autonomous coding agent" }, { "@type": "FAQPage", "mainEntity": [ { "@type": "Question", "name": "Is Superpowers free?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Superpowers is MIT-licensed open source. Installation from the Claude Code or Cursor marketplaces is free. Prime Radiant offers commercial support and managed spending for enterprise teams." } }, { "@type": "Question", "name": "Which coding agents does Superpowers support?", "acceptedAnswer": { "@type": "Answer", "text": "Superpowers ships plugins for Claude Code, Cursor, Codex CLI, OpenCode, Kimi Code, Antigravity, Factory Droid, and Pi. Gemini CLI was supported until Google EOLed it on June 18, 2026. GitHub Copilot CLI is supported via the Superpowers marketplace." } }, { "@type": "Question", "name": "Does Superpowers work with existing projects that already have tests?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Superpowers reads the existing test suite during the using-git-worktrees step. The test-driven-development skill adds new tests without modifying existing ones. Your testing framework is auto-detected." } }, { "@type": "Question", "name": "Can I disable specific skills?", "acceptedAnswer": { "@type": "Answer", "text": "Not directly, but you can override behavior by telling the agent explicitly. For permanent overrides, edit the skill files in your local clone — skills are plain Markdown in the skills/ directory." } }, { "@type": "Question", "name": "How do I update Superpowers?", "acceptedAnswer": { "@type": "Answer", "text": "Updates are automatic for Claude Code and Cursor plugin marketplace installations. For manual installations, pull latest from git. v6.1.1 was released July 2, 2026." } }, { "@type": "Question", "name": "What happens if a subagent gets stuck?", "acceptedAnswer": { "@type": "Answer", "text": "Subagents return DONE, DONE_WITH_CONCERNS, NEEDS_CONTEXT, or BLOCKED. NEEDS_CONTEXT prompts the controller for more info. BLOCKED triggers systematic-debugging. Fewer than 5% of tasks require human intervention." } }, { "@type": "Question", "name": "Does Superpowers work with monorepos?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. The using-git-worktrees skill handles monorepo structures correctly. The writing-plans skill scopes task file paths to the correct package directory. Subagent dispatch includes workspace context." } } ] }, { "@type": "HowTo", "name": "How to Install and Use Superpowers Agentic Skills Framework", "description": "Step-by-step guide to install Superpowers and build a feature using the agentic skills framework across Claude Code, Cursor, or Codex CLI.", "step": [ { "@type": "HowToStep", "position": 1, "name": "Install Superpowers on your platform", "text": "Install via Claude Code marketplace (/plugin install superpowers@claude-plugins-official), Cursor (/add-plugin superpowers), or git clone for Codex CLI and OpenCode." }, { "@type": "HowToStep", "position": 2, "name": "Start a new session", "text": "Close and reopen your agent fully — plugins load at session start. Describe a feature request to trigger the brainstorming skill." }, { "@type": "HowToStep", "position": 3, "name": "Review and approve the design", "text": "The brainstorming skill asks clarifying questions and produces a design document. Review each section and sign off." }, { "@type": "HowToStep", "position": 4, "name": "Watch autonomous execution", "text": "The agent creates a git worktree, writes an implementation plan, and dispatches subagents per task with TDD and two-stage review." }, { "@type": "HowToStep", "position": 5, "name": "Systematic debugging if needed", "text": "If tests fail, the systematic-debugging skill activates with 4-phase root cause analysis before fixing." }, { "@type": "HowToStep", "position": 6, "name": "Finish the development branch", "text": "When all tasks complete, the finishing-a-development-branch skill presents merge options — squash, merge, or discard." } ], "totalTime": "PT10M", "estimatedCost": { "@type": "MonetaryAmount", "value": "0", "currency": "USD" }, "supply": [ { "@type": "HowToSupply", "name": "Claude Code, Cursor, or Codex CLI" }, { "@type": "HowToSupply", "name": "Node.js 18+" }, { "@type": "HowToSupply", "name": "git 2.30+" } ], "tool": [ { "@type": "HowToTool", "name": "Superpowers framework" }, { "@type": "HowToTool", "name": "Claude Code" }, { "@type": "HowToTool", "name": "Cursor" }, { "@type": "HowToTool", "name": "Codex CLI" } ] } ] } JSONLD_DATA_END