AI coding agents have become remarkably capable, but getting consistently good results requires more than writing a prompt and letting them loose on your codebase.
This is where AI agent skills come in. They provide structured workflows for understanding requirements, writing specifications, planning implementation, generating code, and reviewing results.
Two of the most popular skill frameworks on GitHub are Superpowers and Matt Pocock’s Skills. At the time of my comparison, Superpowers had around 300k stars, with Matt Pocock’s collection close behind at around 290k.
I’ve spent time using both, and both are excellent.
They solve essentially the same problem but approach it differently. After working with both, I’ve developed some preferences, while also appreciating several things each framework does particularly well.
Here’s how they compare based on my experience.
Matt Pocock’s Skills: A Structured, Question-Driven Workflow
Matt Pocock’s skills follow a structured development process:
Grill With Docs → To Spec → To Tickets → Implement / Implement Spec
The usual feature workflow looks like this. These are composable skills: the arrows show the order you invoke them, rather than an automatic handoff between every stage.
Grill With Docs: Understanding What You Want
You start with an idea, perhaps a new application or a feature for an existing project. A single sentence is enough.
Grill With Docs then starts asking clarifying questions. Lots of them.
This is one of its greatest strengths. The agent digs into requirements, challenges assumptions, explores edge cases, and makes you think about things you may have overlooked.
But it can also become annoying.
I remember giving it a fairly detailed specification that I’d already spent considerable time writing. I expected it to have most of the information it needed.
Instead, it started asking even more questions, drilling into finer details. But that’s also the point of the skill.
Even a well-written specification can contain ambiguities and unexplored edge cases. Grill Me is exceptionally good at finding them.
If you want to move quickly into implementation, this can feel excessive. But if you want to deeply understand a problem before writing code, Grill Me is one of the best skills I’ve used.
From Specification to Implementation
Once the questioning is complete, the workflow progresses through three skills:
- To Spec synthesizes the conversation into a specification and publishes it to the configured issue tracker.
- To Tickets breaks that specification into smaller, independently implementable tasks.
- Implement takes a ticket, writes the code, and invokes a review process to check the implementation against the specification.
It’s a disciplined process that works well.
One frustration I had with earlier versions was that I needed to invoke Implement separately for every ticket. Finish one, start the next, and repeat.
The current collection also provides Implement Spec for a whole specification. It runs ready tickets through implementer subagents, merges their work into an integration branch, and reviews the combined result, allowing the agent to work independently for longer.
Wayfinder: Discovery for Larger Projects
Wayfinder is an alternative to Grill Me, designed for projects too large to explore effectively in a single conversation.
Instead of one enormous questioning session, it breaks discovery into multiple focused tasks. A large project might generate five or ten separate grilling tickets, each exploring a specific area.
But Wayfinder goes further than that.
It can create research tasks, where the agent independently investigates existing solutions, relevant technologies, and prior art on the internet.
It also supports prototyping. Rather than endlessly discussing a design, the agent can quickly build something and present alternatives for review.
I particularly like this approach. Sometimes seeing a prototype communicates more than answering dozens of questions. You might even discover an approach better than what you originally imagined.
For large projects, the combination of focused exploration, independent research, and prototyping makes Wayfinder especially interesting.
Glossary and Architectural Decision Records
Matt Pocock’s skills generate certain documents that are deeply integrated throughout the workflow.
Glossary generation captures important domain-specific terminology in Markdown files, helping the agent maintain consistent understanding across future sessions.
Architectural Decision Records (ADRs) preserve significant architectural decisions and their reasoning. If a decision is later reversed or partially superseded, that history can also be recorded.
Both help preserve knowledge that might otherwise disappear between AI sessions.
Improve Codebase Architecture
Another standout is Improve Codebase Architecture.
It analyses an existing codebase and generates a nicely formatted HTML report with architectural observations and recommendations.
You can review the suggestions, select the ones you agree with, and ask the agent to implement those improvements.
I like that it encourages deliberate architectural changes rather than immediately refactoring everything.
PR Writing
There’s also a newer skill for generating pull request descriptions, adapted from another developer’s Show Me skill.
It’s a relatively small addition, but a practical one that saves time during everyday development.
Superpowers: An Agentic Skills Framework for Software Development
Superpowers follows a similar overall process:
Brainstorming → Writing Specs → Writing Plans → Implementation and Review → Finishing
The usual flow includes design approval, an isolated workspace, and a choice of execution style:
Brainstorming: Questions Followed by Concrete Drafts
Like Grill Me, Superpowers starts with an idea and asks clarifying questions.
But instead of continuing with questions indefinitely, it moves relatively quickly into drafting sections of the specification.
You review one section, provide feedback, and move on to the next.
I find this a bit easier to work with.
When an agent asks dozens of questions, you have to maintain a mental picture of the entire system while answering each one.
This becomes particularly difficult when designing API interfaces. The agent might ask several questions about the shape of the API, validation, and error handling. Each question makes sense individually, but the process becomes tiring. Sometimes looking at a draft interface spec communicates more than answering twenty questions.
When Superpowers presents a draft section, I find it easier to get a sense of the whole idea and identify what the agent is getting right and where it is going wrong.
As I identify what’s wrong, the agent revises the section, and we move forward.
It feels more like collaborating with an architect who presents designs for review rather than an analyst conducting an extended interview.
More Readable Specifications
This difference also affects the resulting documentation.
In my experience, Matt Pocock’s documents often retain more of the question-and-answer structure from the discovery process.
That preserves useful detail, but I find the documents harder to read later.
Superpowers tends to produce more consolidated specifications, with related requirements organised into clear sections.
For me, a well-structured design document is easier to revisit than a lengthy record of questions and answers.
Planning and Execution
After completing the specification, Superpowers creates an implementation plan.
Unlike Matt Pocock’s To Tickets, which produces individual tickets, Superpowers keeps the tasks together in a single plan document.
For execution, it offers two approaches:
- Subagent-driven development, where a fresh agent implements each task, followed by a task review and a final whole-branch review.
- Executing plans, where the agent implements all tasks inline in the current session, followed by a whole-branch review.
Superpowers can recommend an approach depending on the complexity of the work.
What I particularly like is that the agent can work through a substantial portion of the plan without requiring me to manually initiate every task.
Compared with my earlier experience of implementing Matt Pocock’s tickets one by one, this feels more autonomous.
A More Iterative Approach
Another difference is how Superpowers handles larger projects.
Rather than specifying everything upfront, it will often suggest dividing a large project into two or three smaller specifications.
You then complete one part through the full cycle:
Specification → Plan → Implementation → Review
After that, you move to the next part.
I like this because it encourages delivering meaningful chunks of functionality and incorporating feedback between iterations.
You might discover something during the first implementation that changes how you want to approach the second.
This feels closer to how I prefer to develop software: shorter cycles of design, implementation, and feedback rather than one enormous specification followed by a long implementation phase.
The Biggest Difference Is the Developer Experience
After using both frameworks, I don’t think the most important distinction is how they generate code.
Both provide structured approaches to implementation and review.
The bigger difference is how they help you think through what you’re building.
Matt Pocock’s Grill Me is primarily question-driven. It tries to eliminate ambiguity by asking detailed questions until the requirements are clear.
Superpowers is more specification-driven. It asks questions but also presents consolidated drafts for you to evaluate and refine.
Both approaches have merit.
The question-driven approach is particularly valuable for complicated problems with hidden assumptions.
The specification-driven approach is more comfortable when you already have a reasonable understanding of what you want and prefer reviewing concrete proposals.
The difference isn’t as big as it may sound, though. Matt Pocock’s skills generate a spec after the Q&A session, and Superpowers asks a few questions before presenting each section of the spec. It’s more a matter of emphasis.
I find Superpowers easier to work with, not because Grill Me asks unnecessary questions—quite often, they’re excellent questions—but because reviewing and correcting a proposed design is less mentally demanding than answering a long sequence of questions.
A Side-by-Side Comparison
| Area | Matt Pocock’s Skills | Superpowers |
|---|---|---|
| Initial discovery | Grill With Docs | Brainstorming |
| Discovery style | Deep questioning | Questions and section-by-section drafts |
| Specification | To Spec | Consolidated design document |
| Task breakdown | Individual tickets | Single implementation plan |
| Execution | Implement, including multi-ticket execution in newer versions | Plan execution or subagent-driven development |
| Large project discovery | Wayfinder with multiple exploration sessions | Splitting work into smaller specifications |
| Research and prototyping | Wayfinder supports dedicated research and prototypes | Primarily focused on brainstorming and design |
| Architecture improvement | Dedicated HTML architecture review | No directly equivalent skill |
| Knowledge capture | Glossary and ADRs | No equivalent artifacts |
| My preference | Excellent for deep requirements exploration | More comfortable for everyday feature development |
This isn’t intended to be an exhaustive feature comparison. It summarises the capabilities I’ve used and the differences that stood out to me.
Which One Do I Prefer?
If I had to choose one for everyday development, I’d lean slightly toward Superpowers.
Three things make the difference for me.
First, I prefer reviewing specification sections over answering extended sequences of questions.
Second, I find the resulting specifications easier to read and revisit.
Third, I like its iterative approach to larger projects and its ability to execute substantial plans with relatively little intervention.
That said, Matt Pocock’s skills have several capabilities I particularly appreciate.
Grill Me is exceptional at uncovering requirements and edge cases, even when the questioning becomes frustrating.
Wayfinder offers an interesting approach to large-project discovery through multiple sessions, research, and prototyping.
And supporting skills like glossary generation, ADRs, architecture reviews, and PR writing add considerable value.
Final Thoughts
One interesting observation is that the two frameworks appear to be evolving toward some of the same ideas.
Superpowers already provides longer-running plan execution and an iterative specification process.
Matt Pocock’s skills have been adding multi-ticket implementation and Wayfinder, making larger projects easier to explore and execute.
I expect both will continue to evolve, and it’ll be interesting to see which ideas they adopt from each other.
For now, my preference is Superpowers for the overall development experience, particularly brainstorming, specification writing, and iterative implementation.
But Grill Me remains one of the strongest tools I’ve used for deeply exploring a problem, and Wayfinder adds another interesting dimension to that process.
Ultimately, I don’t think there’s a clear winner.
Matt Pocock’s skills feel like working with a meticulous analyst who wants to understand every detail before proceeding.
Superpowers feels more like collaborating with an architect who presents designs, gets your feedback, and progressively turns them into working software.
