I Tested Anthropic Superpowers for 3 Weeks: Here's What Actually Works
I've been writing code for 10 years. Last month Claude Code did something that made me feel like a beginner again.
Not because it was smarter than me. Because it was faster, more consistent, and it used a system I had never seen before. Anthropic calls it the Skills system. The community started calling it "superpowers." After three weeks of daily use on my project saas.pet, I have opinions.
Here's what I actually found.
What Is the Superpowers Skill System?
In late 2025, Anthropic added a Skills layer to Claude Code. The idea is simple. Instead of writing a long prompt every time you start a task, you define a reusable "skill" once. Claude reads it at the start of a session. It shapes how the model approaches every task in that project.
Think of it like a `.cursorrules` file, but with more structure and tighter integration into the agent loop.
A skill is a markdown file. It lives in a `/mnt/skills/` directory. It has a name, a description, and a body that explains constraints, patterns, and preferences. Claude reads it before it touches your code.
The difference from a normal system prompt is scope and persistence. A prompt changes per session. A skill changes per project, and it stacks. You can have a skill for your database patterns, another for your UI components, another for your testing approach.
| Feature | Normal Prompt | Superpowers Skill |
|---|
|---|---|---|
| Scope | Single session | Entire project |
|---|---|---|
| Reusability | Copy-paste manually | Loaded automatically |
| Stackability | Limited | Multiple skills, different concerns |
| Maintenance | You remember to update it | Lives in version control |
| Team sharing | Slack DM | Git commit |
The architecture shift is real. You're moving from "tell Claude what to do each time" to "teach Claude how you work, once."
What I Actually Built With It
I run saas.pet, a directory that tracks and ranks AI coding tools. One of the things I kept doing manually was writing review page summaries. Each tool gets a short description, a use-case breakdown, and a comparison note.
Before skills, that took me about 30 minutes per tool. I was doing the same cognitive work every time. Open the tool's docs, extract the key claims, format it in my voice, add internal structure.
I wrote a skill for this. It defined my editorial style, the fields I care about, the tone I use, and the patterns I avoid. I tested it on five tools I already knew well.
The result: around 5 minutes per page. The time savings were real. But that wasn't the part that surprised me.
The part that surprised me was the consistency. The outputs for tool five looked structurally identical to tool one. Same field order. Same hedging language when a claim was uncertain. Same internal linking logic.
When I do this manually, I drift. I forget to include something on page three that I included on page one. The skill doesn't drift.
That consistency is the actual value. Not the speed.
The Mistakes I Made First
My first three skills were bad. Not slightly bad. Useless.
The first one was too vague. I wrote something like "write in a professional but approachable tone." Claude already does that. I gave it nothing new to work with.
The second one was too long. I tried to cover everything at once. Tone, formatting, linking strategy, data sources, output structure. Claude read it and then basically ignored most of it, defaulting to generic behavior because the signal was buried in noise.
The third one had conflicting instructions. I said "be concise" in one section and "always include a detailed comparison table" in another. Claude picked one and dropped the other.
The fourth one worked. Here's what changed:
- One skill, one concern. My working skill only covers review page structure.
- Concrete over abstract. "Use bullet points for pros/cons" beats "be organized."
- Examples over instructions. I included one sample output block. That alone was worth more than 200 words of description.
- Explicit triggers. I told it exactly when to apply the skill and when to ignore it.
My advice: start with the single most repetitive task in your workflow. Write a skill for that one thing. Get it working. Then, and only then, write a second one.
How This Compares to Cursor and Copilot
Cursor has a similar feature in its Background Agent and `.cursorrules` system. The philosophy is close. The implementation is different. Cursor bakes it into the IDE layer. Claude Code treats it as a file system artifact. For team workflows, the file system approach is easier to version and share.
Copilot is still mostly in completion mode. It suggests the next line. It doesn't have a persistent skill or rule system at the project level. Microsoft is clearly moving toward agentic features, but as of mid-2026, it hasn't shipped anything that competes directly with what skills do.
My honest take: the skill system is the right abstraction. Writing skills feels a lot like writing documentation that actually gets read. That's a good problem to solve.
But it's early. I hit edge cases where Claude partially ignored a skill. I hit sessions where it loaded the wrong one. The tooling around skill management is still rough. I'd give it 6 to 12 months before it's smooth enough that most teams can adopt it without friction.
If you want to track how Claude Code stacks up against Cursor, Copilot, and the rest of the field, I keep a live ranking at saas.pet/find/?q=claude+code. It updates as tools ship new features.
How to Start
If you want to try this today, here's the shortest path.
Step 1. Pick one task you do repeatedly in Claude Code. Not ten tasks. One.
Step 2. Write a skill file. Keep it under 300 words. Include one concrete example of the output you want. Save it to your project's skill directory.
Step 3. Run it on three real tasks before you judge it. The first run often feels off. By the third run you'll know whether the skill is helping or just adding friction.
The Anthropic documentation covers the technical setup. The setup is not the hard part. The hard part is writing a skill that actually changes Claude's behavior in a useful direction. That takes iteration.
Final Thought
The skills system is the most structurally interesting thing Anthropic has shipped for developers in a while. It's not magic. It's a discipline. You have to think carefully about what you want Claude to do consistently, and then write that down in a way it can use.
That process of writing the skill made me realize how sloppy my own mental models were. Getting Claude to be consistent forced me to be consistent first.
If you want to see how the broader AI coding tool landscape is shifting, I track 25+ tools at saas.pet, including rankings for AI code editors. Rankings update as things change. Worth a bookmark if this space matters to your work.
Alex is the founder of [saas.pet](https://saas.pet), a directory for AI-powered developer tools.
I've been testing AI tools for 2+ years. I run saas.pet as a side project. I buy every subscription I review. No vendor pitches, no free accounts.