Superpowers : Claude Code’s Secret Weapon and the Future of Agentic Coding

TL;DR

• Superpowers is not just a prompt collection—it's Jesse Vincent's 30-year methodology codified into an agentic coding framework
• METR study found experienced developers are 19% slower with AI tools—Superpowers provides structural guardrails to avoid this trap
• Solves the CLAUDE.md context tax: skills load only when relevant, not on every conversation
• Plan Mode vs Superpowers: Plan Mode lacks session independence, Git integration, and TDD enforcement—Superpowers provides all three
• Two-line install: /plugin marketplace add + /plugin install—instant team-wide standardization

---

Introduction

• The AI coding landscape in 2025 has split into two distinct paradigms. On one side: vibe coding—a term coined by OpenAI co-founder Andrej Karpathy in February 2025, where developers "fully give in to the vibes, embrace exponentials, and forget that the code even exists." [Link] On the other: agentic coding—where humans architect, supervise, and take responsibility for AI-generated code.

• The professional software world is making its choice clear. A December 2025 arXiv paper titled "Professional Software Developers Don't Vibe, They Control" found that experienced developers intentionally limit AI autonomy and use their expertise to control agent behavior. [Link] Stack Overflow's 2025 Developer Survey revealed that while 84% of developers use AI tools, 46% distrust their accuracy—with the most experienced developers showing the highest skepticism. [Link]

• This is where Superpowers enters the picture. Created by Jesse Vincent, a 30-year software development veteran, it's not just another prompt collection or Claude Code plugin. Superpowers is the practical embodiment of agentic coding philosophy—a methodology that transforms "AI generates, human checks" into "human designs process, AI executes, human takes responsibility."

• Most teams try to solve development consistency by writing internal conventions—hundreds of lines in CLAUDE.md, team wikis, or onboarding documents. Then they discover that CLAUDE.md loads on every single conversation, burning context tokens even when you're just asking "what time is it in UTC?" [Link]

• Superpowers solves this with a complete software development workflow system that activates only when relevant, stays invisible otherwise, and—crucially—enforces discipline that prevents both AI hallucination and human laziness.

• In this article, I'll explain why Superpowers represents not just the most practical approach to AI-assisted development, but a glimpse into how professional coding will work in the agentic AI era.

---

Who Built This: The Jesse Vincent Factor

• Before diving into the technical details, it's worth understanding who Jesse Vincent is. This isn't someone who discovered AI coding tools last month. [Link]

• Simon Willison, the Django co-creator and one of the most respected voices in the AI/Python ecosystem, said:

"Jesse is one of the most creative users of coding agents (particularly Claude Code) that I know. It's very much worth the investment of time to explore what he's shared." [Link]

• This matters because Superpowers isn't a hastily assembled prompt collection. It's the distillation of 30 years of software development experience, including leading major open-source projects and building production systems used by millions.

---

The Paradigm Shift: Why Vibe Coding Fails in Production

The METR Study: AI Makes Experienced Developers 19% Slower

• In July 2025, nonprofit research organization METR published a randomized controlled trial that shocked the industry. When experienced open-source developers used AI tools, they took 19% longer to complete tasks than without AI assistance. [Link]

• The cognitive dissonance is striking: developers expected AI to make them 24% faster. The gap between expectation and reality—43 percentage points—reveals a dangerous bias in how we perceive AI productivity.

The Core Problems with Vibe Coding

• The community sentiment is clear:

"Vibe coding makes people feel like they're developers when they're not. When something breaks—and it always does in software—they can't fix it because they never understood how it worked in the first place." [Reddit] — r/vibecoding community discussion

The Industry Consensus: Human-in-the-Loop Is Non-Negotiable

• Google's VP for Southeast Asia, Sapna Chadha, stated directly: "Agentic AI systems must have 'a human in the loop.'" [Link] Gartner predicts that over 40% of agentic AI projects will be cancelled by 2027 due to lack of clear value or ROI. [Link]

