/superpowers vs /agent-skills: Faster Shipping or Safer Reasoning?

In my previous posts, I shared about Addy Osmani 's /agent-skills and its structured approach to agentic software development. While I found it to be an excellent framework, /superpowers has remained my daily driver for the past few months.

Instead of comparing them subjectively, I decided to compare them under identical conditions and measure engineering behaviour, not just the generated code.

Experiment

Both runs used the exact same setup.

Configuration

• IDE: Claude Code
• Model: Claude Sonnet 4.6
• Reasoning: Medium
• Permissions: All permissions granted
• Execution Mode: Sub-agentic
• Repository: Same codebase
• Prompt: Identical
• Execution: Independent worktrees with no shared context

The only variable was the skills.

/superpowers

• brainstorming-plan
• writing-plans
• test-driven-development
• verification-before-completion

/agent-skills

• spec-driven-development
• planning-and-task-breakdown
• test-driven-development
• incremental-implementation
• build

The feature itself wasn't trivial. It implemented complex logic and a TDD-first test suite for an existing production codebase.

Results

At first glance, the numbers look surprisingly similar. Both implementations completed successfully in roughly the same time. The interesting part wasn't the outcome, it was how they arrived there.

What the Metrics Actually Show

1. Planning Philosophy

This was the biggest behavioural difference.

/superpowers invested more time before writing code. It produced a single, dense implementation plan and resolved architectural questions; RPE granularity, projection rebuilding, and progression gates before touching the codebase.

/agent-skills took a lighter approach. It produced a formal specification followed by a task breakdown, then moved into implementation much earlier.

The result was a 4-minute faster first code change (8 vs 12 minutes) without affecting total execution time. The planning was not "better" or "worse" it was simply allocated differently.

2. Validation Strategy

This was probably the most interesting finding.

Both frameworks followed TDD. The difference came after implementation.

/agent-skills performed 7 validation passes, including a full 446-test suite verification at the end.

That broader validation exposed an unexpected issue involving MagicMock users inside the context builder—something the feature-specific tests never exercised.

/superpowers performed 5 targeted validation passes, focusing on the feature and adjacent functionality.

Both shipped working implementations. One optimized for broader regression confidence. The other optimized for validating only the affected surface area.

3. Test Coverage

Both implementations were disciplined about TDD.

• /superpowers added 7 tests
• /agent-skills added 8 tests

The additional test wasn't arbitrary. It specifically covered the defensive fallback introduced while fixing the context builder edge case discovered during the broader validation phase.

That extra test was a consequence of the workflow rather than simply writing "more tests."

4. Engineering Flow

Despite the planning differences, both frameworks required exactly one replan.

Interestingly, they both encountered the same shared issue in the test infrastructure; a missing session_started event in the fixture. Where they diverged was afterwards.

/agent-skills encountered an additional compatibility issue while running the entire test suite and adapted its implementation to match existing defensive patterns already present in the codebase.

/superpowers never encountered that scenario because its verification remained focused on the implementation scope.

Neither approach was incorrect.

One validated the feature while the other validated the feature and the surrounding ecosystem.

5. Token Efficiency

This metric was actually surprising.

Both frameworks recorded zero context rereads. Once the relevant files were understood, neither workflow revisited them during implementation.

That suggests both methodologies maintained sufficient working context throughout the task, making token efficiency effectively identical for this feature.

So Which One Wins?

For this specific task, I have to give the edge to /agent-skills.

Not because it wrote significantly better code. Not because it finished faster.

It didn't.

Both completed in roughly ~22 minutes.

The deciding factor was validation depth.

The additional build verification uncovered a genuine compatibility issue outside the immediate feature scope and the workflow naturally incorporated both the fix and the corresponding test.

That extra confidence came with essentially no increase in total execution time.

Does That Mean I'm Switching?

No.

This experiment actually reinforced why /superpowers has remained my daily workflow.

Most of the engineering work I do involves evolving production systems, exploring new ideas, and making architectural decisions that don't always have an existing pattern to follow.

In those situations, I value the heavier upfront reasoning that /superpowers encourages. Spending a few extra minutes resolving architectural trade-offs before implementation often pays for itself on larger or less-defined features.

However, this comparison also showed where /agent-skills shines.

When requirements are already well understood, architectural patterns exist and the objective is disciplined implementation with confidence, /agent-skills is exceptionally well suited.

Final Thoughts

The biggest takeaway wasn't that one framework is universally better.

It was seeing how much the engineering methodology changes the behaviour of the same underlying model.

Same Claude Code. Same Claude Sonnet 4.6. Same prompt. Same repository.

Yet the planning strategy, validation scope, testing behaviour, and implementation flow were noticeably different.

As AI-assisted software engineering matures, I think these workflow frameworks will become just as important as the models themselves.

Repositories

• Superpowers — https://github.com/obra/superpowers
• Agent Skills — https://github.com/addyosmani/agent-skills