Quickstart

Get your first project running with Get Shit Done in minutes

This guide walks you through creating your first project with GSD, from installation to your first working feature.

Prerequisites

Before starting, make sure you have:

• Claude Code, OpenCode, Gemini CLI, or Codex installed
• GSD installed (see installation guide)
• A project idea or existing codebase

Step 1: Install GSD

If you haven’t already, install GSD:

npx get-shit-done-cc@latest

Choose your runtime and installation location when prompted.

For existing codebases, run /gsd:map-codebase before starting a new project. This analyzes your stack, architecture, and conventions so GSD can work with your existing patterns.

Step 2: Start Your Runtime

Launch your AI coding assistant with recommended settings:

claude --dangerously-skip-permissions

This flag prevents friction from repeated permission prompts. GSD is designed for automated workflows.

Step 3: Initialize Your Project

Run the project initialization command:

/gsd:new-project

What Happens Next

GSD will guide you through a structured conversation:

1. Questions

   GSD asks about your project until it understands:

   • What you’re building
   • Technical constraints and preferences
   • Edge cases and requirements
   • What’s v1 vs v2
2. Research (Optional)

   GSD spawns parallel agents to investigate:

   • Stack and technology choices
   • Similar features in the ecosystem
   • Architecture patterns
   • Common pitfalls
3. Requirements

   GSD extracts and structures:

   • v1 must-haves
   • v2 nice-to-haves
   • Out of scope items
   • Acceptance criteria
4. Roadmap

   GSD creates phases mapped to requirements:

   • Phase 1: Foundation
   • Phase 2: Core features
   • Phase 3: Polish
   • …

Review and approve the roadmap. You’re now ready to build.

Expected Output

GSD creates these files in .planning/:

.planning/
  PROJECT.md         # Project vision and context
  REQUIREMENTS.md    # Scoped requirements with IDs
  ROADMAP.md         # Phase breakdown
  STATE.md           # Session memory
  config.json        # Workflow configuration
  research/          # Domain research (if enabled)

Step 4: Shape Your Implementation

Before planning, capture your implementation preferences:

/gsd:discuss-phase 1

GSD analyzes the phase and asks about gray areas:

• Visual features → Layout, density, interactions, empty states
• APIs/CLIs → Response format, flags, error handling
• Content systems → Structure, tone, depth
• Organization → Grouping criteria, naming conventions

The deeper you go here, the more GSD builds what you actually want. Skip it and you get reasonable defaults.

Step 5: Plan the Phase

Create execution plans for the phase:

/gsd:plan-phase 1

Planning Process

GSD orchestrates multiple agents:

1. Research

   4 parallel agents investigate:

   • Stack patterns and libraries
   • Feature implementation approaches
   • Architecture decisions
   • Common pitfalls to avoid
2. Planning

   Planner creates 2-3 atomic task plans with XML structure:

   <task type="auto">
     <name>Create login endpoint</name>
     <files>src/app/api/auth/login/route.ts</files>
     <action>
       Use jose for JWT (not jsonwebtoken).
       Validate credentials against users table.
       Return httpOnly cookie on success.
     </action>
     <verify>curl POST localhost:3000/api/auth/login returns 200</verify>
   </task>
   
3. Verification

   Plan checker verifies plans against requirements and loops until they pass (up to 3 iterations).

Expected Output

.planning/phases/01-foundation/
  01-RESEARCH.md      # Domain research findings
  01-01-PLAN.md       # First atomic task plan
  01-02-PLAN.md       # Second atomic task plan
  CONTEXT.md          # Your implementation preferences

Step 6: Execute the Phase

Run all plans in parallel waves:

/gsd:execute-phase 1

Execution Flow

GSD orchestrates parallel execution:

WAVE 1 (parallel)          WAVE 2 (parallel)
┌─────────┐ ┌─────────┐    ┌─────────┐
│ Plan 01 │ │ Plan 02 │ →  │ Plan 03 │
│ User    │ │ Product │    │ Orders  │
│ Model   │ │ Model   │    │ API     │
└─────────┘ └─────────┘    └─────────┘

Key features:

