If your Claude Code sessions still feel like you are babysitting a junior engineer who refuses to plan before writing, you are not alone. The honest version of working with coding agents in 2026 is that the agent is fast, capable, and structurally optimistic. It will skip the brainstorm, ignore the test, write the wrong abstraction, and ship the bug. The fix is not better prompting. The fix is a methodology layer on top of the agent.
That layer, for me, is obra/superpowers — Jesse Vincent's agentic skills framework for Claude Code. Approaching 180,000 GitHub stars as of May 2026, currently at v5.1.0. It is not a prompt template, not a slash command pack, not a vibe. It is a complete development methodology that triggers automatically based on context, enforces test-driven development, and breaks work into 2-5 minute tasks with explicit specifications.
I have been running Superpowers across every project I touch for the last six months — the personal site you are reading this on, my consulting work at Seahawk Media, the HostList directory, content production for the blog, and a fair amount of one-off design and tooling work. The honest take, after that much usage: it is the single biggest productivity change to my Claude Code workflow since the agent itself shipped. This post is the actual breakdown — what it is, how I use it for the five categories I work in, and the parts that still need work.
What Superpowers actually is, in 90 seconds
Superpowers ships as a marketplace plugin for Claude Code. One install command:
/plugin install superpowers@claude-plugins-official
After that, your Claude Code agent has access to a composable skills library. Each skill is a markdown file in the plugin directory that describes when and how to apply a specific workflow — TDD, parallel agent dispatch, code review, brainstorming, plan writing, debugging, and dozens more. Claude reads the skill metadata, recognises the situation in your conversation, and pulls the relevant skill into context automatically. You do not invoke skills manually most of the time. You describe the problem and Claude routes itself.
The mental model that finally made it click for me: it is what every senior engineering team's tribal knowledge used to be — the unwritten rules about how this team plans, tests, reviews, and ships — except now it is a portable library you can install on any project and the agent reads it before each task.
The seven-stage workflow that does the heavy lifting
Most of the value comes from one core workflow that Superpowers enforces by default. Stages, in order, with the skill name in brackets:
- Brainstorming — refine the idea through questions before any code is written. (brainstorming)
- Worktree isolation — every non-trivial task runs in a git worktree, not on your main branch. (using-git-worktrees)
- Plan writing — break the work into 2-5 minute discrete tasks with exact specifications, before touching code. (writing-plans)
- Subagent-driven development — fresh subagents per task with two-stage review, so the main agent stays oriented and the worker agents stay focused. (subagent-driven-development)
- Test-driven development — RED-GREEN-REFACTOR is mandatory, not optional. (test-driven-development)
- Code review — severity-based review with explicit blocking on critical issues. (requesting-code-review)
- Branch finishing — structured merge or PR decision when the work is complete. (finishing-a-development-branch)
In practice you do not run through all seven manually for a 10-line edit. The framework decides what stages apply based on the task's complexity, and skips the ones that would be overkill. A typo fix runs the planning skill briefly and skips TDD. A new feature on a 25,000-page directory runs the full sequence.
How I use Superpowers for blog writing and SEO
This is the use case nobody talks about because the framework was built for code, but content production at scale is the same problem in disguise: structured planning, parallel execution, and review before publish. The five concrete patterns I use:
1. Brainstorming a post before drafting
Every post starts with the brainstorming skill. I describe the topic in one or two lines and Claude runs an actual interrogation: who reads this, what do they already know, what is the contrarian angle, what specific signals from my own work belong in the draft. Most posts that used to take a 90-minute outline session now take 15 minutes of guided questions and produce a tighter brief.
2. Plan-writing for cluster posts
Multi-post content clusters (the HIPAA cluster I shipped this week is the most recent example) use the writing-plans skill. I describe the parent topic, Claude plans the 3-5 supporting posts with their angles, internal-link structure, and target keywords. The plan goes into a markdown file in the project. Each post becomes a discrete 30-45 minute task. The cluster ships in a day rather than a fortnight.
3. Parallel agent dispatch for keyword research
The dispatching-parallel-agents skill is what makes large SEO research projects feasible. For a competitor analysis I need DataForSEO SERPs for 8 keywords, content audits for 4 ranking competitors, and AI Overview citation checks for the parent topic. Three parallel agents go out, each comes back with structured findings, the main agent synthesises. What used to be a half-day of manual SERP toggling is now 10 minutes of structured analysis.
4. Test-driven content quality gates
Sounds counterintuitive but it works: my content pipeline has a test suite. Word count, Flesch-Kincaid score, meta description length 140-155, banned-words check, internal link minimum, schema validity, hreflang completeness. Every draft runs through the gate. Superpowers' TDD skill enforces it — if a post fails the gate, the draft does not ship until the failure is addressed. RED-GREEN-REFACTOR for prose.
5. Worktree isolation for site-wide content rewrites
When I rewrote 17 hero copies this month for TRIBE v2 alignment, the worktree skill kept the rewrite isolated from the main branch until the whole batch was complete and reviewed. No half-finished hero copy on production. The skill is so habituated now that I notice when other projects do not have it.
How I use Superpowers for design work
Design through Claude Code is a different problem shape — Figma is not in the agent's hands, but everything around it is: design tokens, component specs, copy, spacing, accessibility audits, slide decks. Three patterns I rely on:
1. Token architecture from a brand brief
Brainstorming + writing-plans on a brand brief produces a complete design-token spec — primitive layer, semantic layer, component layer — in one session. Claude routes through the design skill (when it is in scope) and the writing-plans skill in parallel. The output is CSS variables ready for the codebase, not a Figma file someone has to translate later.
2. Component spec generation
Receiving-code-review and dispatching-parallel-agents handle component spec work. I describe a component (a pricing card, a service hub block, a comparison table) and Claude writes the full spec — props, variants, states, accessibility notes — that an engineer or another agent can implement. The spec is reviewed by a parallel agent before it is handed off.
3. Slide-deck production
My presentation work all goes through Superpowers now. Brainstorming the narrative, writing-plans for the slide structure, parallel agents for chart generation and copy refinement. A 25-slide deck that used to be a day's work is two hours of guided session — and the slides ship in HTML with Chart.js, not in a binary that someone has to re-create later.
How I use Superpowers for web development
This is the original use case and where the framework's depth shows. Two examples from this week:
The WordPress Stack Advisor tool
I built the WordPress Stack Advisor — a free tool that takes a URL, fetches the site, detects the CMS and 30+ plugins, and returns a Claude-generated stack recommendation — in roughly 8 working hours of session time. The brainstorming skill produced the input/output spec and the system prompt approach. Writing-plans broke the build into discrete tasks: detection module, Claude integration, UI page, CSP wiring, smoke test. Subagent-driven development delivered each task in isolation with a fresh agent context, while the main agent kept the architectural picture. TDD on the detection module caught two regex bugs before they landed in production. The whole thing went out as a clean PR with a real commit history.
The HIPAA blog cluster
Three articles, fully cross-linked, with hero images, schema markup, and internal-link structure to the existing HIPAA-compliant Next.js post. Brainstorming surfaced the gap analysis (what AccountableHQ doesn't cover, where Reddit threads are out of date). Writing-plans structured the cluster: parent post upgrade, two new supporting posts (Supabase + Vercel BAA, AI HIPAA), shared internal-link skeleton. Parallel agents pulled DataForSEO SERPs and live web research on Vercel, Supabase, OpenAI, Anthropic, Azure HIPAA pricing. Subagent-driven development produced each post. The cluster shipped in one focused session.
How I use Superpowers for personal projects
The framework adapts surprisingly well to non-work problems. Three honest examples:
Travel research
Family holiday planning: brainstorming for the actual brief (what the kids will tolerate, what budget is real, what dates work), parallel agents for restaurant research, accommodation analysis, and itinerary scoring. The output is a one-page plan with citations to actual sources, not a generic listicle. The brainstorming skill alone is worth the install — it forces the conversation that most family planning skips.
Finance and decisions
Bigger personal financial decisions (mortgage refinance, a property purchase, a car) get the same plan-writing treatment as commercial work. The output is a structured comparison with the trade-offs explicit, not a vibes-based recommendation. The receiving-code-review skill — adapted to non-code reviews — catches the missing analyses I would have skipped.
Content for my own writing practice
Personal essays (the off-screen blog, the cafe writing, the tech reflections) all go through brainstorming first. Most of my best personal writing started as a 30-minute Superpowers conversation that surfaced an angle I would not have written from on my own. The skill acts like a sympathetic editor who will not let you write the boring version.
Where Superpowers does not yet pay off
- Trivial edits — one-line CSS changes, a single typo fix, a one-paragraph copy tweak. Superpowers' overhead becomes friction here. Disable the workflow stages or invoke the agent directly.
- Pure exploration — when you genuinely do not know what you are building yet and need to fumble through five quick prototypes. The plan-writing skill tries to structure too early; manual mode is faster.
- Time-pressure debugging — production is down, you have 10 minutes, the framework's plan-first reflex is the wrong reflex. Use the systematic-debugging skill if at all and skip the seven-stage workflow.
- Other people on the team without the framework. If your collaborator is on raw Claude Code and you are on Superpowers, the artefacts (plan files, worktree branches, structured commits) confuse the workflow rather than clarifying it. Either everyone runs it or nobody does.
Installing it and the first 24 hours
If you are on Claude Code, the install is one command:
/plugin install superpowers@claude-plugins-official
After install, the skills load automatically based on context. You do not need to memorise them — Claude routes itself. The most useful first 24 hours is to deliberately pick a real project (not a toy) and let the framework run. The seven-stage workflow on a real feature is what teaches you the cadence. Reading the README is not enough; the value compounds with use.
Two configuration tips that took me a week to learn the hard way: keep the worktree directory on a fast SSD (the worktree skill creates a lot of them), and add the skill plugin to your dotfiles so it travels across machines. There is nothing worse than starting a session on a new laptop and missing the workflow you have built habits around.
FAQ
Is Superpowers free?
Yes. The framework is open source under a permissive licence. The install is via the official Claude Code plugin marketplace at no cost. You still pay Anthropic for Claude Code usage at standard rates — Superpowers does not change that, but it tends to use more tokens per task because it runs richer plans and parallel agents. In practice that has been a positive trade for me: more tokens, fewer wasted sessions.
Does it replace Claude Code's built-in skills?
No. Superpowers is additive. Claude Code's own skill system (project-level skills, marketplace plugins) still works the same way. Superpowers slots in alongside as a methodology layer — the seven-stage workflow, the TDD enforcement, the parallel agent dispatch — that orchestrates how the underlying skills get used.
Will it work for non-coding tasks?
Yes, with caveats. The framework was built for software development, and the TDD and code-review skills are obviously code-shaped. But the brainstorming, writing-plans, dispatching-parallel-agents, and worktree skills generalise cleanly to content production, design, research, and personal projects. About 40% of my Superpowers usage now is non-code, and the productivity gain is comparable.
How does it compare to other agentic frameworks?
The closest comparisons are Cursor's agent mode, Cline, and Aider's planning workflows. Superpowers' differentiator is the depth of the skill library and the TDD enforcement. Cursor and Cline are excellent at the IDE level; Superpowers operates at the methodology level. They are complementary, not competitive — I run Superpowers inside Claude Code while keeping Cursor for live editing on smaller tasks.
What is the catch?
Two real ones. First, you have to actually use it; reading the README and not running the workflow leaves you with the same Claude Code you had before. Second, the framework's plan-first reflex is wrong for some tasks (pure exploration, urgent debugging). Knowing when to disable the workflow is part of the learning curve. After about two weeks of regular use, the cadence becomes habituated and you stop thinking about which skills are firing.
Related reading
Claude Code for WordPress: the workflow my agency runs in 2026 — the broader Claude Code agency workflow, with Superpowers slotting in as the methodology layer.
WordPress Stack Advisor — a working tool I built using Superpowers in roughly 8 hours of session time, end to end.
WordPress alternatives 2026: when no-code is not the answer — the cluster post that the Superpowers writing-plans + parallel-research workflow produced as a single session.
The agent is fast. The agent is capable. The agent is structurally optimistic. The methodology is what stops the optimism from shipping.
If you want to talk about how to embed Superpowers into a real engineering or content team — the people problems, the workflow design, the cost economics — book a 30-minute call. I run this on every project at Seahawk Media now and the patterns generalise across team sizes.