Working with Superpowers 🦸🏻

Superpowers

Developer life was turned upside down over Holiday Season 2025. Many people switched from writing code manually to some Claude Code or another, equally capable coding agent. Code became something that was written for you. I already started at the end of last year relying more and more not only on recommendations or lookups of an LLM, but letting it write most of the code I produce.

As my practice with coding agents evolved I recognised two main issues:

1. What do I want?

This seems to be a very basic problem, but as a programmer, you are familiar with the evolution of a feature during programming. Knowing up-front what a feature should look like has a long malevolent history in programming (💧🍂 - you know). Agentic programming seems to lead back this path in some way, as of course you could ask the agent to change stuff over and over, but the speed of improvement is just not as fast anymore.

2. What did I prompt?

Even more basic - but if you are stuck in a prompt, review, prompt, review, clear context, prompt, review, approve… whatever kind of process, you get completely lost and find yourself doing stuff twice and forgetting even more about the what? from above.

Superpowers, my solution - for now

A friend of mine brought Superpowers to my attention. It is a plugin for Claude Code that enables a pretty simple development flow:

  ┌──────────────────────────────────────────────────┐
  │  0. brainstorming                                │
  │  Refines ideas, asks questions, saves design doc │
  └──────────────────────┬───────────────────────────┘
                         │
                         ▼
  ┌──────────────────────────────────────────────────┐
  │  1. using-git-worktrees                          │
  │  Isolated workspace, new branch, clean baseline  │
  └──────────────────────┬───────────────────────────┘
                         │
                         ▼
  ┌──────────────────────────────────────────────────┐
  │  2. writing-plans                                │
  │  Bite-sized tasks, exact paths, verification     │
  └──────────────────────┬───────────────────────────┘
                         │
                         ▼
  ┌──────────────────────────────────────────────────┐
  │  3. executing-plans                              │
  │  Subagent per task, two-stage review             │
  └──────────────────────┬───────────────────────────┘
                         │
                         ▼
  ┌──────────────────────────────────────────────────┐
  │  4. test-driven-development                      │
  │  RED → GREEN → REFACTOR → commit                 │
  └──────────────────────┬───────────────────────────┘
                         │
      ┌──────────────────┤
      │  ↻ review loop   │
      │                  ▼
      │  ┌─────────────────────────────────────────────────┐
      │  │  5. requesting-code-review                      │
      │  │  Reviews against plan, critical issues block    │
      │  └──────────────────────┬──────────────────────────┘
      │                         │
      └─────────────────────────┘  (if issues found → back to 3)
                         │
                         ▼
  ┌──────────────────────────────────────────────────┐
  │  6. finishing-a-development-branch               │
  │  Verify tests, merge/PR/keep/discard, cleanup    │
  └──────────────────────────────────────────────────┘

The brainstorming step forces you to refine your up-front picture of the feature, but to a great level of granularity. You will not be asked for colours etc. That is still cheap to change later, but workflows, UI patterns, and architecture decisions are supported. You even get UI previews to illustrate different options (via a local web server that spins up).

For bigger features this takes about 10 to 15 minutes, but saves you the time to think through everything for yourself, and the prompt feedback really helps finding the one thing you forget to take into account. All in all, it saves you a lot of time. And helps you focus (more on that in another post).

Writing plans

The heart of the plugin is the plan management. Of course you can use plan mode in Claude Code to let you write plans, but I always found them too much of a compromise between code snippets, architecture decisions, and specifications.

Superpowers uses a two-step planning process. Spec first, then implementation plan. The latter doesn't matter that much for me, but creates great results. The specs really change things for me: I review them, I update them, I understand them, I reuse them for other features. For me they have a big impact, especially on clarity, tracking, and quality.

Having text that describes your intentions in detail are crucial for successfully rolling out features and being able to maintain a AI written codebase over time. Only if intentions and plans are transparent, human control stays in place. Not over every single detail, but over key architectural and design decisions. Superpowers makes this step, that would need a lot of discipline and effort, something easy and sometimes even fun to do.

Will it stay forever?

Definitely not, as Claude Code integrates a lot of features, as AI keeps moving and improving, as tools vanish. But the pattern is useful for me, as it brings order to my chaos. Happy to hear your opinion: info@fbiberger.de