Your AI Coding Agent Is Winging It. Superpowers Makes It Stop.

Plugins & Skills That Actually Matter | Part 1 of a Series. The ecosystem of plugins and skills for AI coding agents is growing fast. Most of it is noise. This series cuts through it. Each installment covers one plugin or skill that I have tested in real work and found worth keeping. No hype, no listicles, no "top 50" roundups. Just the tools that changed how I build software, and why they work.

There is a pattern most developers recognize by now. You open Claude Code, describe a feature, and within seconds the agent is writing files. It feels productive. It feels fast. Then twenty minutes later you realize it built the wrong thing, skipped the tests, and quietly introduced a bug in a file you did not even know it touched.

The speed was never the problem. The lack of process was.

This is the gap that Superpowers fills. Built by Jesse Vincent and the team at Prime Radiant, Superpowers is a free, open-source plugin that transforms Claude Code from a fast but reckless coder into something closer to a disciplined engineering team. It has over 137,000 installs, earned a spot on Anthropic's official plugin marketplace in January 2026, and works across Claude Code, Cursor, Codex, OpenCode, Copilot, and Gemini CLI.

But the interesting story is not the install count. It is the philosophy underneath it, and what it reveals about how we should all be working with coding agents.

The core insight: agents need process, not just prompts

Here is something worth sitting with. When a junior developer joins a team, nobody hands them a vague feature request and says "go build it." There is a process. Requirements get clarified. Architecture gets discussed. Someone reviews the plan before code gets written. Code gets reviewed after it is written. Tests are expected.

We do not extend this same courtesy to our AI agents. We give them vague prompts and hope for the best. When the output is wrong, we blame the model. But the model was never the bottleneck. The workflow was.

Superpowers encodes a complete software development methodology into a set of composable "skills" that activate automatically based on context. You do not memorize commands or write elaborate prompts. You just describe what you want to build, and the system enforces a structured process before a single line of code gets written.

The workflow has seven phases: brainstorm, isolate, plan, execute, test, review, finish. Each phase gates the next. You can't skip brainstorming. You can't skip tests. You can't declare victory without evidence.

This might sound slow. It isn't. It's the difference between driving fast on a road and driving fast off a cliff.

What actually happens when you use it

Let's say you tell Claude Code: "Build a user authentication system for this app."

Without Superpowers, Claude starts writing auth middleware immediately. Maybe it picks the right library, maybe not. Maybe it handles edge cases, maybe not. You won't know until something breaks in production.

With Superpowers, something different happens. The brainstorming skill activates. Instead of coding, Claude starts asking questions. What kind of authentication? OAuth, email and password, magic links? What are the security requirements? Do you need role-based access? What does the existing codebase look like?

It is not a questionnaire. It is a genuine back-and-forth that forces both you and the agent to think through what you are actually building. Once you align on the approach, Claude presents the design in small, digestible sections so you can actually read and respond to each one. (If you have ever tried to review a multi-page plan that Claude Code dumps on you in plan mode, you know how much better this is.)

After you approve the design, the plan-writing skill breaks the work into micro-tasks. Not "implement authentication" but "create the user schema migration" and "add bcrypt password hashing to the user model." Each task takes two to five minutes and includes exact file paths, code snippets, verification commands, and a pre-written commit message.

That plan lives as a markdown file in your repository. You can open it in your own editor, tweak it, reorder tasks, add comments. If your session dies halfway through, the checkboxes in that markdown file tell the next session exactly where to pick up.

Your progress is in a file, not trapped in a conversation that hit its token limit.

Then execution begins. Fresh subagents pick up each task, implement it, and submit it for a two-stage review: first for spec compliance, then for code quality. Critical issues block progress. And throughout every task, the TDD skill enforces red-green-refactor. Write a failing test. Watch it fail. Write minimal code. Watch it pass. Commit. If Claude tries to write code before tests, the skill forces it to delete the code and start over.

When everything is done, the branch-finishing skill verifies all tests pass, presents your options (merge, PR, keep working, discard), and cleans up the worktree.

The features nobody talks about

Most coverage of Superpowers focuses on the brainstorm-plan-execute loop. Fair enough, that is the headline feature. But the plugin has a layer of depth that rewards exploration.

Visual Brainstorming is a recent addition (Superpowers 5) that solves a problem every developer with a UI-heavy project has hit: Claude's ASCII art mockups are useless. Now, when the agent has something visual to discuss, it offers to spin up a local web server and render actual HTML mockups in your browser. You can review layouts, compare design options, and iterate on visual decisions before any implementation code exists. It is opt-in and token-intensive, but for frontend work it changes the entire conversation.

Smart Model Selection quietly saves significant money. When your plan has 30 micro-tasks with explicit instructions, many of them don't need Opus-level reasoning. Superpowers instructs the orchestrator to pick the cheapest model capable of each task. Implementation subagents often run on Haiku. The expensive model does the thinking. The cheap model does the typing.

The Double Shot Latte Hook addresses one of the most annoying aspects of long autonomous sessions: Claude stopping after every step to ask "should I continue?" The DSL hook delegates that decision to a separate Claude instance. If the work is proceeding normally, execution continues without interrupting you. If something unusual happens, it pauses. This is the difference between supervising a competent colleague and babysitting.

Failed Search Logging is a subtle productivity tool. Every time Claude searches for a skill that doesn't exist, the query gets logged to a JSONL file with timestamps and context. Over time, this log tells you exactly what skills your workflow needs but doesn't have yet. It turns your day-to-day frustrations into a prioritized skill-building backlog.

