Does gsd have Test Driven Development?

There's also:

4. Tell claude what to do instead, which will update the plan base on what you say.

5. Add comments to the plan directly - similar to 4 - but you can comment on specific parts.

Note: I use the VSCode extension, not sure if it differs in terminal mode.

You can just tell it what to do. I have a cut and paste handy that lets the tool know to present all judgement calls to me a few at a time in logical groups to give feedback on. I go through that process and then it pulls the plan from that

>It's sure baffling how Anthropic has kept Claude Code's plan mode so linear and inflexible

It's difficult to know what the appropriate process for a model would be without widespread deployment. I can see how they have to strike a fine balance between keeping up with what the feedback shows would be best and changing the way the user interacts with the system. Often it's easy to tell what would be better once something is deployed, but if people are productively using the currently deployed system you always have to weigh the advantage of a new method against the cost of people having to adapt. It is rare to make something universally better, and making things worse for users is bad.

I've found [Plannotator]( https://github.com/backnotprop/plannotator) useful for this. It opens the plan on a minimal web page so I can highlight and add comments. This is then passed back to Claude code. Works well enough for now. But ideally this should be natively implemented in cc.

I accidentally figured out you can go into plan mode then leave, Claude can keep working on the plan, then I use my own custom plan viewer (just a markdown viewer that's watching for the latest for update in the plan dir)

The VSCode plugin now (since last week I think) allows you to highlight elements of the plan and add comments. I think it first appeared in Antigravity but now is in Claude code. Unfortunately there is only so much you can do in CLI.

It is also possible to now save plans in a custom location (I have started using ./docs/plans) although the plan mode still frustratingly names plans random file names and struggles with more than. 1 plan file in a session.

But the interface has become much better if you're on vscode

In my experience the plan is plastic and responsive to iteration through dialogue. I don't think too much structure here is going to be desired by all users. But the "sounds good, but needs these edits" option can save a small amount of interaction. I often use the tab command that exists to modify the yes and no options. If you tab modify "Yes", I believe the plan will be executed and addendums from your additional prompting will be made afterward. By using tab modified "No", you can be clear about what parts of the plan are to be kept and what is to be immediately adjusted. Tab modified "No", definitely works as the "sounds good" option, but perhaps requires slightly more typing than you would like. "No, use most of this, but change..." I don't think there is a glaring lack here at all.

Plans are written to the .Claude folder in your home directory as you discuss them. Just ask for the file name.

Overall I think it's useful.

Superpowers has several skills. Its core workflow is:

- Brainstorm with you to design a spec

- Use subagents to review its own spec, then get your approval

- Based on the spec, write a plan, use subagents to review before final approval

- Use subagents to implement (using TDD)

I think that the brainstorming skill [1] is great. It helps flesh out a rough early idea. I also like that it uses subagents to adversarially review its own spec/plan; that has caught several things I would've missed. I do not like the separation of spec/plan; IMO the models are good enough to get straight to coding once the spec is written. The plan often ends up being code blocks in a Markdown doc.

[1]: https://github.com/obra/superpowers/tree/main/skills/brainst...

Croes, is that you?

>The way I use Claude is quite similar to what super powers does under the hood anyways.

I bake my own bread and solo code, both episodic. No matter how I vary fresh starts, I always end up in the same place. The optimization problem feels to be a giant bowl.

This reminds me of named flavors of management style for teams of programmers. A friend in this role instead prefers deep dives into Apollo flight control, and abstracting.

As a solo programmer I always converge on staying extraordinarily involved in planning and code review, and working in steps of finer granularity than superpowers suggests. One may produce less code this way, but it's the only way I know to discover one needs less code.