Which Claude Code Workflow Builds the Best App?

TL;DR

GSD and Superpowers both improve complex Claude Code projects through detailed planning, smaller tasks, subagent execution, and verification. Superpowers emphasizes test-driven development and interactive design exploration, while GSD emphasizes persistent project documentation and explicit state tracking. The provided transcript describes the comparison setup and early planning, but it does not include the final test results or winner.

Transcript

Should you be using GSD or should you be using superpowers or are both a waste of time? To answer that question, I did a head-to-head test with superpowers, GSD, and vanilla clawed code. I have them create the exact same web app, and we grade them on their final output, the amount of tokens used, and how long it takes them to build it. And the winn... Read More

Key Insights

• GSD and Superpowers are orchestration layers for Claude Code that introduce more structured planning, testing, and subagent-driven development. Their shared goal is to break complex projects into smaller tasks and reduce the context degradation that can occur when one session handles the entire project.
• Subagent-driven development works by assigning specific tasks to separate agents with cleaner context windows. Instead of keeping planning and implementation inside one continuously expanding Claude Code session, each subagent receives a narrower responsibility that should support more focused output.
• Superpowers is strongly centered on test-driven development. Its stated rule requires a failing test before production code, followed by the minimum implementation needed to pass that test and a refactoring stage that improves the code while preserving successful behavior.
• GSD is strongly centered on persistent project state and context. It creates markdown files for requirements, roadmaps, phases, completed work, and future tasks, giving frequently reset subagents a written reference for where the project stands and where it should go next.
• Superpowers offers a visual companion that can run a development server and present multiple design directions for review. In the demonstrated process, it displayed four aesthetic options and then refined the selected warm editorial direction through additional hero-section choices.
• GSD uses explicit slash commands to control its workflow, including a command for starting a new project. Superpowers instead loads a collection of skills and lets Claude Code select an appropriate skill according to the conversation and the current stage of development.
• The benchmark asks all three workflows to build the same AI agency website. Required features include a landing page, a public blog, and a hidden administrative generator that accepts a YouTube or article URL and produces a blog post with source imagery.
• The benchmark evaluates final output, token consumption, and completion time. The prompt intentionally leaves transcript retrieval, YouTube thumbnail handling, generation instructions, writing voice, and skill selection open to interpretation so differences in planning and implementation can emerge.

Questions & Answers

Q: What is the difference between GSD and Superpowers?

GSD and Superpowers use similar planning and subagent workflows, but their main emphases differ. Superpowers focuses heavily on test-driven development, including failing tests, minimal passing implementations, refactoring, code review, and merging. GSD focuses more on maintaining explicit state through markdown documents that record requirements, roadmaps, phases, completed work, and remaining tasks across repeated context resets.

Q: How does subagent-driven development reduce context problems?

Subagent-driven development divides a large project into smaller, specific tasks and assigns each task to a separate agent. Each subagent therefore begins with a cleaner and more focused context window. This avoids placing every planning decision, implementation detail, and revision into one Claude Code session, where accumulated information can fill the context window and potentially weaken later output.

Q: How does Superpowers use test-driven development?

Superpowers applies a test-first process described as red, green, refactor. Before writing production code for a feature, it creates a test that initially fails. It then writes the minimum amount of code required to make that test pass. After reaching a passing state, it refactors the implementation while using the test to confirm that the intended behavior remains intact.

Q: How does GSD preserve project context between tasks?

GSD preserves context by repeatedly writing project information into markdown files. These documents describe the requirements, roadmap, phases, previous work, current position, and future work. Because execution involves multiple subagents and frequent context resets, the saved files act as a persistent reference that helps each agent understand the project direction without relying entirely on an earlier conversation history.

Q: What application did the comparison ask each workflow to build?

Each workflow was asked to build a website for the Chase AI agency. The site needed a standard landing page with a hero section, an about section, services, and a lead capture form. It also needed a public blog and a hidden administrative page that could generate new blog posts from either YouTube video URLs or article URLs.

Q: What did the automated blog generator need to do?

The hidden administrative generator needed to accept either a YouTube video URL or an article URL, retrieve information from that source, and use the Anthropic SDK to create a clean blog post in the requested voice. It also needed to obtain the source thumbnail or hero image and save the generated content and image together as a new blog post.

Q: How did Superpowers support visual design decisions?

Superpowers used a visual companion that started a development server and showed several aesthetic directions together. The demonstration presented four choices, allowing the reviewer to compare them visually instead of relying only on written descriptions. After the warm editorial option was selected, Superpowers continued refining the design by presenting additional alternatives for the landing page hero section.

Q: Which workflow won the GSD, Superpowers, and Claude Code test?

The winner cannot be determined from the provided transcript. The introduction says that the workflows are graded on final output, token usage, and completion time, and it suggests that the result is unexpected. However, the supplied transcript ends during Superpowers' visual design exploration, before the first-pass evaluation, final comparison, scores, or winning workflow are disclosed.

Summary & Key Takeaways

• GSD and Superpowers are orchestration layers that change how Claude Code handles complex projects. Both divide a large idea into smaller, specific tasks and assign those tasks to subagents. This approach gives each subagent a cleaner context window instead of filling one continuous session with planning, implementation, testing, and revision details.

• Superpowers follows a workflow built around brainstorming, planning, Git worktrees, subagent-driven development, test-driven development, code review, and merging. Its test process follows red, green, refactor: create a failing test, write the minimum production code needed to pass it, and then improve the implementation without breaking the successful test.

• GSD emphasizes explicit state management through project, requirements, roadmap, and phase documents. These files record what is planned, what has already been completed, and what remains. The comparison asks GSD, Superpowers, and baseline Claude Code to build the same agency website, then evaluates output, token usage, and completion time.