Discussion

Search code, repositories, users, issues, pull requests...

dfltr: GSD has a reputation for being a token burner compared to something like Superpowers. Has that changed lately? Always open to revisiting things as they improve.

obsidianbases1: > If you know clearly what you wantThis is the real challenge. The people I know that jump around to new tools have a tough time explaining what they want, and thus how new tool is better than last tool.

greenchair: terrible name, DOA

MeetingsBrowser: I've tried it, and I'm not convinced I got measurably better results than just prompting claude code directly.It absolutely tore through tokens though. I don't normally hit my session limits, but hit them immediately with GSD.

prakashrj: With GSD, I was able to write 250K lines of code in less than a month, without prior knowledge of claude.

wslh: 250K? Could you expand your experience with details about your project and the lessons and issues you found?

rsoto2: I could copy 250k lines from github.Faster than using ai. Cheaper. Code is better tested/more secure. I can learn/build with other humans.

prakashrj: This is how I test my code currently. 1. Backend unit tests — fast in-memory tests that run the full suite in ~5 seconds on every save. 2. Full end-to-end tests — automated UI tests that spin up a real cloud server, run through the entire user journey (provision → connect → manage → teardown), and verify the app behaves correctly on all supported platforms (phone, tablet, desktop). 3. Screenshot regression tests — every E2E run captures named screenshots and diffs them against saved baselines. Any unintended UI change gets caught automatically.

testycool: Same experience on multiple occasions.

boringg: What do you think drives the tooling ecosystem aside from VC dollars?

jauntywundrkind: These are incredible new superpowers. The LLMs let us do far far more than we could before. But it creates information glut, doesn't come with in built guards to prevent devolution from setting in. It feels unsurprising but also notable that a third of what folks are suddenly building is harness/prompting/coordination systems, because it's all trying to adapt & figure out process shapes for using these new superpowers well in.There's some VC money interest but I'd classify more than 9 / 10ths of it as good old fashioned wildcat open source interest. Because it's fascinating and amazing, because it helps us direct our attention & steer our works.And also it's so much more approachable and interesting, now that it's all tmux terminal stuff. It's so much more direct & hackable than, say, wading into vscode extension building, deep in someone else's brambly thicket of APIs, and where the skeleton is already in place anyhow, where you are only grafting little panes onto the experience rather than recasting the experience. The devs suddenly don't need or care for or want that monolithic big UI, and have new soaring freedom to explore something much nearer to them, much more direct, and much more malleable: the terminal.

gtirloni: I was using this and superpowers but eventually, Plan mode became enough and I prefer to steer Claude Code myself. These frameworks are great for fire-and-forget tasks, especially when there is some research involved but they burn 10x more tokens, in my experience. I was always hitting the Max plan limits for no discernable benefit in the outcomes I was getting. But this will vary a lot depending on how people prefer to work.

thr0waway001: At the risk of sounding stupid what does the author mean by: “I’m not a 50-person software company. I don’t want to play enterprise theatre.” ?

arjie: I could not produce useful output from this. It was useful as a rubber duck because it asks good motivating questions during the plan phase, but the actual implementation was lacklustre and not worth the effort. In the end, I just have Claude Opus create plans, and then I have it write them to memory and update it as it goes along and the output is better.

Andrei_dev: 250K lines in a month — okay, but what does review actually look like at that volume?I've been poking at security issues in AI-generated repos and it's the same thing: more generation means less review. Not just logic — checking what's in your .env, whether API routes have auth middleware, whether debug endpoints made it to prod.You can move that fast. But "review" means something different now. Humans make human mistakes. AI writes clean-looking code that ships with hardcoded credentials because some template had them and nobody caught it.All these frameworks are racing to generate faster. Nobody's solving the verification side at that speed.

lielcohen: This is the key insight. The generation vs. verification speed gap is a fundamental architectural problem with single-agent workflows. When one agent writes 250K lines, the verification bottleneck isn't just about running tests - it's about catching the things tests don't cover: hardcoded credentials, missing auth middleware, debug endpoints in prod. One approach that works well is splitting generation and verification into separate agents with different system prompts and ideally different models. The 'verifier' agent only sees the spec and the output code, never the generation context. It catches a surprising amount of the 'looks clean but is broken' issues because it doesn't share the same blind spots as the generator.

mbb70: https://news.ycombinator.com/newsguidelines.html#generated

dominotw: yes vibecoding is fun.

eclipxe: This is clearly ai generated. Please no.

maccam912: I've had a good experience with https://github.com/obra/superpowers. At first glance this looks similar. Has anyone tried both who can offer a comparison?

huydotnet: I've tried both. Each has pros and cons. Two things I don't like about superpowers is it writes all the codes into the implementation plan, at the plan step, then the subagents basically just rewrite these codes back to the files. And I have to ask Claude to create a progress.md file to track the progress if I want to work in multiple sessions. GSD pretty much solved these problems for me, but the down side of GSD is it takes too many turns to get something done.

prakashrj: You can AI to audit and review. You can put constraints that credentials should never hit disk. In my case, AI uses sed to read my env files, so the credentials don't even show up in the chat.Things have changed quite a bit. I hope you give GSD a try yourself.

