Comprehensive Comparison: grill-me vs Superpowers

Hello everyone, I’m Kasong.

Recently, my thread comparing grill-me and Superpowers has been well received by many friends.

Both are currently very popular AI coding workflows, each with over 100k stars.

Today, I’ll provide a thorough comparison in this article to help you choose.

Design Philosophy

The main flows of both are roughly similar:

• Through multiple rounds of Q&A with AI to align requirements

• Produce requirement documents

• Break down documents into plans

• Execute plans

To discuss their differences, the best way is to start with their design philosophy.

grill-me originated from a collection of author @mattpocockuk’s personal skills as a programmer.

This means grill-me carries a lot of the author’s personal style, for example:

• Skills are divided into: actively called by the developer / automatically called by the Agent based on context

• When the discussion gets too long and the Agent’s context is insufficient, the developer needs to actively call handoff to summarize the discussion into a document, then start a new session to continue

Superpowers’ design philosophy is a complete software development methodology, which means a lot of complexity is abstracted into the framework, for example:

• The developer doesn’t need to know when to call which skill; all skills are automatically triggered when needed

Once you understand the difference in design philosophy, many detailed differences become easy to grasp.

Differences in Questioning Methods

The first step in both workflows is “multiple rounds of Q&A to align requirements.” What’s the difference?

Matt is an excellent developer, so grill-me assumes you already have a solution in mind, just lacking details.

His implementation logic is: starting from a trunk, through continuous discussion with you, branches extend, and the final state is a complete tree structure.

This means “if you only have a vague idea and passively accept/reject AI’s suggestions during the conversation, you’ll be asked a lot of questions (because the output is a tree, each branch needs attention).”

The correct approach is:

• Have a main trunk before the conversation

• Actively guide the conversation, growing more branches in one dialogue

• Provide additional information using outputs from tools like /prototype

Again, you need to understand the development model the author advocates to use it well.

Superpowers’ brainstorming assumes you have only a fuzzy idea, and the Agent gives you direction based on your thought.

Similar to: You ask for directions in an unfamiliar city, a passerby points you in the right direction, you walk a bit, then ask another passerby, until you reach your destination.

Theoretically, using the latter will result in fewer questions asked than the former.

So the question arises: grill-me asks more questions, so the Agent will inevitably have more comprehensive information.

Superpowers asks fewer questions; how does it ensure the subsequent execution doesn’t deviate?

Again, understanding the difference in design philosophy explains the difference.

Because grill-me asks very thoroughly, the subsequent process is quite lightweight, only having a review process after code is written.

Superpowers deploys multiple Reviewers during:

• Generating requirement documents

• Converting requirement documents into execution plans

• During plan execution

These Reviewers not only control code quality but also fill in many missing requirement details.

This also leads to many people criticizing Superpowers for being too slow and consuming too many tokens.

How to Choose?

AI programming is essentially continuously correcting the deviation between ideas and code implementation.

There are many methods to correct, for example:

• grill-me aligns requirements through extensive questioning, reducing deviation

• Superpowers reduces deviation through multiple rounds of review

Ultimately, it’s about finding a balance among the following three points:

(Graphic: a triangle with vertices: “Low cost (tokens/time)”, “Low attention investment”, “Low deviation”)

To find this balance, you can even use these tools separately, for example:

• If you use Fable 5, the model is smart enough to fill in everything, you could even skip the “back-and-forth questioning to align requirements” step

• If you want to reduce attention investment, you can first use brainstorming to set direction, then use grill-me to align details

• If the model you use isn’t smart enough, you could introduce Superpowers’ Reviewer into grill-me’s code generation process

If you just want to pick one, consider the model you use and whether the Agent supports long-term goal execution.

Superpowers outputs detailed execution plans, which implies its assumptions are:

• The Agent cannot execute long-term tasks, so the plan’s TODO items serve as compact execution anchors

• The Agent may deviate during long-term execution, so the execution plan needs to be detailed down to “what to do at each step”

grill-me’s implement is just 5 sentences, defining a standard goal format:

• What is the goal: Check the PRD or issue

• How to do it: TDD

• Execution constraints: Regularly run tests and type checks

• Acceptance criteria: Use /review to pass

• Delivery criteria: Submit a commit

Essentially, it assumes the Agent already has good goal capabilities.