The Three-Fix Safeguard prevents one of AI coding's most wasteful patterns. When debugging, if Claude fails to fix an issue after three attempts, it stops guessing and triggers an architectural review instead. This single rule eliminates hours of the "try random changes and hope" loop that burns tokens and developer patience in equal measure.

The psychology of why skills actually work

There is a deeper reason Superpowers is effective, and it is not obvious from the feature list.

Jesse Vincent has talked publicly about discovering that research on LLM persuasion, specifically how authority framing, commitment structures, and social proof affect model behavior, directly applies to how skills should be written.

Superpowers skills don't just contain instructions. They are written using techniques that make the model reliably follow through rather than taking shortcuts.

This matters because the biggest failure mode of any structured prompt is the model deciding it knows better and skipping steps. "Sure, I'll follow the TDD process" followed by writing code before tests.

Superpowers skills are pressure-tested against this failure mode using the same TDD methodology they teach. You write a test scenario (a subagent in a realistic situation), watch the agent fail without the skill, write the skill, watch the agent comply, and then refine.

If you didn't watch an agent fail without the skill, you don't know if the skill teaches the right thing.

That principle alone is worth stealing for anyone building custom agent workflows.

There is also a subtle anti-pattern worth understanding. When a skill's description summarizes its workflow ("this skill does X, then Y, then Z"), Claude reads the description, decides it already knows what to do, and never loads the full skill content. It follows the summary instead, which inevitably misses important details.

The fix is counterintuitive: skill descriptions should only explain when to trigger, never what to do. The "what" lives in the skill body, which Claude only reads when it actually activates the skill.

This is the kind of insight that only emerges from months of watching agents fail in specific, repeatable ways.

What this means for how we work with agents

Superpowers is a Claude Code plugin, but the ideas it encodes are bigger than any single tool.

The first idea is that agents need methodology, not just capability. A more powerful model with no process will make bigger mistakes faster. A less powerful model with good process will often produce better outcomes. Superpowers proves this by running implementation tasks on Haiku and still producing high-quality, tested code.

The second idea is that plans should live in files, not in conversations. Conversations are ephemeral. They hit token limits. They can't be edited in your own editor. They can't survive a session crash. When your plan is a markdown file with checkboxes in your repo, it becomes a durable artifact that any session, human or agent, can pick up and continue.

The third idea is that verification must be mandatory, not aspirational. Every developer agrees that tests matter, code review matters, and you shouldn't ship without checking your work. But when an agent is writing code at high speed, the temptation to skip these steps is enormous. Superpowers removes the temptation by making them non-negotiable gates. No tests, no progress. No evidence, no completion. This is the kind of rigidity that produces reliability.

The fourth idea, and perhaps the most important one, is that the best agent tools teach agents how to think, not just what to do. Superpowers doesn't give Claude a library of code templates. It gives Claude a library of methodologies. Brainstorming is a methodology. TDD is a methodology. Four-phase root cause debugging is a methodology. The agent isn't copying solutions. It is applying systematic thinking to novel problems.

Getting started

Installation takes about thirty seconds:

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

Restart Claude Code, then just start working. Tell it what you want to build. You don't need to remember slash commands or trigger specific skills. The system reads the context and activates the right workflow automatically.

If you want to go deeper, create personal skills at ~/.config/superpowers/skills/ to encode your team's standards, your tech stack conventions, or your own development patterns. Personal skills shadow core skills, so you can customize behavior without forking the plugin.

The project is fully open-source (MIT license), completely free, and actively maintained. The community Discord is a good place to see what others are building with it.

The bigger picture

Six months ago, the conversation around AI coding tools was about speed. How fast can the agent write code? How many lines per minute?

That conversation is starting to shift. The developers getting the most value from AI agents aren't the ones pushing for raw speed. They are the ones who figured out that the real leverage is in process. Slowing down to brainstorm saves hours of rework. Writing a plan before writing code prevents architectural dead ends. Enforcing tests during implementation prevents bugs that would have taken days to diagnose.

Superpowers didn't invent any of these ideas. Senior engineers have known this for decades. What Superpowers did is package these ideas into a format that an AI agent can reliably execute, and then prove that the approach scales across thousands of real-world projects.

If you're still vibe-coding with raw Claude, at least vibe-code with a process. Your future self will thank you.

What's next in this series

Superpowers is the foundation, but it is not the only plugin worth your attention. The Claude Code ecosystem now has hundreds of plugins and skills, and a handful of them are genuinely excellent.

In upcoming installments, I will be covering plugins and skills that tackle specific problems: frontend design quality, webapp testing, MCP server integrations, context management, and more. Each piece will follow the same format: what the tool does, why it works, the features nobody talks about, and whether it is worth adding to your stack.

If you found this useful, follow along so you don't miss the next one. And if there is a plugin or skill you think deserves a deep look, drop it in the comments. The best recommendations always come from people who have used the tool in production, not from product pages.

---

Full disclosure: I am not sponsored by Superpowers, Jesse Vincent, Prime Radiant, or anyone else. Nobody asked me to write this. I just use the plugin daily and think it makes a genuine difference in how productive and reliable AI-assisted development can be. That is the whole reason this article, and this series, exists.

Superpowers is an open-source project by Jesse Vincent and Prime Radiant. It is not developed by Anthropic, though it is available on the official Claude plugins marketplace. GitHub: github.com/obra/superpowers.

This is Part 1 of Plugins & Skills That Actually Matter, a series on the tools reshaping AI-assisted development. Follow to catch the next installment.