hatmanstack: Why are we using cli wrappers if you're using Claude Code? I get if you need something like Codex but they released sub agents today so maybe not even that, but it's an unnecessary wrapper for Claude Code.

ibrahim_h: The README recommends --dangerously-skip-permissions as the intended workflow. Looking at gsd-executor.md you can see why — subagents run node gsd-tools.cjs, git checkout -b, eslint, test runners, all generated dynamically by the planner. Approving each one kills autonomous mode.There is a gsd-plan-checker that runs before execution, but it only verifies logical completeness — requirement coverage, dependency graphs, context budget. It never looks at what commands will actually run. So if the planner generates something destructive, the plan-checker won't catch it because that's not what it checks for. The gsd-verifier runs after execution, checking whether the goal was achieved, not whether anything bad happened along the way. In /gsd:autonomous this chains across all remaining phases unattended.The granular permissions fallback in the README only covers safe reads and git ops — but the executor needs way more than that to actually function. Feels like there should be a permission profile scoped to what GSD actually needs without going full skip.

hatmanstack: I don't get why people need a cli wrapper for this. Can't you just use Claude skills and create everything you need?

prakashrj: I was not a app developer before, but a systems engineer with devops experience. But I learnt a lot about apple development, app store connect and essential became a app developer in a month. I don't think I can learn so quickly with other humans help.

0x696C6961: If you lost access to AI would you be able to continue development on your app?

prakashrj: Goal is to build something that will have value. Once it has value, I can hire a team or open source it, if AI ceases to exist in this world.

annjose: I tried Superpowers for my current project - migrating my blog from Hugo to Astro (with AstroPaper theme). I wrote the main spec in two ways - 1) my usual method of starting with a small list of what I want in the new blog and working with the agent to expand on it, ask questions and so on (aka Collaborative Spec) and 2) asked Superpowers to write the spec and plan. I did both from the working directory of my blog's repo so that the agent has full access to the code and the content.My findings:1. The spec created by Superpowers was very detailed (described the specific fonts, color palette), included the exact content of config files, commit messages etc. But it missed a lot of things like analytics, RSS feed etc.2. Superpowers wrote the spec and plan as two separate documents which was better than the collaborative method, which put both into one document.3. Superpowers recommended an in-place migration of the blog whereas the collaborative spec suggested a parallel branch so that Hugo and Astro can co-exist until everything is stable.And a few more difference written in [0].In general, I liked the aspect of developing the spec through discussion rather than one-shotting it, it let me add things to the spec as I remember them. It felt like a more iterative discovery process vs. you need to get everything right the first time. That might just be a personal preference though.At the end of this exercise, I asked Claude to review both specs in detail, it found a few things that both specs missed (SEO, rollback plan etc.) and made a final spec that consolidates everything.[0] https://annjose.com/redesign/#two-specs-one-project

indigodaddy: Check out exe.dev/Shelley web agent it facilitates much of what you describe by default.

jghn: I've gone the other way recently, shifting from pure plan mode to superpowers. I was reminded of it due to the announcement of the latest version.It is perhaps confirmation bias on my part but I've been finding it's doing a better job with similar problems than I was getting with base plan mode. I've been attributing this to its multiple layers of cross checks and self-reviews. Yes, I could do that by hand of course, but I find superpowers is automating what I was already trying to accomplish in this regard.

gtirloni: Yes, it does help in that way. Maybe I'm still struggling to let go and let AI take the wheel from beginning to end but I enjoy the exploratory part of the whole process (investigating possible solutions, trying theories, doing little spikes, etc, all with CC's assistance). When it's time to actually code, I just let it do its own thing mostly unsupervised. I do spend quite a lot of time on spec writing.

tkiolp4: The whole gsd/agents folder is hilarious. Like a bunch of MD that never breaks. How do you is it minimally correct? Subjective prose. Sad to see this on the frontpage

gbrindisi: I like openspec, it lets you tune the workflow to your liking and doesn’t get in the way.I started with all the standard spec flow and as I got more confident and opinionated I simplified it to my liking.I think the point of any spec driven framework is that you want to eventually own the workflow yourself, so that you can constraint code generation on your own terms.

alasano: I also like openspec.I think these type of systems (gsd/superpowers) are way too opinionated.It's not that they can't or don't work. I just think that the best way to truly stay on top of the crazy pace of changes is to not attach yourself to super opinionated workflows like these.I'm building an orchestrator library on top of openspec for that reason.

hatmanstack: No brother, the Claude plans aren't the right path, they're for hobbyists.

arjie: Okay, I'll give these another shot. Perhaps I just haven't figured out how to use them right.

hatmanstack: I don't know brother, I don't use them, they may be great they may suck. What I've found is that adding peripherals always creates more problems. If you aren't using Claude for professional work then just sticking with the factory plan mode probably works. If not, look into creating your own Claude skills, try to understand how prompt pipelines work and it will unlock a ton of automation for you. Not just for coding.

gtirloni: GSD and superpowers aren't CLI wrappers?