Skill Recommendation: Add a Complete Workflow for Coding Agents with Superpowers
Introduces the project `obra/superpowers`, a skill/plugin for coding agents, and explains how it turns requirements clarification, specification design, implementation planning, and TDD into reusable AI workflows.
1. Why I’m Looking at Superpowers
Lately I’ve been looking at Claude Skill, Codex Skill, MCP, and agent workflows, and I found an interesting project: obra/superpowers.
It is not just a collection of prompts, nor an ordinary scaffold. It packages a software development methodology into a Skill/Plugin that coding agents can call automatically. Its core idea is: do not let a coding agent jump straight into writing code; first clarify goals, organize specifications, create an implementation plan, and then enter a more controlled development process.
That is worth studying. Because many people using Claude Code, Codex, or Cursor face the same problem: the model’s issue is not that it cannot write code, but that it is too ready to “start coding right away.” If requirements are unclear, boundaries are undefined, and tests are not prepared, large portions of code get modified before things are properly understood.
Superpowers tries to solve exactly this problem.
2. What It Basically Is
According to the project README, Superpowers is a software development methodology for coding agents, built on a set of composable Skills and initialization instructions to ensure agents use these processes at the right time.
In other words, it gives AI coding assistants a set of “engineering discipline.”
Its supported scenarios are not limited to Claude Code. Public materials show it also supports Codex CLI, Codex App, Gemini CLI, OpenCode, Cursor, GitHub Copilot CLI, and other coding agents or development tools with installation options.
That means it focuses not on a single model, but on “how an agent should work when writing code.”
3. What Role Skills Play Here
(If you still are not clear on what a Skill is, check out “Skill Primer: From Prompts to Reusable AI Workflows”.)
Anthropic defines Agent Skills this way: a Skill is modular capability that extends Claude. Each Skill packages instructions, metadata, and optional scripts, templates, and other resources; Claude then automatically uses the Skill when relevant tasks arise.
OpenAI describes Skills similarly: a Skill is a reusable, shareable workflow that tells ChatGPT or Codex how to complete a certain type of task more reliably; it can include instructions, examples, and code.
So what I understand by Skill is more than “a longer prompt.”
More precisely, it is like a small workflow package:
my-skill/
├── SKILL.md
├── scripts/
├── references/
└── assets/In this structure:
SKILL.mdis typically the entry file, containing the skill description, trigger conditions, and execution rules.scripts/can hold executable scripts for repetitive, precise, or programmatic tasks.references/can hold reference docs, specs, and knowledge bases.assets/can hold templates, examples, and resource files.
Directory details vary by platform, but the overall idea is the same: extract “how to do the work” from a one-off conversation and turn it into a reusable, installable, and composable unit.
That is where the value of Superpowers lies. It does not just tell the model “please write carefully.” Instead, it encodes a process—“clarify first, then design, then plan, then implement, then validate”—so the agent can repeatedly follow it.
4. Its Workflow Characteristics
From the README, the Superpowers workflow can be broadly divided into several steps.
1. Clarify the Goal First
When the agent sees that the user wants to build something, it does not immediately start coding. It steps back first and asks follow-up questions to find out what the user truly wants.
This may look simple, but it is critical.
Many AI programming incidents happen because requirements were never finalized. The model fills in business logic based on assumptions, and the resulting code looks complete but is actually off target from what the user really wanted.
2. Produce Readable Specifications
After requirements are clarified, the agent presents the specifications in chunks, so the user can actually read and confirm them.
This is more practical than generating one long requirements document at once. If it is too long, users often do not read it carefully; if it is too short, boundary conditions can easily be missed.
3. Create an Implementation Plan
After the design is confirmed, the agent organizes an implementation plan. The project README emphasizes that this plan should be clear enough that even a junior engineer with little context can execute it.
That standard is insightful.
A truly good AI workflow is not about the model “feeling its way through” a task. It is about decomposing, checking, handing off, and doing retrospectives.
4. Emphasize TDD, YAGNI, and DRY
Superpowers explicitly emphasizes test-driven development (TDD), YAGNI, and DRY.
What those mean:
TDD: write tests first, then implement features, and at least maintain a verifiable feedback loop;YAGNI: avoid implementing features that are not needed yet;DRY: do not repeat the same logic over and over.
This is especially important for agent-based coding. The model is very good at “adding a lot,” but not always good at deciding what should not be written right now.
5. What It Inspired Me About Writing Skills
The most important thing I learned from Superpowers is not one specific command, but how it positions Skill.
Many people write a Skill like this:
You are a senior engineer. Please analyze the requirements seriously and write high-quality code.That is useful, but not enough.
A better Skill should tell the agent:
When this process should be started;
What information should be collected first;
Under what conditions confirmation is required;
How to form specifications;
How to break tasks down;
How to validate results;
What to avoid doing.In other words, a Skill is not just “role assignment”; it is an “operating standard.”
For my AI workflow, this is important. For example, when I generate website articles, collect case studies for name analysis, organize metaphysics text, or crawl AI news, these can all be broken into a similar structure:
Input constraints → Information verification → Structure organization → Content generation → Self-check rules → Output filesIf these rules are written in prompts every time, they become long and easy to miss. Distilling them into a Skill is much closer to a reusable production workflow.
6. Difference Between Skill and MCP
Let me also clarify the difference between Skill and MCP.
MCP, the Model Context Protocol, is officially described as an open standard for connecting AI applications to external systems. Through MCP, AI apps like Claude and ChatGPT can connect to local files, databases, search tools, calculators, or other workflows.
In simple terms:
A Skill is more about “how to do the work”;
MCP is more about “what tools and data can be connected”.The two can be used together.
For example, an “article publishing Skill” can prescribe article checks, frontmatter, SEO description, and reference-formatting rules, while MCP can allow the agent to access GitHub, the filesystem, databases, or search services. Skill manages process, MCP manages connection capabilities.
That is also why I increasingly value Skills: MCP solves the tool-connection problem, while Skill solves the workflow problem. With tools but no method, the agent still tends to wander; with method but no tools, the agent cannot execute reliably.
7. Good Inspiration to Borrow, Not to Idolize
Superpowers is very suitable for learning from, but it should not be idolized.
It is more like an experienced developer packaging their working habits, engineering judgment, and collaboration process into an executable standard an agent can follow. For personal projects, its value is in reminding us that AI programming is not “making the model write code as quickly as possible,” but “moving tasks forward through a reliable process.”
If you are just writing a tiny script, you may not need such a heavy workflow. But for long-term maintained websites, automation systems, content-generation pipelines, or database projects, a Skill mindset like this is genuinely valuable.
If I continue writing my own Skills, I will lean even more toward this direction: less vague slogans, more trigger conditions, input/output definitions, checklists, directory structures, command constraints, and failure handling.
That is where Skills become truly useful.
FAQ
What is Superpowers?
obra/superpowers is a skill/plugin project for coding agents that packages software development methodologies such as requirement clarification, specification design, implementation planning, and TDD into reusable workflows that a coding agent can call automatically. Its core idea is “don’t let the agent start writing code immediately.”
Can Superpowers only be used with Claude Code?
No. Public materials show it also provides installation options for Codex CLI, Codex App, Gemini CLI, OpenCode, Cursor, and GitHub Copilot CLI, among other coding agents and development tools. The focus is “how an agent should work when writing code,” not a single model.
What is the difference between Skill and MCP?
A Skill is more like “how to do the work” (process and method), while MCP (Model Context Protocol) is more like “what tools and data can be connected” (external connectivity). They can be combined: Skill manages process, MCP manages connection capability.
What is the core workflow of Superpowers?
It is generally: clarify the goal first → produce user-readable and confirmable specifications → create a clear implementation plan that even a junior engineer can follow → emphasize TDD, YAGNI, and DRY so tasks can be decomposed, checked, and reviewed.
References
Share