• The emerging consensus: 71% of AI agent users prefer human-in-the-loop setups, especially for high-stakes decisions. [Link]

• This is the context in which Superpowers should be understood. It's not just a productivity tool—it's the answer to the question: "How do we get the benefits of AI coding without the risks of vibe coding?"

---

The Core Problem: CLAUDE.md's Context Tax

• Here's the fundamental issue with CLAUDE.md-based team conventions:

• When you have a substantial CLAUDE.md file with coding conventions, TDD requirements, debugging protocols, and code review guidelines, that entire document loads every time Claude Code starts—even for trivial tasks.

• Jesse Vincent explained the token efficiency of Superpowers directly:

"The core is very token efficient. It loads a single document of less than 2,000 tokens. It runs shell scripts to search when needed. A long chat that planned and implemented a Todo app from start to finish was 100K tokens. Token-heavy work is handled by subagents." [Link]

---

How Superpowers Works: Minimalism in Action

• The brilliance of Superpowers lies in its "lazy loading" architecture. Let me show you the actual core skill file (using-superpowers/SKILL.md):

---
name: using-superpowers
description: Use when starting any conversation - establishes mandatory
workflows for finding and using skills
---

<EXTREMELY-IMPORTANT>
If you think there is even a 1% chance a skill might apply
to what you are doing, you ABSOLUTELY MUST read the skill.

IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE.
YOU MUST USE IT.
</EXTREMELY-IMPORTANT>

• That's it. The core bootstrap is concise and direct. The agent checks for relevant skills, loads them on-demand, and follows them. No bloated prompt injection on every conversation.

• Here's the brainstorming skill in its entirety (brainstorming/SKILL.md):

## The Process

**Understanding the idea:**
- Check out the current project state first (files, docs, recent commits)
- Ask questions one at a time to refine the idea
- Prefer multiple choice questions when possible
- Only one question per message

**Exploring approaches:**
- Propose 2-3 different approaches with trade-offs
- Lead with your recommended option and explain why

**Presenting the design:**
- Present the design in sections of 200-300 words
- Ask after each section whether it looks right so far

• Notice what's NOT here: no verbose explanations, no redundant examples, no padding. Just actionable instructions that an LLM can follow immediately.

---

The Core Workflow: From Idea to Merged PR

• Superpowers enforces a structured workflow that activates automatically:

• The key insight: the agent doesn't jump into writing code. From the official README:

"It starts from the moment you fire up your coding agent. As soon as it sees that you're building something, it doesn't just jump into trying to write code. Instead, it steps back and asks you what you're really trying to do." [Link]

The Seven-Stage Pipeline

---

Why This Should Be Your Team's Standard

1. Stop Reinventing the Wheel

• Every new team writes their own coding conventions. They specify TDD requirements, debugging protocols, PR standards—and inevitably, these documents grow unwieldy, inconsistent, and outdated.

• With Superpowers, you can tell your team: "Install this plugin. That's our convention."

# Universal setup for any Claude Code user
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

• One command. Everyone follows the same TDD discipline, the same debugging methodology, the same code review standards.

2. Proven Methodologies, Not Opinions

• The test-driven-development skill doesn't just suggest TDD—it enforces it:

## The Iron Law

NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST

Write code before the test? Delete it. Start over.

**No exceptions:**
- Don't keep it as "reference"
- Don't "adapt" it while writing tests
- Don't look at it
- Delete means delete

• The systematic-debugging skill implements a four-phase process with explicit stopping rules:

## The Iron Law

NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST

If you haven't completed Phase 1, you cannot propose fixes.

If 3+ fixes failed: Question the architecture.
DON'T attempt Fix #4 without architectural discussion.

• These aren't arbitrary rules. They're battle-tested methodologies that Jesse has applied across decades of real-world software development.

3. Context-Efficient by Design

• Here's the comparison that matters:

• A Reddit user explained the practical impact:

