Table of Contents
- Introduction
- The Context Rot Problem
- Understanding Spec-Driven Development
- Meta-Prompting and Context Engineering Fundamentals
- The GSD Framework: A Practical Solution
- Workflow Phases and Execution
- Real-World Applications and Benefits
- Comparing GSD to Alternative Frameworks
- Implementation Best Practices
- Future of AI-Assisted Development
- Resources
Introduction
The landscape of software development has fundamentally shifted. Where developers once wrote code alone or in teams using traditional methodologies, they now collaborate with AI assistants capable of understanding complex requirements, generating functional code, and debugging issues in real-time. Yet this technological leap has introduced a paradox: as conversations with AI assistants grow longer and more complex, the quality of their output often degrades. This phenomenon, known as context rot, represents one of the most significant challenges in modern AI-assisted development.
Enter Get Shit Done (GSD), an open-source meta-prompting and spec-driven development system that addresses this exact problem[1][2]. Rather than treating AI interaction as an endless chat session, GSD structures development into discrete phases, each operating within a fresh context window. This approach preserves AI quality throughout the entire project lifecycle while maintaining clear documentation, atomic commits, and verifiable results.
This article explores how context engineering and spec-driven workflows are revolutionizing the way developers build software with AI, examining the underlying principles, practical implementation, and the broader implications for the future of development practices.
The Context Rot Problem
Understanding the Challenge
Large language models like Claude, GPT-4, and Gemini operate within context windows—the maximum amount of text they can process in a single conversation. While these windows have grown substantially (Claude 3.5 Sonnet supports 200K tokens, for example), they are still finite. As a development session progresses, the conversation history accumulates, consuming more of this limited space.
The problem isn’t merely one of space. As context windows fill, several degradation patterns emerge:
Quality Degradation: AI assistants become less attentive to earlier requirements and constraints. A requirement mentioned in message five might be forgotten by message fifty, leading to implementations that contradict earlier specifications.
Attention Drift: The model’s focus naturally gravitates toward recent messages. Early architectural decisions, design patterns, and project constraints fade from active consideration, resulting in inconsistent code quality and architectural violations.
Token Inefficiency: As the context grows, the model spends more tokens processing history rather than generating new, relevant content. This reduces the proportion of the context window available for actual development work.
Inconsistent Behavior: Different parts of a large project may be implemented with different coding styles, patterns, and quality levels, simply because the context window shifted between implementations.
Consider a typical scenario: A developer starts a new project with Claude Code, establishing clear requirements and architecture. The first few functions are implemented beautifully, following SOLID principles and the established patterns. By the time the developer reaches the tenth feature, the context window is 70% full. The eleventh feature is implemented with a slightly different pattern. By the twentieth feature, the implementations are inconsistent, the original architectural principles are ignored, and the code quality has noticeably declined.
This isn’t a failure of the AI model—it’s a failure of the workflow. The traditional chat-based approach to AI-assisted development doesn’t account for the model’s inherent limitations.
Why Traditional Workflows Fall Short
Developers accustomed to tools like GitHub Copilot or ChatGPT might initially approach AI-assisted development as an extended conversation. They ask questions, receive code, iterate, and continue the dialogue. This works reasonably well for small tasks, but breaks down at scale.
The problem compounds when developers try to implement enterprise-scale features or multi-module systems. They’re essentially asking the AI to maintain a coherent understanding of an increasingly complex system while operating under resource constraints that make that increasingly difficult.
Traditional project management approaches (story points, sprint ceremonies, enterprise processes) don’t translate well to AI collaboration either. The AI doesn’t benefit from retrospectives or sprint planning in the way human teams do. What it needs is a fundamentally different approach to structuring work.
Understanding Spec-Driven Development
The Specification-First Approach
Spec-driven development (SDD) inverts the traditional development workflow. Instead of starting with code, developers begin with a detailed specification—a Product Requirements Document (PRD) that clearly articulates what should be built, why it should be built, and how it should behave.
This approach has deep roots in software engineering. Formal specification languages like Z notation and TLA+ have been used in critical systems for decades. However, spec-driven development in the AI context is more pragmatic and less formal than these academic approaches.
A specification in the GSD context includes:
- Requirements Analysis: What features are required? What’s in scope, and what’s explicitly out of scope?
- Architecture Overview: How should the system be organized at a high level?
- Data Models: What entities exist, and how do they relate?
- API Contracts: What interfaces should the system expose?
- Acceptance Criteria: How will we know when each requirement is satisfied?
Why Specs Work with AI
Specifications work exceptionally well with AI for several reasons:
Clarity and Precision: A well-written specification eliminates ambiguity. Instead of the AI inferring requirements from vague requests, it has explicit, detailed guidance.
Reduced Back-and-Forth: Rather than iterating through multiple clarification rounds, the specification captures all necessary context upfront. This reduces the conversation overhead and preserves context window space.
Verifiability: Specifications include acceptance criteria. The AI can check its own work against these criteria, catching errors before they propagate through the codebase.
Modularity: Specifications naturally decompose large projects into smaller, manageable components. Each component can be developed in isolation with a fresh context window.
Documentation Generation: A specification serves as the foundation for all project documentation. As development progresses, the specification becomes the source of truth for understanding the system.
Meta-Prompting and Context Engineering Fundamentals
What is Meta-Prompting?
Meta-prompting refers to the practice of creating prompts that guide an AI’s approach to problem-solving, rather than simply asking it to solve a problem directly. A meta-prompt establishes the framework, methodology, and constraints within which the AI operates.
For example, instead of asking “Build a user authentication system,” a meta-prompt might be:
You are implementing a user authentication system. Follow these steps:
1. Review the specification at [location]
2. Extract all authentication-related requirements
3. Design the data schema
4. Implement each component according to the spec
5. Verify each implementation against acceptance criteria
6. Generate commit messages following conventional commits
Work methodically. After each step, confirm you've completed it before proceeding.
This meta-prompt establishes a structured approach, references the specification, and includes verification steps. The AI now operates within a clear framework rather than making ad-hoc decisions.
Context Engineering Principles
Context engineering is the practice of strategically structuring information to maximize an AI model’s ability to produce high-quality output. Key principles include:
Recency Bias Mitigation: Place the most critical information (current task, relevant specs, recent decisions) near the end of the context, where the model’s attention is strongest.
Hierarchical Organization: Structure information from general to specific. Start with project overview, then module details, then specific implementation tasks.
Explicit State Management: Rather than relying on the model to remember previous decisions, explicitly state the current project state, completed work, and remaining tasks.
Fresh Context Windows: Instead of maintaining one massive conversation, regularly clear the context and start fresh, carrying forward only essential state information.
Atomic Task Boundaries: Break work into tasks small enough to fit comfortably within a context window with room to spare (GSD targets ~50% context utilization).
These principles work together to create an environment where AI assistants can operate at peak efficiency throughout the entire project lifecycle.
The GSD Framework: A Practical Solution
Framework Overview
Get Shit Done synthesizes these concepts into a practical, lightweight framework designed specifically for AI-assisted development[1][2]. Rather than imposing heavyweight enterprise processes, GSD provides just enough structure to maintain quality and clarity without bureaucratic overhead.
The framework is deliberately named to reflect its philosophy: eliminate unnecessary complexity and focus on getting work done effectively. This contrasts sharply with frameworks that emphasize process over outcomes.
Core Features
AI-Assisted Spec-Driven Planning: GSD begins with a discussion phase where the AI helps refine requirements and create a comprehensive specification. This ensures clarity before implementation begins[2][3].
Context Engineering: The framework explicitly manages context windows. Projects are divided into phases, each designed to operate within a fresh context window while maintaining clear state information[3].
Structured Multi-Phase Lifecycle: Instead of ad-hoc development, GSD defines distinct phases: discuss, plan, execute, and verify. Each phase has clear inputs, outputs, and success criteria[2].
Cross-Platform CLI Integration: GSD provides command-line tools (like npx get-shit-done-cc) that work across Mac, Windows, and Linux, making it accessible to developers regardless of their platform[1][2].
Atomic Commits and Task Verification: The framework encourages atomic, well-documented commits and includes verification steps to ensure each task is completed correctly[1].
Multi-Assistant Support: While originally designed for Claude Code, GSD now supports OpenCode, Gemini CLI, and other AI assistants, with ongoing expansion to additional platforms[1][2][3].
Persistent State Management: GSD maintains structured state throughout the project, allowing developers to clear context windows and resume work without losing progress or context[3].
Workflow Phases and Execution
Phase 1: Initialize and Discuss
The project begins with initialization, where the developer provides a high-level vision or Product Requirements Document. The AI then engages in a structured discussion to:
- Clarify ambiguous requirements
- Identify potential challenges or constraints
- Suggest architectural approaches
- Define the scope (what’s in v1, v2, and out of scope)
- Ask clarifying questions about the target audience, performance requirements, and integration needs
This phase produces a refined specification that serves as the foundation for all subsequent work. The discussion is thorough but concise—typically completed in a single context window.
Phase 2: Research and Planning
With a clear specification in hand, the AI performs research and creates a detailed roadmap. This phase includes:
Requirements Extraction: The specification is analyzed to extract all requirements, organizing them by priority and version (v1, v2, future).
Roadmap Creation: Requirements are mapped to development phases. Each phase is sized to be completable within a fresh context window while delivering meaningful functionality.
Architecture Design: The AI proposes a system architecture that accommodates the requirements while following established patterns and best practices.
Technology Selection: Appropriate technologies, libraries, and frameworks are selected based on the requirements and constraints.
The output of this phase is a detailed roadmap that the developer reviews and approves. This roadmap becomes the guide for execution.
Phase 3: Execute
Execution follows the roadmap phase by phase. Each phase is designed to:
- Fit within a fresh context window
- Deliver a complete, testable unit of functionality
- Build upon previous phases without requiring their full context
The AI implements code according to the specification, creates tests, and generates documentation. The developer provides feedback, requests adjustments, and approves the work.
Critically, each phase starts with a fresh context window. The AI receives:
- The relevant portion of the specification
- The current project state
- The specific tasks for this phase
- Any relevant code from previous phases
This approach prevents context rot while maintaining continuity.
Phase 4: Verify
Each completed phase is verified against the specification’s acceptance criteria. Verification includes:
- Running tests and confirming they pass
- Reviewing code against architectural principles
- Checking that all requirements are met
- Ensuring consistency with previous phases
If verification identifies issues, they’re addressed before moving forward.
Iteration and Completion
The process repeats for each phase until all requirements are implemented. The developer can pause, resume, and iterate as needed. The persistent state means no work is lost, and the fresh context windows mean quality remains consistent throughout.
Real-World Applications and Benefits
Solo Developers and Small Teams
GSD is particularly valuable for solo developers and small teams. These developers often lack the resources for dedicated project managers, architects, or QA specialists. GSD effectively provides these functions through structured AI collaboration.
A solo developer can now:
- Get help refining requirements and architecture
- Maintain consistent code quality throughout a project
- Generate documentation automatically
- Verify work against specifications
- Manage complex projects that would previously require a team
Rapid Prototyping
The framework accelerates prototyping. A developer can move from idea to working prototype in a single day by:
- Discussing the idea with the AI to refine it (30 minutes)
- Creating a specification and roadmap (30 minutes)
- Executing the first phase (2-3 hours)
- Reviewing and iterating (1 hour)
This rapid feedback loop is invaluable for validating ideas before committing significant resources.
Scaling Development Efforts
As projects grow, GSD’s structured approach becomes increasingly valuable. Large projects naturally decompose into multiple phases, each managed independently. This allows:
- Multiple developers to work on different phases in parallel
- Clear handoff points between developers
- Consistent quality across the entire codebase
- Easy onboarding of new team members (they can review specifications and previous phases)
Maintaining Code Quality
By preventing context rot, GSD maintains consistent code quality throughout the project. Early implementations don’t degrade as the project grows. This reduces technical debt and makes the codebase easier to maintain long-term.
Reducing Iteration Cycles
Because specifications are detailed and verified, fewer iterations are needed. The AI understands requirements precisely, reducing misunderstandings and rework.
Comparing GSD to Alternative Frameworks
GSD vs. SpecKit
SpecKit is another spec-driven framework for AI-assisted development. Both emphasize specifications and structured workflows. However, GSD places greater emphasis on context engineering and fresh context windows. GSD also provides more explicit support for phase-based development and persistent state management[3].
GSD vs. BMAD (Build More, Ask Deeper)
BMAD focuses on having the AI build more while asking deeper questions about requirements. While valuable, BMAD doesn’t explicitly address context rot. GSD combines BMAD’s philosophy with context engineering to maintain quality at scale[3].
GSD vs. Superpowers
Superpowers is a framework emphasizing AI capabilities and delegation. GSD is more prescriptive about workflow structure and context management. Where Superpowers encourages leveraging AI capabilities, GSD provides a framework for doing so sustainably[3].
GSD vs. Traditional Agile
Unlike traditional Agile (with story points, sprint ceremonies, and retrospectives), GSD is lightweight and optimized specifically for AI collaboration. It doesn’t require the overhead of traditional Agile while still providing structure and predictability.
Implementation Best Practices
Starting with GSD
To implement GSD effectively:
1. Begin with a Clear Vision: Before engaging the AI, have a clear idea of what you want to build. This doesn’t need to be exhaustive, but should articulate the core problem you’re solving.
2. Create a Detailed Specification: Work with the AI to create a comprehensive specification. This is time well spent—it prevents misunderstandings later.
3. Establish Clear Acceptance Criteria: For each requirement, define how you’ll know it’s complete. This makes verification straightforward.
4. Size Phases Appropriately: Each phase should be completable in a few hours and fit comfortably within a context window. If a phase is too large, break it down further.
5. Maintain Clear State: Document what’s been completed, what’s in progress, and what remains. This state is your lifeline when starting fresh context windows.
6. Review and Verify Thoroughly: Don’t skip verification. This is where you catch issues before they propagate.
Advanced Techniques
Specification Versioning: As requirements evolve, version your specifications. Keep the current version clear, and document how changes affect the roadmap.
Phase Interdependencies: Be explicit about which phases depend on others. This helps with parallel development and understanding the critical path.
Context Window Budgeting: Monitor how much context each phase uses. If a phase consistently uses more than 60% of the context window, it’s too large and should be split.
Documentation Generation: Let the AI generate documentation from specifications and code. This keeps documentation in sync with implementation.
Automated Testing: Include test generation in your execution phases. Tests serve as executable specifications and catch regressions.
Future of AI-Assisted Development
Evolution of Frameworks
As AI capabilities improve and context windows expand, frameworks like GSD will evolve. We’ll likely see:
Adaptive Context Management: Future frameworks will dynamically adjust context window management based on task complexity and AI capabilities.
Integrated Verification: Verification will become increasingly automated, with AI systems checking their own work against specifications and best practices.
Cross-Project Learning: Frameworks will learn from previous projects, improving estimates and recommendations for new projects.
Multi-AI Orchestration: As different AI models excel at different tasks, frameworks will orchestrate work across multiple AI assistants, each handling tasks suited to their strengths.
Broader Implications
The success of frameworks like GSD suggests a fundamental shift in how software development will be conducted:
Specification-First Development: Specifications will become as important as code. Developers will spend more time clarifying requirements upfront and less time debugging misunderstandings.
Reduced Context Switching: By structuring work into discrete phases, developers will experience less context switching and maintain better focus.
Quality as Default: Rather than quality being something you achieve through testing and iteration, it becomes the default when using well-structured workflows with AI assistance.
Democratization of Development: Complex projects that previously required large teams will become accessible to smaller teams and solo developers using AI-assisted frameworks.
Conclusion
Get Shit Done represents a maturation in how developers collaborate with AI assistants. Rather than treating AI as a chat interface for ad-hoc coding, GSD provides a structured framework that leverages AI’s strengths while mitigating its limitations.
The framework addresses the fundamental challenge of context rot through context engineering and fresh context windows. It enforces specification-driven development, ensuring clarity and verifiability. It’s lightweight enough for solo developers but scalable for larger teams.
Most importantly, GSD demonstrates that the future of software development isn’t about replacing developers with AI—it’s about developing frameworks and practices that allow developers and AI to collaborate effectively at scale. The developers who master these frameworks and practices will be able to build more, faster, with better quality than ever before.
As AI capabilities continue to improve, the frameworks we use to structure that collaboration will become increasingly important. GSD and similar frameworks are laying the groundwork for a new era of software development—one where clarity, structure, and strategic use of AI create unprecedented productivity and quality.