Skip to content
BSWEN
Blog

Opus 5.0 Ultracode + Workflow vs Superpower Plugin: What Claude Code Now Does Natively

Cowrie
Cowrie
Dev @ Bswen

Purpose

I have both the native Claude Code Ultracode plus Workflow features and the Superpower plugin installed. After Opus 5.0 rolled out, the two started to overlap badly. The same thread on r/ClaudeCode captured it: the author said native Ultracode plus Workflow now do “a lot of the things Superpowers can do,” and their /brainstorming usage dropped sharply because those tasks happen “naturally without me explicitly asking.”

That overlap costs me tokens, latency, and sometimes two competing plans for the same task. This post shows the feature map I use to collapse the overlap onto native Workflow and keep only the pieces native cannot do.

Environment

  • Claude Code on Opus 5.0
  • Native: Ultracode, Workflow (planning and multi-step orchestration)
  • Plugin: Superpower (slash commands for planning, brainstorming, TDD)

What happened?

Running both produced double planning. I would invoke a Superpower planner, then Workflow would also plan, and I ended up reconciling two plans instead of executing one. The cost was not theoretical — duplicated planning steps eat context, slow the turn, and sometimes disagree with each other.

The mental picture that fixed it for me is a Venn diagram:

Overlap between Superpower and native features
        ┌────────────────────────────┐
        │        Superpower          │
        │  ┌──────────────────────┐  │
        │  │  brainstorming       │──┼──► overlap: planning + orchestration
        │  │  multi-step planning  │  │     → move to native Ultracode + Workflow
        │  └──────────────────────┘  │
        │  ┌──────────────────────┐  │
        │  │  TDD red/green/refactor│ │     → Superpower-only sliver: process gate
        │  │  spec-driven scaffold │  │       → keep on plugin
        │  └──────────────────────┘  │
        └────────────────────────────┘
                  overlapped with
        ┌────────────────────────────┐
        │  Ultracode + Workflow      │
        │  planning, orchestration   │
        └────────────────────────────┘

The overlap (planning, brainstorming, multi-step orchestration) moves to native. The Superpower-only sliver (TDD gates and spec-driven scaffolding) stays.

How to solve it?

I map each Superpower subcommand to a native equivalent where one exists, and keep only the ones with no native peer.

Feature map template
Superpower feature           | Native now?    | Action
-----------------------------|----------------|------------------
/brainstorming               | Ultracode      | DROP (native)
multi-step task planning     | Workflow        | DROP (native)
TDD red/green/refactor gate  | none            | KEEP (discipline)
spec-driven scaffolding      | partial         | KEEP or thin shim

Then I want to detect when both are still active at the same time, because double planning is the failure mode I am trying to kill:

Detect double-planning: Superpower planner invoked while Workflow is active
ps aux | grep -i "workflow\|superpower" || true

The action column is the whole point. “DROP (native)” does not mean disable the plugin globally — it means stop reaching for that subcommand in my habits and let Workflow do it. “KEEP (discipline)” means the subcommand is a process gate the model would skip under pressure, so it earns the extra tokens.

The reason

I think the key reason to map per feature instead of dropping the plugin wholesale is that orchestration and discipline are different jobs. Ultracode and Workflow are great at the first: they sequence and plan. They are not gates. They do not force a failing test to be written before code, and they do not forbid new behavior in the refactor phase. TDD does.

So the rule I follow is:

  orchestration and planning  -> native wins
  enforced process / gates    -> plugin still wins

Mixing them up produces two mistakes I keep making: running Superpower’s planner on top of Workflow (double planning), or assuming Workflow enforces TDD just because it orchestrates long tasks. It orchestrates; it does not gate.

Summary

In this post, I mapped the Superpower plugin against native Ultracode and Workflow. The key point is orchestration and planning collapse onto native Workflow, while process enforcers like TDD stay on the plugin. I drop the overlap per feature rather than deleting the plugin wholesale, so I keep the discipline and stop paying for double planning.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: