I'm already using Claude Code for big chunks of my workflow, and I'm always looking for new ways to make things easier. One of the coolest features of Claude Code is that it can spawn subagents to handle individual tasks, with individualized instructions. But I didn't want to manually corral those coding agents, so I went looking for another option. And I found it, in Get Sh*t Done.

The aptly named tool helps you plan, research, design, build, and verify your project end-to-end, and it's amazing. You can let it run wild to build your program after an initial question-and-answer phase, or work interactively to get the final product you've been imagining. It's incredibly powerful, and it'll turn your single developer cycle into a full team, (mostly) managed by Claude.

What is GSD (Get Sh*t Done)?

Think of it as an org chart for a small dev team

One of the problems I've found with vibe coding is that, while I don't have to know the programming language, it's just as much work as writing code myself. I mean, AI agents go off on weird tangents, write spaghetti code, or add unnecessary loops, and they need a firm hand to keep them on track.

And that's what GSD does. Turns a single coder into a small full-stack development team, by putting the complexity of managing subagents into the hands of well-constructed planning documents, so the developer can focus on the look, features, and feel of the app being developed.

It primarily runs off six main namespace routers, but those six are mapped onto various groups out of the 86 skills that GSD encompasses:

Everything gets handled in the background, from context engineering, XML prompts, subagent orchestration, and so on. It'll ask you for confirmation on some things, but you can waive those conversations if you prefer and let it build in peace. It's not like you can't go back into the code and have an interactive conversation with the GSD tool to change things after the fact.

Time to level up your automated development

Treat your LLM as a full dev team

The development cycle with GSD is built to be simple, with short commands that handle one aspect in sequence. Initialize, Discuss, Plan, Execute, Verify, Repeat -> Ship. It's genius in how well it hides the complexity of the process from the user, while still getting all the required information, so you still feel like you're in charge.

The initial project phase points you in the right direction to create a very brief overview of your build, but it doesn't flesh it out. You end up with a sentence describing each phase, which you can yolo and see what it comes up with in the end, or go into the discuss phase to expand on layouts, UI, API decisions, error handling, login details, and anything else that crops up.

GSD creates subagents as needed to split the work into parallel development cycles

Once you've answered the initial questions (with or without the discussion phase), it's time to plan. This spawns four subagents for research, then plans and verifies the plan based on what they return. That's the phase that got me close to the million token window on Opus, which could have become a problem.

But it's not just the workload that it manages. It tracks the context window, and when it starts to fill up it'll suggest a suitable stopping point, so you can clear the chat and start with a fresh context window for the next phase. That makes it so much more usable than vibe coding purely with your LLM of choice, which won't tell you if the context is getting close or will compact the data, losing valuable context in the process.

LLMs can spawn their own subagents but tools like GSD keep them on track

The sheer number of tools built around LLM harnesses never fails to impress me, and GSD is one of the better ones I've used. It puts guardrails and guidance into the LLM at every stage, and makes me feel like an engineering manager and not a lone coder. It's now an indispensable part of my workflow, and I've got so many ideas for things to build.