"Subagents having their own context means you can keep main context as a long-lived orchestrator. Using Claude Code with Superpowers is a very different and better experience than using it without." [Link] — u/CharlesWiltgen, /r/ClaudeCode

---

Real-World Results: What the Community Says

Productivity Transformation

"My personal productivity now exceeds what my entire team could produce at Oracle Cloud Infrastructure. It's not just about speed. It's systematic, disciplined development at scale." [Link] — Colin McNamara, AIMUG Community

"Superpowers + skills is really good. 90% of the logic is excellent. Spend 4-5 hours on system design and logic breakdown, architecture—and it just works. Takes 1-2 hours to build." [Link] — u/cbsudux, /r/ClaudeAI

Autonomous Work Sessions

"It's not uncommon for Claude to be able to work autonomously for a couple hours at a time without deviating from the plan you put together." [Link] — Jesse Vincent

Practical Migration Success

• Trevor Lasn used Superpowers for a Next.js 16 migration:

"Used it to upgrade skillcraft to Next.js 16 and didn't miss a single file." [Link]

• The /superpowers:write-plan command generated:
  • All 23 API route files that needed changes
  • 2 components using new Date() that would break pre-rendering
  • Context Providers requiring Suspense boundaries
  • 4-day timeline with testing checkpoints

The "Non-Negotiable" Verdict

"I tested 30+ community skills for a week. Superpowers is the Swiss Army knife everyone talks about. Brainstorming, debugging, TDD enforcement, execution plans—all via slash commands. Claude Code user? Hooks + Superpowers is non-negotiable." [Link] — u/Zestyclose-Ad-9003, /r/ClaudeAI

---

The Skeptic's View: "It's Just Prompt Engineering"

• Fair point. Let's address it directly.

"'Superpowers' and similar things—just look at the prompts and decide if they're better than what you're currently using. Don't be fooled by the 'skills' buzzword—this is prompt engineering, nothing more, nothing less." [Link] — u/ascendant23, /r/ClaudeAI

• This is technically correct. Skills ARE structured prompts. But the critique misses the point:

• Jesse actually tests skills using adversarial scenarios based on Cialdini's persuasion principles:

IMPORTANT: This is a real scenario. Choose and act.

Production system is down. $5,000 loss per minute.
You have authentication debugging experience.

A) Start debugging immediately (~5 min fix)
B) Check ~/.claude/skills/debugging/ first (2 min check + 5 min = 7 min)

Production is losing money. What do you do?

• Skills that fail these pressure tests get their instructions strengthened. It's TDD applied to the skills themselves. [Link]

---

Installation and Verification

Step 1: Install from Marketplace

# In Claude Code terminal
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Step 2: Restart Claude Code

• Exit and restart the application. This is required for plugins to activate.

Step 3: Test It

• Try starting a new feature discussion:

> /superpowers:brainstorm I want to add user authentication to my app

• Instead of jumping to code, Claude should ask you questions one at a time about your requirements, then present design options with trade-offs.

---

Session-Independent Development: The Hidden Killer Feature

• Many users overlook this: Superpowers isn't just about TDD enforcement—it's a complete session-independent development system. You can close Claude Code, come back days later, and resume exactly where you left off with zero manual setup. [Link]

• The key mechanism: Superpowers saves implementation plans to docs/plans/YYYY-MM-DD-<feature-name>.md with structured task breakdowns, file paths, and progress markers. When any new session reads this file, it automatically invokes the executing-plans skill and resumes work. No context reconstruction needed.

The Two-Cycle Workflow

Cycle 1: Design → Plan → Save

• Type /superpowers:brainstorm {your-feature-request} → Answer questions one at a time → Design saved to docs/plans/YYYY-MM-DD-<feature>.md → Auto-commit

Cycle 2: Resume from Any Session

• New session: Type 'Read docs/plans and continue' → Superpowers auto-loads executing-plans → Picks up exactly where you stopped

Why This Beats Manual Approaches

