I usually use AI to write code without reaching for any particular skills. I try to describe the feature as precisely as I can, often in a Markdown file. Then I give the file to the agent in Plan mode and ask it to implement the plan once I have approved it.
I like using the same model for both steps. I am a little reluctant to use the "stronger model for planning, weaker model for implementation" approach. For example, I use GPT Sol 6.x or Opus 5.x for both planning and writing the code. Over the past few weeks I wanted to try a different way of working, so I tried Elephant Goldfish Model, Matt Pocock's skills, and Superpowers.
A skill is a set of instructions written in a Markdown file that an agent can follow for a specific job, like asking about requirements, writing a plan, or reviewing a diff. All three workflows start with a conversation and produce something the agent can refer back to. What interests me is what gets checked at that point. A specification can make perfect sense to the person who wrote it and still leave the implementer with questions. A task can also pass all its tests and cause a problem when it meets code from another task.
Elephant Goldfish Model
The idea behind EGM is to give the agents who write and review the specification different contexts. The Elephant follows the conversation, keeps track of decisions, and writes the draft. The Goldfish get the document and can consult the referenced material. They start without the conversation that led to the draft. If a detail came up in discussion and never made it onto the page, a fresh reader has a good chance of spotting the gap.
The workflow starts with the egm-brainstorm skill, which helps clarify the goal and prepare a brief. egm-draft turns that into a technical design. egm-review gives the draft to reviewers with different jobs. One might look for contradictions while another checks whether the proposal fits the existing code. With egm-resolve, you go through the review findings and decide which changes to make. You end up with a technical design and a record of the reviews. Once the project owner approves it, the design guides implementation. See the EGM workflow.

Suppose you filter a table of orders and get 120 results, with 20 shown per page. The specification says the CSV export must use the same filter. Should the file contain all 120 orders or just the 20 on the current page? Someone who discussed the requirement may already know the answer. A reviewer seeing the document for the first time will ask you to write it down. That was my favorite part. The tradeoff is that you may have to read and evaluate a lot of evidence, both in the specification document and the technical document. Another aspect to consider is that EGM doesn’t provide an implementation workflow, so there’s no way to verify whether the generated code complies with the specification.
Matt Pocock's skills
Matt Pocock's flow begins with grill-with-docs. The agent reads the code and documentation and asks you about decisions that are still open. If the project uses similar words for different things, it is worth sorting that out early. Think of a canceled order and a refunded payment. They may be part of the same flow, but they are different events and can happen at different times. A glossary such as GLOSSARY.md makes the distinction explicit. An architecture decision record, or ADR, captures the reasoning behind decisions you will want to revisit later.
to-spec brings the decisions into a specification and describes the expected behavior. to-tickets breaks the specification into increments with acceptance criteria. In practice, a ticket should give you a behavior you can verify. For example, one ticket could deliver the ability to cancel an order from the profile, including the status check and a test through the service. That gives you a working flow as soon as the ticket is done. In the workflow I followed, implement guided the work on the tickets and code-review checked the changes against the specification.

What I appreciated most about Matt Pocock's approach is the traceability of decisions. The project's context is not confined to the conversation with the AI but is distributed across documents with clearly defined responsibilities: the glossary clarifies domain concepts, ADRs document architectural decisions, the specification describes the expected behavior, and tickets translate requirements into verifiable tasks.
This makes it possible to resume development in a new session without having to reconstruct all the previous decisions.
The downside, however, could be the process overhead. Moving from brainstorming to specification, from specification to tickets, and finally to implementation involves several steps and requires a certain level of discipline in maintaining documentation. Even a seemingly simple change may require updating multiple documents and tickets to keep everything consistent.
This is a trade-off that can make sense for complex features but risks unnecessarily complicating the development of smaller ones. It's worth noting, however, that Pocock's workflow is modular: skills can be used independently, allowing you to choose only those needed for a particular task without having to follow the entire process.
Superpowers
Superpowers starts with brainstorming to understand the problem and produce a specification you can approve. Then writing-plans puts tasks in order and describes how to verify them. The specification describes the behavior you want. The plan is for whoever will change the code, so it gets into files, dependencies between tasks, and which tests to run. Superpowers documentation
In subagent-driven-development mode, one agent coordinates the work and delegates tasks. An agent implements a task, with a test that fails before the change and passes afterward. The review checks whether the code meets the specification and whether it is well written. If a problem comes up, the code gets fixed and checked again. Once the tasks are done, a broader review looks at the whole branch. That is a chance to see whether pieces built separately work well together. How subagent-driven development works