• Fresh context per plan - 200k tokens purely for implementation
• Parallel execution - Independent plans run simultaneously
• Atomic commits - Every task gets its own commit
• Automatic verification - Checks codebase against phase goals

Expected Output

.planning/phases/01-foundation/
  01-01-SUMMARY.md         # Execution outcomes
  01-02-SUMMARY.md
  01-VERIFICATION.md       # Post-execution verification

Git commits:
abc123f feat(01-01): implement user model
def456g feat(01-02): implement product model

Walk away during execution. Come back to completed work with clean git history.

Step 7: Verify Your Work

Manually test that everything works:

/gsd:verify-work 1

Verification Process

1. Extract Deliverables

   GSD identifies what you should be able to do now:

   • “Can you create a new user?”
   • “Does the login form validate email?”
   • “Can you view the product list?”
2. Manual Testing

   Test each deliverable and respond:

   • Yes - It works
   • No - Describe what’s wrong
3. Auto-Diagnosis

   If something’s broken, GSD:

   • Spawns debug agents to find root causes
   • Creates verified fix plans
   • Ready for immediate re-execution

If everything passes, move to the next phase. If issues are found, run /gsd:execute-phase 1 again with the fix plans.

Step 8: Complete the Milestone

Repeat the cycle for all phases:

/gsd:discuss-phase 2
/gsd:plan-phase 2
/gsd:execute-phase 2
/gsd:verify-work 2
...

When all phases are done:

/gsd:audit-milestone       # Verify milestone achieved definition of done
/gsd:complete-milestone    # Archive milestone, tag release

Quick Mode for Ad-Hoc Tasks

For bug fixes, small features, or one-off tasks:

/gsd:quick

Prompt:

What do you want to do? "Add dark mode toggle to settings"

Quick mode gives you GSD guarantees (atomic commits, state tracking) with a faster path:

• Same planner + executor agents
• Skips research, plan checker, verifier
• Lives in .planning/quick/, not phases

Example: Complete First Phase

Here’s what a complete first phase looks like:

1. Initialize

   /gsd:new-project
   # Answer questions about a todo app
   # Approve roadmap with 3 phases
   
2. Discuss

   /gsd:discuss-phase 1
   # Choose card layout for todos
   # Decide on infinite scroll
   # Pick color scheme
   
3. Plan

   /gsd:plan-phase 1
   # GSD researches React component patterns
   # Creates 2 plans: database setup + API routes
   # Plan checker verifies against requirements
   
4. Execute

   /gsd:execute-phase 1
   # Wave 1: Both plans run in parallel
   # 2 atomic commits created
   # Verification confirms database + API working
   
5. Verify

   /gsd:verify-work 1
   # Test: Can create todos? ✓
   # Test: Can list todos? ✓
   # Test: Can delete todos? ✓
   # Phase 1 complete!
   

Navigation Tips

Check Your Progress

/gsd:progress              # Where am I? What's next?

Resume After a Break

/gsd:resume-work           # Restore full context from last session

Pause Mid-Phase

/gsd:pause-work            # Create handoff for next session

Common Patterns

New Project from Document

If you have a PRD or spec document:

/gsd:new-project --auto @prd.md

GSD auto-runs research, requirements, and roadmap from your document.

Existing Codebase

Before starting a new project on existing code:

/gsd:map-codebase          # Analyze stack, architecture, conventions
/gsd:new-project           # Questions focus on what you're ADDING

Urgent Mid-Milestone Work

Need to insert work between phases?

/gsd:insert-phase 3        # Insert between phases 3 and 4

Change Scope

Add or remove phases as needed:

/gsd:add-phase             # Append new phase to roadmap
/gsd:remove-phase 7        # Descope phase 7 and renumber

Next Steps

Configuration

Learn about config.json settings and model profiles

Core Concepts

Deep dive into context engineering and multi-agent orchestration

Commands

Complete command reference

Advanced Topics

Deep dive into architecture and agent system

Core Concepts

Deep dive into context engineering and multi-agent orchestration

Commands

Complete command reference

Advanced Topics

Deep dive into architecture and agent system

Commands

Complete reference for all GSD commands

Best Practices

Tips for getting the most out of GSD