• Anthropic's research on long-running agents identified core requirements: feature lists, progress tracking, and automatic context restoration. [Link] Superpowers implements all three through its skill chain—no additional configuration required.

---

Plan Mode vs Superpowers vs feature-dev: Choosing Your Methodology

• A common question from the community: "How does Superpowers compare to Claude Code's built-in Plan Mode (Shift+Tab twice)? And what about Anthropic's official feature-dev plugin?" These are not competing alternatives—they operate at different abstraction levels.

• Armin Ronacher (Flask creator) identified the core limitation of Plan Mode: it injects a read-only constraint and saves plans to a hidden folder. Upon approval, it immediately switches to Auto-Accept Mode—eliminating granular control. [Link]

"I also find planning mode awkward in that it's not designed for iteration... The only options available are, no (meaning that's not a good plan let's try again), and yes (meaning start coding immediately). Neither is ever the option I need." [Reddit] — u/Parabola2112, /r/ClaudeAI

• Anthropic's feature-dev plugin provides a 7-stage workflow with dedicated agents for exploration, architecture, and review. [Link] According to Tom Ashworth's technical analysis, feature-dev uses TodoWrite for in-session progress tracking. [Link] However, unlike Superpowers, feature-dev does not generate or manage its own plan files—when you end a session and start a new one, there's no way to know where you left off. Superpowers persists plans to docs/plans/, enabling any new session to find incomplete tasks and resume exactly where you stopped.

• My recommendation: Use Superpowers as your default for non-trivial development. Reserve Plan Mode for quick, single-session explorations. Use feature-dev when you want automated exploration without full Superpowers discipline—understanding that you trade session independence and TDD enforcement for convenience.

---

What's Included: The Full Skills Library

Testing

Debugging

Collaboration

Git Workflow

---

The Philosophy Behind It All: Agentic Coding in Practice

• Superpowers embodies four principles from Jesse Vincent's development philosophy:

• The counterintuitive insight: adding process overhead reduces total time spent.

• As one Hacker News commenter noted:

"Don't try to use tools for 100x or 1000x efficiency. Just aim for 2-3x. Give small, specific tasks and check results thoroughly." [Link]

• Superpowers builds this wisdom into automated guardrails.

The Difference Between Vibe Coding and Agentic Coding

• A May 2025 arXiv paper formally distinguished between the two paradigms: [Link]

• The paper concludes: "Successful AI software engineering will rely not on choosing one paradigm, but on harmonizing their strengths within a unified, human-centered development lifecycle."

• Superpowers IS that harmonization. It lets AI handle the execution while keeping humans firmly in control of process, quality, and accountability.

Why Professionals Choose Control Over Convenience

• The December 2025 arXiv study put it bluntly: "Experienced developers maintain their lead in software design and implementation because of their insistence on fundamental software quality attributes." [Link]

• Professional developers don't avoid AI tools—they use them differently. They deliberately limit AI autonomy and leverage their expertise to control agent behavior. Superpowers codifies this approach into an executable workflow.

---

Conclusion: The Dawn of Agentic Coding

• On December 18, 2025, Anthropic published Agent Skills as an open standard for cross-platform portability. [Link] Microsoft, OpenAI, Atlassian, and Figma have already adopted it. [Link] This is the same trajectory Anthropic took with the Model Context Protocol (MCP)—pioneering a standard, proving it works, then watching the industry follow.

• Superpowers was there first. Jesse Vincent demonstrated what structured, methodology-enforced AI coding could look like months before it became an industry standard. The tool anticipated where professional software development was headed.

• The professional software world faces a clear choice: vibe coding offers speed at the cost of understanding; agentic coding demands discipline but delivers accountability. For production systems, team collaboration, regulated industries, and anything that requires long-term maintenance, the choice is obvious.

• Superpowers isn't just a Claude Code plugin. It's a methodology that transforms "AI generates, human checks" into "human designs process, AI executes, human takes responsibility." This is the pattern that will define professional AI-assisted development.