What I appreciated most about Superpowers is the discipline it brings to the implementation phase. The framework doesn't simply provide a plan to execute; it guides development through small, manageable tasks, applying Test-Driven Development (TDD) and incorporating systematic code reviews. In particular, with the subagent-driven development approach, each task is assigned to a dedicated agent and goes through two separate reviews: one to verify compliance with the specification and another to assess code quality.
This approach helps identify potential issues early in the development process, preventing unverified changes from accumulating until the end of the implementation.
The main drawback could be the rigidity of this process. Repeating the implementation, testing, and review cycle for every task introduces additional steps and potentially increases token consumption. For complex features, this investment can pay off in terms of code quality and reliability, while for simpler changes, it may be disproportionate to the task at hand.
Superpowers still offers some flexibility, allowing developers to choose between subagent-driven development and executing the plan within the current session, adapting the workflow to the project's needs.
Trying the workflows on ZenBarber reviews
To put the three approaches to the test, I chose to develop the same feature for ZenBarber, a platform for booking appointments at barbershops. The goal was to allow customers to leave a review after an eligible appointment and enable barbershop owners to view, manage, and report reviews through the backoffice.
With EGM, the design phase required the most interaction. During brainstorming, several trade-offs and edge cases emerged that I hadn't initially considered. The questions asked by the agent and the subsequent Goldfish reviews made me think about aspects of the feature that I probably would have overlooked.
The brainstorming phase was the longest of the three, but it resulted in a detailed and well-structured technical specification. Although EGM doesn't provide a dedicated implementation skill, I have to say that, overall, it was the approach I enjoyed the most. The downside was token consumption, which was already particularly high during the design and specification review phases.
With Matt Pocock, the design phase required fewer interactions compared to EGM. What I appreciated most was how information is organized and documented: glossaries, ADRs, specifications, and tickets make it possible to keep track of decisions and break down the work into clearly defined tasks.
Turning the specification into implementation tickets was one of the aspects I found most interesting.
With Superpowers, I had fewer interactions during the design phase. I particularly appreciated the discipline it introduced during development, thanks to incremental tasks, Test-Driven Development (TDD), and systematic code reviews.
The implementation process was more involved and required more verification steps, but it gave me a greater sense of control over the quality of the final result.
One aspect that pleasantly surprised me was that, in my experiment, Superpowers was the only approach that proposed a UI preview before starting the implementation. This allowed me to evaluate the interface and request changes before any code was written.
To make the comparison quantitative as well, I used the Codex logs to retrieve the cumulative token counts, number of interactions, and active time for all three runs. The data helps illustrate how different the resource costs of these workflows can be, keeping in mind that the number of steps and the activities actually performed were not necessarily identical.
| Workflow | Work included | Design tokens | Implementation tokens | Total tokens | Number of interactions | Active time |
|---|---|---|---|---|---|---|
| Elephant Goldfish Model | Design and document review | 100,961,139 | 0 | 100,961,139 | 85 | 3:07:07 |
| Matt Pocock's skills | Design, implementation, and two branch reviews | 4,515,022 | 107,454,120 | 111,969,142 | 27 | 3:33:41 |
| Superpowers | Design, implementation, verification, and automatic Codex checks | 5,830,048 | 184,461,235 | 190,291,283 | 12 | 3:41:06 |
Token counts combine input and output. Design covers the work before coding, from the specification to the plan or tickets, including their reviews. Implementation includes code, tests, branch reviews, and fixes. The interaction count covers completed turns in the main conversation. Active time covers time spent in turns, including waits for tools and reviewers.
Between 96.7% and 97.9% of the input tokens came from cache. The totals include the same context being read across multiple calls. The runs also covered different work. EGM stopped at the technical design, moderation rules varied, and I could refer to earlier branches during the Superpowers run. Treating these figures as an efficiency ranking would be misleading.
Conclusions
Comparing Elephant-Goldfish Model, Matt Pocock, and Superpowers made me realize that there is no single way to approach software development with AI. All three approaches share a fundamental principle: don't let an AI agent jump straight from an idea to code without a process of design, planning, and verification. What differs is how each framework tries to achieve this goal.
EGM focuses on the quality of the specification, aiming to identify ambiguities and design flaws before they turn into code. Matt Pocock emphasizes decision traceability and work organization, making project context accessible even across different sessions. Superpowers focuses more on implementation discipline through incremental tasks, Test-Driven Development (TDD), and systematic code reviews.
I don't believe any of these frameworks is necessarily better than the others. The choice depends on the complexity of the feature, the maturity of the project, and the level of control we want to maintain throughout development. Moreover, there's no need to adopt any of them in their entirety: we can draw inspiration from different approaches and build a workflow that best suits our needs.
The most important lesson, in my opinion, is that using AI agents doesn't mean completely delegating software development, but learning how to guide and control the process. AI can help us design, implement, and verify software, but the responsibility for defining requirements, evaluating architectural decisions, and ensuring the final result is correct remains ours.
Ultimately, the value of these frameworks lies not only in the code they help us produce, but also in the process they help us build to get there.
Comments