Introduction to Get Shit Done
The realm of software development has evolved dramatically over the years, particularly with the advent of Artificial Intelligence (AI) coding assistants. One such innovative framework designed to enhance productivity and streamline workflows is Get Shit Done (GSD). This meta-prompting and context-engineering framework is tailored for AI coding assistants, including Claude Code, OpenCode, Gemini CLI, and Codex. Its primary objective is to support spec-driven development workflows, ensuring that developers can efficiently manage their tasks from inception to deployment.
The Essence of Get Shit Done
At its core, GSD is designed to tackle some of the most pressing challenges faced by developers today, particularly the issue of context rot. This phenomenon refers to the degradation of context quality that occurs as AI assistants fill their context windows. By addressing this issue, GSD empowers developers to maintain clarity and focus throughout the development process.
📹 Video: This Is How AI Will Change Your Workflow
Video credit: Alex Hormozi
GSD introduces a structured approach through a series of well-defined phases: discuss, plan, execute, verify, and ship. This framework not only organizes tasks effectively but also emphasizes the importance of fresh context for each stage of development. As a result, developers can leverage AI to enhance their productivity significantly.
Why GSD Was Developed
The inception of GSD was driven by the experiences of solo developers who needed a streamlined tool that diverged from the complexities associated with larger engineering organizations. Traditional tools often incorporate extensive processes such as sprint ceremonies, story points, and rigorous stakeholder syncs, which can hinder creativity and flexibility. GSD, on the other hand, minimizes complexity and maximizes efficiency, allowing developers to focus on building great products.
Understanding the GSD Framework
The Get Shit Done framework operates through a series of six commands that guide users through the development process. Each command is designed to accomplish a specific task, ensuring clarity and efficiency at every step.
1. Initialize: Setting the Foundation
The first step in the GSD workflow is to initialize the project using the command /gsd-new-project. This command prompts developers to answer questions that lead to research, requirements gathering, and the creation of a roadmap. Once approved, this roadmap serves as the foundation for subsequent phases.
If developers already have existing code, they can run the command /gsd-map-codebase to analyze their stack, architecture, and conventions. This preliminary analysis ensures that the questions posed during the initialization phase are relevant and tailored to the specific project.
2. Discuss: Capturing Vision and Decisions
The second command, /gsd-discuss-phase 1, allows developers to elaborate on their project vision. A roadmap typically provides a high-level overview, but discussions can uncover the finer details necessary for successful implementation. This phase captures decisions regarding layouts, API structures, error handling, and data management, addressing any uncertainties before planning begins.
The insights gleaned from this discussion phase feed directly into the planning stage, ensuring that developers have a comprehensive understanding of their project requirements.
3. Plan: Strategizing Development
After discussion, the next step is planning. The command /gsd-plan-phase 1 initiates a loop of research, planning, and verification until the plans are deemed satisfactory. Each plan is crafted to be manageable, allowing execution to occur within a fresh context window. This ensures that developers have the necessary clarity and focus when moving forward.
4. Execute: Bringing Plans to Life
Execution is where ideas transform into tangible outcomes. Using the command /gsd-execute-phase 1, developers can run plans in parallel waves, utilizing subagents that operate with fresh context windows. Each task is assigned an atomic commit, allowing for a clean git history that reflects the completed work.
With a primary context window maintained at 30-40%, developers can step away from the workflow and return to find completed tasks ready for review.
5. Verify: Ensuring Quality and Functionality
Verification is a crucial step in maintaining the integrity of the development process. The command /gsd-verify-work 1 allows developers to review the work that has been built. If any issues are identified, they can generate a diagnosis and a fix plan that is ready for immediate re-execution. This automated feedback loop eliminates the need for manual debugging, simplifying the verification process.
6. Repeat and Ship: Finalizing Development
Once the verification phase is complete, the workflow proceeds to the final commands: /gsd-ship 1, /gsd-complete-milestone, and /gsd-new-milestone. These commands facilitate the transition from development to deployment, allowing developers to loop through the discuss, plan, execute, verify, and ship phases until a milestone is achieved. Once completed, developers can archive, tag, and start a new milestone with a clean slate.
Benefits of Using GSD Framework in Software Development
The implementation of the Get Shit Done framework offers several advantages that can significantly enhance the software development experience:
Increased Efficiency: By breaking down the development process into manageable phases and utilizing AI for task execution, developers can complete projects faster and with reduced effort.
Enhanced Clarity: The structured approach minimizes confusion and ensures that all team members have a clear understanding of project objectives and requirements.
Improved Quality: The verification phase allows for immediate identification and resolution of issues, leading to higher-quality outputs.
Streamlined Collaboration: GSD is designed for both solo developers and larger teams, facilitating collaborative efforts without the overhead of cumbersome project management tools.
Flexibility: The framework can be adapted to various development environments and workflows, making it a versatile tool for developers across different industries.
Who Can Benefit from the GSD Framework?
The Get Shit Done framework is particularly beneficial for:
Solo Developers: Individual developers looking for an efficient way to manage their projects can leverage GSD to streamline their workflows.
Small to Medium-Sized Teams: Teams with limited resources can benefit from the automation and structure provided by GSD, allowing them to maximize their productivity without the need for extensive project management infrastructure.
Freelancers: Freelancers working on multiple projects can use GSD to keep track of their tasks, ensuring that they meet deadlines and maintain quality.
Startups: New ventures can utilize GSD to establish a solid development foundation, enabling them to build and launch products quickly and effectively.
Getting Started with Get Shit Done
To begin using the Get Shit Done framework, developers can install it via the command line with:
npx get-shit-done-cc@latest
This command prompts users to select their runtime environment, whether it be Claude Code, OpenCode, Gemini CLI, or others, and offers the choice of a global or local installation. Users can also configure their installation to include only the skills they require, fostering a more personalized experience.
Conclusion: The Future of AI-Powered Development
The Get Shit Done framework represents a significant step forward in the evolution of software development, particularly in the context of AI-powered tools. By addressing the challenges of context rot and providing a streamlined workflow, GSD empowers developers to focus on what truly matters: building high-quality products efficiently. As the landscape of technology continues to evolve, frameworks like GSD will play a crucial role in shaping the future of software development.
People Also Ask
What is Get Shit Done?
Get Shit Done is a lightweight meta-prompting and context-engineering framework designed for AI coding assistants, aimed at enhancing productivity through a structured development process.
How does the GSD framework work?
The GSD framework operates through a series of six commands that guide developers through the phases of initialization, discussion, planning, execution, verification, and shipping.
Which AI coding tools does Get Shit Done support?
GSD supports various AI coding tools, including Claude Code, OpenCode, Gemini CLI, Codex, Copilot, and others.
What is spec-driven development?
Spec-driven development is an approach that emphasizes the importance of specifications in guiding the development process, ensuring that the final product aligns with the original vision and requirements.
How does the discuss-plan-execute-verify-ship loop work?
This loop involves discussing project details, planning tasks, executing them in parallel, verifying the results, and eventually shipping the completed work, allowing for iterative development and continuous improvement.
Sources & References
Original Source: https://github.com/gsd-build/get-shit-done
### Additional Resources
- [GitHub Repository](https://github.com/gsd-build/get-shit-done)
- [README](https://github.com/gsd-build/get-shit-done/blob/main/README.md)
- [User Guide](https://github.com/gsd-build/get-shit-done/blob/main/docs/USER-GUIDE.md)
- [Official Documentation](https://gsd-build-get-shit-done.mintlify.app)
Top comments (0)