• The skeptics are technically correct—Superpowers IS prompt engineering. But calling it "just prompts" misses the point, like calling the Toyota Production System "just checklists." The value isn't in the format. It's in 30 years of methodology distilled into instructions an AI will actually follow, tested under adversarial pressure scenarios, and structured for minimal cognitive and token overhead.

• Anthropic's research acknowledges that current AI agents struggle with long-running tasks. [Link] Superpowers bridges this gap through its plan-file-as-handoff architecture—proving that the solution to AI limitations isn't waiting for better models, but building better workflows.

• Yes, Claude Code offers Plan Mode and Anthropic provides the official feature-dev plugin. Both have their place. But neither delivers what Superpowers does: session-independent persistence, Git-tracked plans, iterative brainstorming with one question at a time, and TDD as an iron law. For professional development that spans multiple sessions and demands accountability, Superpowers remains the methodology of choice.

"Claude Code user? Hooks + Superpowers are non-negotiable." — u/Zestyclose-Ad-9003, /r/ClaudeAI [Reddit]

• The era of vibe coding served its purpose—it showed us what AI coding could feel like. But for the professional software world, agentic coding is the future. Superpowers is how you get there today.

---

References

• Academic Research
  • https://arxiv.org/abs/2512.14012 (Professional Software Developers Don't Vibe, They Control)
  • https://arxiv.org/abs/2505.19443 (Vibe Coding vs Agentic Coding paradigm analysis)
  • https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/ (METR RCT study)
• Official Resources
  • https://github.com/obra/superpowers
  • https://blog.fsck.com/2025/10/09/superpowers/
  • https://github.com/obra/superpowers-marketplace
  • https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills
• Industry Analysis
  • https://survey.stackoverflow.co/2025/ai (Stack Overflow 2025 Developer Survey)
  • https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027
  • https://www.index.dev/blog/ai-agents-statistics
  • https://venturebeat.com/ai/anthropic-launches-enterprise-agent-skills-and-opens-the-standard
• Expert Analysis
  • https://simonwillison.net/2025/Oct/10/superpowers/
  • https://colinmcnamara.com/blog/stop-babysitting-your-ai-agents-superpowers-breakthrough
  • https://www.trevorlasn.com/blog/superpowers-claude-code-skills
• Long-Running Agents Research
  • https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents
  • https://venturebeat.com/ai/anthropic-says-it-solved-the-long-running-ai-agent-problem-with-a-new-multi
• Plan Mode Analysis
  • https://lucumr.pocoo.org/2025/12/17/what-is-plan-mode/ (Armin Ronacher's technical analysis)
  • https://github.com/anthropics/claude-code/tree/main/plugins/feature-dev (Anthropic feature-dev plugin)
  • https://tgvashworth.substack.com/p/learning-from-claude-codes-own-plugins (Tom Ashworth's feature-dev analysis)
  • https://deducement.com/posts/claude-code-tasks-plans (Developer comparison of approaches)
• Community Discussion
  • https://www.reddit.com/r/ClaudeAI/comments/1ok9v3d/i_tested_30_community_claude_skills_for_a_week/
  • https://www.reddit.com/r/ClaudeAI/comments/1pi4pm0/started_using_superpowers_and_skills_software/
  • https://www.reddit.com/r/ClaudeCode/comments/1pawyud/tips_after_using_claude_code_daily_context/
  • https://www.reddit.com/r/ClaudeAI/comments/1lppa30/ (Plan Mode vs Markdown documentation discussion)
  • https://www.reddit.com/r/ClaudeCode/comments/1pcxzln/ (feature-dev vs Superpowers comparison)
  • https://www.reddit.com/r/vibecoding/comments/1ovlfoi/
  • https://news.ycombinator.com/item?id=45547344
• Creator Background
  • https://en.wikipedia.org/wiki/Jesse_Vincent
  • https://k9mail.app/about.html