thuongtin/GSD-Guide.md

## GSD-Guide.md

      
    Raw
  

              GSD-Guide.md
            
          
  tags
  
  
  type/guide
  ai/concept/vibe-coding
  ai/concept/agent
  ai/concept/context-engineering
  dev/workflow
  dev/framework/gsd
  dev/tool/claude-code
  dev/best-practices
  dev/open-source
  project/vibe-coding
  
  
Get Shit Done (GSD) – Hướng dẫn từ cơ bản đến thành thạo

Giới thiệu tổng quan

Get Shit Done (GSD) là một hệ thống meta-prompting, context engineering và spec-driven development nhẹ nhưng mạnh mẽ dành cho Claude Code, OpenCode và Gemini CLI. GSD giải quyết vấn đề context rot — sự suy giảm chất lượng xảy ra khi Claude lấp đầy context window — bằng cách chia nhỏ công việc thành các plans nhỏ, mỗi plan chạy trong context window sạch với đầy đủ 200K token.
Thông tin dự án:

Repository: github.com/gsd-build/get-shit-done
Tác giả: TÂCHES (@glittercowboy)
Giấy phép: MIT (miễn phí 100%, mã nguồn mở)
Ngôn ngữ: JavaScript 100%
Phiên bản hiện tại: v1.20.4 (cập nhật rất tích cực — 832+ commits)
Stars: ~15.3K ⭐ | Forks: ~1.4K | Contributors: 31
npm: npx get-shit-done-cc@latest
Hỗ trợ runtime: Claude Code, OpenCode, Gemini CLI
Platform: Mac, Windows, Linux
Discord: discord.gg/5JJgD5svVS


      graph TB
    CENTER["💥 GSD<br/>Get Shit Done"]

    subgraph context ["🧠 Context Engineering"]
        CE1["PROJECT.md · REQUIREMENTS.md"]
        CE2["ROADMAP.md · STATE.md"]
        CE3["PLAN.md (XML) · SUMMARY.md"]
    end

    subgraph agents ["🤖 Multi-Agent Orchestration"]
        AG1["4x Researchers (parallel)"]
        AG2["Planner + Plan Checker (loop)"]
        AG3["Executors (wave-based parallel)"]
        AG4["Verifier + Debugger"]
    end

    subgraph execution ["⚡ Execution Engine"]
        EX1["Wave-based Parallel Execution"]
        EX2["Fresh 200K Context Per Plan"]
        EX3["Atomic Git Commits Per Task"]
    end

    subgraph workflow ["🔄 Workflow"]
        WF1["discuss → plan → execute → verify"]
        WF2["Milestones · Quick Mode · Debug"]
    end

    CENTER --- context
    CENTER --- agents
    CENTER --- execution
    CENTER --- workflow

    style CENTER fill:#e74c3c,color:#fff,stroke:#c0392b,stroke-width:3px
    style context fill:#1e272e,color:#dfe6e9,stroke:#0984e3,stroke-width:2px
    style agents fill:#1e272e,color:#dfe6e9,stroke:#00b894,stroke-width:2px
    style execution fill:#1e272e,color:#dfe6e9,stroke:#e17055,stroke-width:2px
    style workflow fill:#1e272e,color:#dfe6e9,stroke:#fdcb6e,stroke-width:2px
    style CE1 fill:#0984e3,color:#fff,stroke:#74b9ff
    style CE2 fill:#0984e3,color:#fff,stroke:#74b9ff
    style CE3 fill:#0984e3,color:#fff,stroke:#74b9ff
    style AG1 fill:#00b894,color:#fff,stroke:#55efc4
    style AG2 fill:#00b894,color:#fff,stroke:#55efc4
    style AG3 fill:#00b894,color:#fff,stroke:#55efc4
    style AG4 fill:#00b894,color:#fff,stroke:#55efc4
    style EX1 fill:#e17055,color:#fff,stroke:#fab1a0
    style EX2 fill:#e17055,color:#fff,stroke:#fab1a0
    style EX3 fill:#e17055,color:#fff,stroke:#fab1a0
    style WF1 fill:#fdcb6e,color:#2d3436,stroke:#f9ca24
    style WF2 fill:#fdcb6e,color:#2d3436,stroke:#f9ca24

    
      Loading

  
Tại sao cần GSD?


"Vibecoding has a bad reputation. You describe what you want, AI generates code, and you get inconsistent garbage that falls apart at scale. GSD fixes that."

Các tool spec-driven development khác (BMAD, SpecKit, OpenSpec) thường rơi vào hai cực: hoặc quá phức tạp (sprint ceremonies, story points, stakeholder syncs, retrospectives) hoặc thiếu hiểu biết toàn cảnh về project. GSD lấy triết lý "complexity is in the system, not in your workflow" — behind the scenes là context engineering, XML prompt formatting, subagent orchestration và state management phức tạp. Nhưng user chỉ thấy vài commands đơn giản mà just works.
GSD dành cho ai? Những người muốn mô tả ý tưởng và có nó được xây dựng chính xác — mà không cần giả vờ đang điều hành một engineering org 50 người.
Triết lý cốt lõi


      graph LR
    P1["🧠 Context<br/>Engineering"] --> P2["📄 XML Prompt<br/>Formatting"]
    P2 --> P3["🤖 Multi-Agent<br/>Orchestration"]
    P3 --> P4["⚡ Fresh Context<br/>Per Plan"]
    P4 --> P5["✅ Atomic<br/>Git Commits"]
    P5 --> P6["🔍 Goal-Backward<br/>Verification"]

    style P1 fill:#e74c3c,color:#fff,stroke:#c0392b,stroke-width:2px
    style P2 fill:#0984e3,color:#fff,stroke:#74b9ff,stroke-width:2px
    style P3 fill:#00b894,color:#fff,stroke:#55efc4,stroke-width:2px
    style P4 fill:#e17055,color:#fff,stroke:#fab1a0,stroke-width:2px
    style P5 fill:#fdcb6e,color:#2d3436,stroke:#f9ca24,stroke-width:2px
    style P6 fill:#6c5ce7,color:#fff,stroke:#a29bfe,stroke-width:2px

    
      Loading

  
Context Engineering — Mỗi file (PROJECT.md, REQUIREMENTS.md, PLAN.md...) được thiết kế để cung cấp chính xác context mà Claude cần. Size limits dựa trên điểm mà chất lượng Claude bắt đầu suy giảm.
XML Prompt Formatting — Plans dùng XML structure tối ưu cho Claude: <task>, <action>, <verify>, <done>. Precise instructions, no guessing.
Multi-Agent Orchestration — Thin orchestrator spawn specialized agents → collect results → route to next step. Orchestrator không bao giờ làm việc nặng.
Fresh Context Per Plan — Mỗi plan executor nhận 200K tokens sạch. Zero accumulated garbage. Chất lượng ổn định từ đầu đến cuối.
Atomic Git Commits — Mỗi task = 1 commit riêng. Git bisect tìm chính xác task lỗi. Mỗi task revert độc lập.
Goal-Backward Verification — Không kiểm tra "tasks đã complete chưa?" mà kiểm tra "goal đã đạt được chưa?". Task complete ≠ Goal achieved.

GSD so với các phương pháp khác


Tiêu chí
Vibe Coding
BMAD Method
Ucai
bmalph
GSD


Tiếp cận
Prompt → Code
21 agent personas
Native plugin
BMAD + Ralph
Meta-prompting + context engineering


Planning
Không
Chi tiết (personas)
/plan + agents
BMAD-level
Research → Plan → Verify loop


Execution
Thủ công
Thủ công
/build 8-phase
Ralph loop
Wave-based parallel, fresh 200K/plan


Context rot
Nghiêm trọng
Giảm nhẹ
File-based chain
Fresh per story
Giải quyết triệt để


Verification
Không
Agent review
Agent + manual test
Không
Goal-backward 3-level + UAT


Git strategy
Không
Không
Không
Ralph auto-commit
Atomic per-task + branching strategies


Config/Profiles
Không
Không
Không
Không
3 model profiles + workflow toggles


Runtime
Claude Code
Claude Code
Claude Code
Claude Code
Claude Code + OpenCode + Gemini CLI


Complexity
Không
Cao
Thấp
Cao
Thấp cho user, cao cho system


Cài đặt và thiết lập

Yêu cầu


Claude Code (hoặc OpenCode / Gemini CLI)
Node.js (cho npx)
Git (khuyến nghị)

Cài đặt (1 lệnh)

npx get-shit-done-cc@latest
Installer sẽ hỏi:

Runtime — Claude Code, OpenCode, Gemini, hoặc tất cả
Location — Global (tất cả projects) hoặc Local (project hiện tại)

Cài đặt Non-Interactive (Docker, CI)

# Claude Code
npx get-shit-done-cc --claude --global    # Cài vào ~/.claude/
npx get-shit-done-cc --claude --local     # Cài vào ./.claude/

# OpenCode
npx get-shit-done-cc --opencode --global  # Cài vào ~/.config/opencode/

# Gemini CLI
npx get-shit-done-cc --gemini --global    # Cài vào ~/.gemini/

# Tất cả runtimes
npx get-shit-done-cc --all --global
Xác nhận cài đặt

Trong Claude Code, chạy:
/gsd:help

Khuyến nghị: Skip Permissions Mode

GSD được thiết kế cho frictionless automation. Chạy:
claude --dangerously-skip-permissions

Dừng lại approve date và git commit 50 lần defeats the purpose.

Alternative — Granular Permissions (nếu không muốn skip all):
{
  "permissions": {
    "allow": [
      "Bash(date:*)", "Bash(echo:*)", "Bash(cat:*)", "Bash(ls:*)",
      "Bash(mkdir:*)", "Bash(wc:*)", "Bash(head:*)", "Bash(tail:*)",
      "Bash(sort:*)", "Bash(grep:*)", "Bash(tr:*)",
      "Bash(git add:*)", "Bash(git commit:*)", "Bash(git status:*)",
      "Bash(git log:*)", "Bash(git diff:*)", "Bash(git tag:*)"
    ]
  }
}
Cập nhật

npx get-shit-done-cc@latest
Gỡ cài đặt

npx get-shit-done-cc --claude --global --uninstall
npx get-shit-done-cc --claude --local --uninstall

Kiến trúc tổng quan

Cấu trúc thư mục của GSD

get-shit-done/               # Repository
├── bin/                     # Installer scripts
│   └── install.js           # npx entry point
├── agents/                  # Agent definitions (Markdown + YAML frontmatter)
│   ├── gsd-planner.md       # Tạo execution plans
│   ├── gsd-executor.md      # Thực thi plans, atomic commits
│   ├── gsd-verifier.md      # Goal-backward verification
│   ├── gsd-plan-checker.md  # Verify plans trước execution
│   ├── gsd-phase-researcher.md  # Research per-phase
│   ├── gsd-project-researcher.md # Research project-level
│   ├── gsd-research-synthesizer.md # Tổng hợp research
│   ├── gsd-debugger.md      # Systematic debugging
│   ├── gsd-codebase-mapper.md # Phân tích codebase brownfield
│   ├── gsd-roadmapper.md    # Tạo roadmap
│   └── gsd-integration-checker.md # Kiểm tra integration
├── commands/gsd/            # Slash commands
│   ├── new-project.md       # /gsd:new-project
│   ├── discuss-phase.md     # /gsd:discuss-phase
│   ├── plan-phase.md        # /gsd:plan-phase
│   ├── execute-phase.md     # /gsd:execute-phase
│   ├── verify-work.md       # /gsd:verify-work
│   ├── quick.md             # /gsd:quick
│   ├── map-codebase.md      # /gsd:map-codebase
│   ├── progress.md          # /gsd:progress
│   ├── debug.md             # /gsd:debug
│   └── ... (20+ commands)
├── hooks/                   # Lifecycle hooks
├── scripts/                 # Utility scripts
├── get-shit-done/           # Core logic (gsd-tools, templates, workflows, references)
│   ├── bin/gsd-tools.cjs    # CLI tool: state, commit, roadmap, phases...
│   ├── templates/           # Summary, plan templates
│   ├── workflows/           # execute-plan, verify-phase workflows
│   └── references/          # Checkpoints, task types reference docs
└── docs/
    └── USER-GUIDE.md        # Detailed user guide

Cấu trúc project khi dùng GSD

your-project/
├── .planning/                    # GSD working directory
│   ├── PROJECT.md                # Vision, context (luôn loaded)
│   ├── REQUIREMENTS.md           # v1/v2 requirements + IDs + phase traceability
│   ├── ROADMAP.md                # Phases + status tracking
│   ├── STATE.md                  # Decisions, blockers, session memory
│   ├── config.json               # Workflow configuration
│   ├── MILESTONES.md             # Completed milestone archive
│   ├── research/                 # Domain research từ /gsd:new-project
│   ├── todos/
│   │   ├── pending/              # Ideas chờ xử lý
│   │   └── done/                 # Todos đã hoàn thành
│   ├── debug/                    # Active debug sessions
│   │   └── resolved/             # Archived debug sessions
│   ├── codebase/                 # Brownfield mapping (từ /gsd:map-codebase)
│   │   ├── STACK.md
│   │   ├── ARCHITECTURE.md
│   │   ├── CONVENTIONS.md
│   │   └── CONCERNS.md
│   ├── quick/                    # Quick mode tasks
│   └── phases/
│       └── XX-phase-name/
│           ├── XX-CONTEXT.md     # User preferences (từ discuss-phase)
│           ├── XX-RESEARCH.md    # Ecosystem research
│           ├── XX-YY-PLAN.md     # Atomic execution plans (XML)
│           ├── XX-YY-SUMMARY.md  # Execution outcomes + decisions
│           ├── XX-VERIFICATION.md # Post-execution verification
│           └── XX-UAT.md         # User acceptance testing results
└── ... (project source code)

Multi-Agent Orchestration Pattern

Mọi stage trong GSD đều dùng cùng một pattern: thin orchestrator spawns specialized agents → collects results → routes to next step. Orchestrator không bao giờ làm heavy lifting.

  
      graph TB
    subgraph research ["🔬 Research Stage"]
        RO["Orchestrator"] --> R1["Stack Researcher"]
        RO --> R2["Features Researcher"]
        RO --> R3["Architecture Researcher"]
        RO --> R4["Pitfalls Researcher"]
        R1 --> RO
        R2 --> RO
        R3 --> RO
        R4 --> RO
    end

    subgraph planning ["📋 Planning Stage"]
        PO["Orchestrator"] --> PL["Planner"]
        PL --> PC["Plan Checker"]
        PC -->|"FAIL"| PL
        PC -->|"PASS (max 3 loops)"| PO
    end

    subgraph execution ["⚡ Execution Stage"]
        EO["Orchestrator"] --> W1["Wave 1 (parallel)"]
        W1 --> EX1["Executor A<br/>fresh 200K"]
        W1 --> EX2["Executor B<br/>fresh 200K"]
        EO --> W2["Wave 2 (sequential)"]
        W2 --> EX3["Executor C<br/>fresh 200K"]
    end

    subgraph verification ["🔍 Verification Stage"]
        VO["Orchestrator"] --> VF["Verifier"]
        VF -->|"GAPS"| DB["Debugger"]
        VF -->|"PASS"| VO
    end

    research --> planning --> execution --> verification

    style RO fill:#0984e3,color:#fff,stroke:#74b9ff
    style PO fill:#00b894,color:#fff,stroke:#55efc4
    style EO fill:#e17055,color:#fff,stroke:#fab1a0
    style VO fill:#6c5ce7,color:#fff,stroke:#a29bfe
    style R1 fill:#0984e3,color:#fff,stroke:#74b9ff
    style R2 fill:#0984e3,color:#fff,stroke:#74b9ff
    style R3 fill:#0984e3,color:#fff,stroke:#74b9ff
    style R4 fill:#0984e3,color:#fff,stroke:#74b9ff
    style PL fill:#00b894,color:#fff,stroke:#55efc4
    style PC fill:#00b894,color:#fff,stroke:#55efc4
    style EX1 fill:#e17055,color:#fff,stroke:#fab1a0
    style EX2 fill:#e17055,color:#fff,stroke:#fab1a0
    style EX3 fill:#e17055,color:#fff,stroke:#fab1a0
    style VF fill:#6c5ce7,color:#fff,stroke:#a29bfe
    style DB fill:#6c5ce7,color:#fff,stroke:#a29bfe

    
      Loading

  
Kết quả: Chạy toàn bộ phase — deep research, nhiều plans được tạo + verified, hàng ngàn dòng code viết qua parallel executors, automated verification — mà main context window chỉ ở 30-40%. Work xảy ra trong fresh subagent contexts. Session luôn nhanh và responsive.

Deep Dive: Core Workflow (6 bước)

Bước 1: /gsd:new-project — Khởi tạo dự án


      graph TD
    START["🚀 /gsd:new-project"] --> Q["Phase 1: Questions<br/>Hỏi cho đến khi hiểu hoàn toàn"]
    Q --> R["Phase 2: Research<br/>4 agents song song (tùy chọn)"]
    R --> REQ["Phase 3: Requirements<br/>v1 / v2 / out of scope"]
    REQ --> ROAD["Phase 4: Roadmap<br/>Phases mapped to requirements"]
    ROAD --> APPROVE["👤 User approves roadmap"]

    style START fill:#e74c3c,color:#fff,stroke:#c0392b,stroke-width:2px
    style Q fill:#0984e3,color:#fff,stroke:#74b9ff
    style R fill:#00b894,color:#fff,stroke:#55efc4
    style REQ fill:#e17055,color:#fff,stroke:#fab1a0
    style ROAD fill:#6c5ce7,color:#fff,stroke:#a29bfe
    style APPROVE fill:#fdcb6e,color:#2d3436,stroke:#f9ca24,stroke-width:2px

    
      Loading

  
Cách dùng:
/gsd:new-project               # Interactive mode
/gsd:new-project --auto @prd.md  # Auto-run từ document có sẵn

Hệ thống sẽ:

Questions — Hỏi cho đến khi hiểu hoàn toàn ý tưởng: goals, constraints, tech preferences, edge cases
Research — Spawn 4 parallel agents nghiên cứu domain (optional nhưng recommended)
Requirements — Trích xuất v1, v2, và out of scope
Roadmap — Tạo phases mapped to requirements

Tạo ra: PROJECT.md, REQUIREMENTS.md, ROADMAP.md, STATE.md, .planning/research/

Bước 2: /gsd:discuss-phase — Định hình implementation

/gsd:discuss-phase 1

Đây là bước bạn shape cách implementation được thực hiện.
Roadmap chỉ có 1-2 câu per phase — chưa đủ context để build đúng ý bạn. Bước này capture preferences trước khi research và plan.
Hệ thống phân tích phase và identify gray areas dựa trên loại work:


Loại feature
Hỏi về


Visual features
Layout, density, interactions, empty states


APIs/CLIs
Response format, flags, error handling, verbosity


Content systems
Structure, tone, depth, flow


Organization tasks
Grouping criteria, naming, duplicates, exceptions


Output: {phase_num}-CONTEXT.md — feeds trực tiếp vào:

Researcher đọc nó → biết patterns nào cần investigate
Planner đọc nó → biết decisions nào đã locked


Đi sâu ở bước này = hệ thống build đúng vision của bạn. Skip nó = bạn nhận reasonable defaults.


Bước 3: /gsd:plan-phase — Research + Plan + Verify

/gsd:plan-phase 1


      graph TD
    START["🚀 /gsd:plan-phase N"] --> RESEARCH["Phase Researcher (4 parallel)<br/>Stack · Features · Architecture · Pitfalls"]
    RESEARCH --> PLAN["Planner<br/>Tạo 2-3 atomic plans (XML)"]
    PLAN --> CHECK{"Plan Checker<br/>Verify against requirements"}
    CHECK -->|"FAIL"| PLAN
    CHECK -->|"PASS (max 3 loops)"| DONE["Plans ready ✅"]

    style START fill:#e74c3c,color:#fff,stroke:#c0392b,stroke-width:2px
    style RESEARCH fill:#0984e3,color:#fff,stroke:#74b9ff
    style PLAN fill:#00b894,color:#fff,stroke:#55efc4
    style CHECK fill:#fdcb6e,color:#2d3436,stroke:#f9ca24
    style DONE fill:#00b894,color:#fff,stroke:#55efc4,stroke-width:2px

    
      Loading

  
Hệ thống sẽ:

Research — Investigate cách implement phase này, guided by CONTEXT.md
Plan — Tạo 2-3 atomic task plans với XML structure
Verify — Check plans against requirements, loop cho đến pass (max 3 lần)

Mỗi plan đủ nhỏ để execute trong fresh context window. Không degradation, không "I'll be more concise now."
Tạo ra: {phase_num}-RESEARCH.md, {phase_num}-{N}-PLAN.md
XML Plan 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 - CommonJS issues).
    Validate credentials against users table.
    Return httpOnly cookie on success.
  </action>
  <verify>curl -X POST localhost:3000/api/auth/login returns 200 + Set-Cookie</verify>
  <done>Valid credentials return cookie, invalid return 401</done>
</task>
4 required fields per task:


Field
Mô tả
Bad example
Good example


<files>
Exact file paths
"the auth files"
src/app/api/auth/login/route.ts


<action>
Specific instructions + what to avoid + WHY
"Add authentication"
"Create POST endpoint, validate bcrypt, return JWT httpOnly cookie 15-min. Use jose (not jsonwebtoken — CommonJS issues)"


<verify>
Prove task complete
"It works"
curl -X POST /api/auth/login returns 200 + Set-Cookie


<done>
Acceptance criteria
"Auth is complete"
"Valid credentials → 200 + JWT cookie, invalid → 401"


Context Budget Rule

Plans nên complete trong ~50% context (không phải 80%):


Context Usage
Quality
Claude's State


0-30%
PEAK
Thorough, comprehensive


30-50%
GOOD
Confident, solid work


50-70%
DEGRADING
Efficiency mode begins


70%+
POOR
Rushed, minimal


Mỗi plan: 2-3 tasks max. More plans, smaller scope, consistent quality.

Bước 4: /gsd:execute-phase — Parallel Wave Execution

/gsd:execute-phase 1


      graph TD
    START["🚀 /gsd:execute-phase N"] --> ANALYZE["Analyze plan dependencies"]
    ANALYZE --> W1["Wave 1 (parallel)"]
    W1 --> E1["Executor A<br/>fresh 200K context<br/>→ commit"]
    W1 --> E2["Executor B<br/>fresh 200K context<br/>→ commit"]
    E1 --> W2["Wave 2 (depends on Wave 1)"]
    E2 --> W2
    W2 --> E3["Executor C<br/>fresh 200K context<br/>→ commit"]
    E3 --> VERIFY["Verifier<br/>Check codebase vs goals"]
    VERIFY -->|"PASS"| DONE["VERIFICATION.md ✅"]
    VERIFY -->|"GAPS"| GAP["Issues logged for verify-work"]

    style START fill:#e74c3c,color:#fff,stroke:#c0392b,stroke-width:2px
    style ANALYZE fill:#0984e3,color:#fff,stroke:#74b9ff
    style W1 fill:#e17055,color:#fff,stroke:#fab1a0
    style W2 fill:#e17055,color:#fff,stroke:#fab1a0
    style E1 fill:#e17055,color:#fff,stroke:#fab1a0
    style E2 fill:#e17055,color:#fff,stroke:#fab1a0
    style E3 fill:#e17055,color:#fff,stroke:#fab1a0
    style VERIFY fill:#6c5ce7,color:#fff,stroke:#a29bfe
    style DONE fill:#00b894,color:#fff,stroke:#55efc4,stroke-width:2px
    style GAP fill:#fdcb6e,color:#2d3436,stroke:#f9ca24

    
      Loading

  
Hệ thống sẽ:

Group plans thành waves — Parallel nếu independent, sequential nếu dependent
Fresh context per plan — 200K tokens thuần cho implementation, zero accumulated garbage
Commit per task — Mỗi task = 1 atomic commit
Verify against goals — Check codebase delivers what phase promised

Wave Execution hoạt động thế nào:
┌─────────────────────────────────────────────────────────────┐
│  PHASE EXECUTION                                             │
├─────────────────────────────────────────────────────────────┤
│  WAVE 1 (parallel)        WAVE 2 (parallel)       WAVE 3   │
│  ┌─────────┐ ┌─────────┐  ┌─────────┐ ┌─────────┐ ┌──────┐│
│  │ Plan 01 │ │ Plan 02 │→ │ Plan 03 │ │ Plan 04 │→│Plan05││
│  │ User    │ │ Product │  │ Orders  │ │ Cart    │ │Check-││
│  │ Model   │ │ Model   │  │ API     │ │ API     │ │out UI││
│  └─────────┘ └─────────┘  └─────────┘ └─────────┘ └──────┘│
│       │           │             ↑           ↑          ↑    │
│       └───────────┴─────────────┴───────────┘          │    │
│              Plan 03 needs Plan 01                      │    │
│              Plan 04 needs Plan 02                      │    │
│              Plan 05 needs Plans 03 + 04                │    │
└─────────────────────────────────────────────────────────────┘

Vertical Slices (PREFER) vs Horizontal Layers (AVOID):


Vertical Slices ✅
Horizontal Layers ❌


Plan 01: User feature (model + API + UI)
Plan 01: All models


Plan 02: Product feature (model + API + UI)
Plan 02: All APIs


Plan 03: Order feature (model + API + UI)
Plan 03: All UIs


→ All 3 run parallel (Wave 1)
→ Fully sequential (02 needs 01, 03 needs 02)


Executor Deviation Rules:


Rule
Trigger
Action


Rule 1: Auto-fix bugs
Code doesn't work as intended
Fix inline, no user permission


Rule 2: Auto-add critical functionality
Missing error handling, validation, security
Fix inline, no user permission


Rule 3: Auto-fix blocking issues
Missing dependency, wrong types
Fix inline, no user permission


Rule 4: Ask about architectural changes
New DB table, switching libraries
STOP → checkpoint → user decision


Tạo ra: {phase_num}-{N}-SUMMARY.md, {phase_num}-VERIFICATION.md

Bước 5: /gsd:verify-work — User Acceptance Testing

/gsd:verify-work 1

Đây là bước bạn confirm nó thực sự hoạt động.
Automated verification check code exists và tests pass. Nhưng feature có work đúng như bạn expect? Đây là cơ hội để bạn dùng thử.
Hệ thống sẽ:

Extract testable deliverables — Bạn nên làm được gì bây giờ
Walk through từng cái một — "Can you log in with email?" Yes/no hoặc mô tả lỗi
Diagnose failures tự động — Spawn debug agents tìm root causes
Tạo verified fix plans — Sẵn sàng cho re-execution

Nếu pass → tiến sang phase tiếp. Nếu lỗi → không cần manual debug — chạy /gsd:execute-phase lại với fix plans.
Tạo ra: {phase_num}-UAT.md, fix plans nếu có issues

Bước 6: Repeat → Complete → Next Milestone

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

Loop discuss → plan → execute → verify cho mỗi phase.
Khi all phases done → /gsd:complete-milestone archive milestone và tag release.
→ /gsd:new-milestone bắt đầu version tiếp — cùng flow nhưng cho existing codebase.

Deep Dive: Agents

GSD có 11+ agents chuyên biệt, mỗi agent được tối ưu cho một vai trò cụ thể.


Agent
Color
Model (balanced)
Mission


gsd-planner
🟢 Green
Opus
Tạo execution plans với task breakdown, dependency analysis, goal-backward verification


gsd-executor
🟡 Yellow
Sonnet
Thực thi plans: atomic commits, deviation handling, checkpoint protocols


gsd-verifier
🟢 Green
Sonnet
Goal-backward verification 3 levels: exists → substantive → wired


gsd-plan-checker
—
Sonnet
Verify plans achieve phase goals trước execution


gsd-phase-researcher
—
Sonnet
Research per-phase: stack, features, architecture, pitfalls


gsd-project-researcher
—
Sonnet
Research project-level domain


gsd-research-synthesizer
—
Sonnet
Tổng hợp research findings


gsd-roadmapper
—
Sonnet
Tạo roadmap từ requirements


gsd-debugger
—
Sonnet
Systematic debugging với persistent state


gsd-codebase-mapper
—
Haiku
Phân tích existing codebase (brownfield)


gsd-integration-checker
—
Sonnet
Kiểm tra integration giữa các components


Goal-Backward Verification (gsd-verifier)

Đây là feature đặc biệt nhất của GSD. Thay vì check "tasks đã complete?", verifier check "goal đã đạt được?"
3 levels verification:

  
      graph TD
    GOAL["🎯 Phase Goal"] --> TRUTHS["Level 1: Observable Truths<br/>User can see messages?<br/>User can send messages?"]
    TRUTHS --> ARTIFACTS["Level 2: Required Artifacts<br/>Chat.tsx exists?<br/>Substantive (not stub)?"]
    ARTIFACTS --> WIRING["Level 3: Key Links (Wiring)<br/>Chat.tsx → /api/chat connected?<br/>API → database connected?"]

    TRUTHS --> STATUS1{"✓ VERIFIED<br/>✗ FAILED<br/>? UNCERTAIN"}
    ARTIFACTS --> STATUS2{"✓ VERIFIED<br/>✗ STUB<br/>✗ MISSING"}
    WIRING --> STATUS3{"WIRED<br/>ORPHANED<br/>PARTIAL"}

    style GOAL fill:#e74c3c,color:#fff,stroke:#c0392b,stroke-width:2px
    style TRUTHS fill:#0984e3,color:#fff,stroke:#74b9ff
    style ARTIFACTS fill:#00b894,color:#fff,stroke:#55efc4
    style WIRING fill:#6c5ce7,color:#fff,stroke:#a29bfe

    
      Loading

  
Tại sao cần 3 levels?

"A task 'create chat component' can be marked complete when the component is a placeholder. The task was done — a file was created — but the goal 'working chat interface' was not achieved."


Level
Kiểm tra
Phát hiện


Exists
File có tồn tại?
Missing files


Substantive
File có thật sự implement? Hay chỉ là stub/placeholder?
return <div>Placeholder</div>, empty handlers


Wired
Components có kết nối với nhau?
Fetch without response handling, state exists but not rendered


Deep Dive: Quick Mode

/gsd:quick

Cho ad-hoc tasks không cần full planning. Same agents (planner + executor), same quality, nhưng skip optional steps (no research, no plan checker, no verifier).
/gsd:quick
> What do you want to do? "Add dark mode toggle to settings"

--full flag cho quality guarantees trên quick tasks:
/gsd:quick --full

Spawn plan-checker (max 2 iterations) + post-execution verifier. Produces VERIFICATION.md.
Dùng cho: Bug fixes, small features, config changes, one-off tasks.

Deep Dive: Brownfield (Existing Codebase)

/gsd:map-codebase

Spawn parallel agents phân tích project hiện tại:

  
      graph TD
    MAP["/gsd:map-codebase"] --> S["Stack Mapper<br/>→ STACK.md"]
    MAP --> A["Arch Mapper<br/>→ ARCHITECTURE.md"]
    MAP --> C["Convention Mapper<br/>→ CONVENTIONS.md"]
    MAP --> CO["Concern Mapper<br/>→ CONCERNS.md"]
    S --> NP["/gsd:new-project<br/>Questions focus on what you're ADDING"]
    A --> NP
    C --> NP
    CO --> NP

    style MAP fill:#e74c3c,color:#fff,stroke:#c0392b,stroke-width:2px
    style S fill:#0984e3,color:#fff,stroke:#74b9ff
    style A fill:#0984e3,color:#fff,stroke:#74b9ff
    style C fill:#0984e3,color:#fff,stroke:#74b9ff
    style CO fill:#0984e3,color:#fff,stroke:#74b9ff
    style NP fill:#00b894,color:#fff,stroke:#55efc4,stroke-width:2px

    
      Loading

  
Sau khi map xong, /gsd:new-project đã biết codebase → questions focus vào what you're adding, planning tự động load patterns.

Tham chiếu Commands đầy đủ

Core Workflow


Command
Mô tả


/gsd:new-project [--auto]
Full initialization: questions → research → requirements → roadmap


/gsd:discuss-phase [N] [--auto]
Capture implementation decisions trước planning


/gsd:plan-phase [N] [--auto]
Research + plan + verify cho phase


/gsd:execute-phase <N>
Execute tất cả plans trong parallel waves, verify khi xong


/gsd:verify-work [N]
Manual user acceptance testing


/gsd:audit-milestone
Verify milestone đạt definition of done


/gsd:complete-milestone
Archive milestone, tag release


/gsd:new-milestone [name]
Bắt đầu version tiếp: questions → research → requirements → roadmap


Navigation


Command
Mô tả


/gsd:progress
Đang ở đâu? Cần làm gì tiếp?


/gsd:help
Hiển thị tất cả commands


/gsd:update
Cập nhật GSD với changelog preview


/gsd:pause-work
Tạo handoff khi dừng giữa phase


/gsd:resume-work
Restore context từ session trước


Phase Management


Command
Mô tả


/gsd:add-phase
Thêm phase vào cuối roadmap


/gsd:insert-phase [N]
Chèn urgent work giữa phases


/gsd:remove-phase [N]
Xóa future phase, đánh số lại


/gsd:list-phase-assumptions [N]
Xem approach Claude dự định trước khi plan


/gsd:plan-milestone-gaps
Tạo phases cho gaps từ audit


Brownfield & Utilities


Command
Mô tả


/gsd:map-codebase
Phân tích existing codebase trước new-project


/gsd:quick [--full]
Ad-hoc task với GSD guarantees


/gsd:debug [desc]
Systematic debugging với persistent state


/gsd:add-todo [desc]
Capture idea cho sau


/gsd:check-todos
List pending todos


/gsd:settings
Configure workflow toggles và model profile


/gsd:set-profile <profile>
Switch model profile (quality/balanced/budget)


/gsd:health [--repair]
Validate .planning/ integrity, auto-repair


Configuration

GSD lưu settings trong .planning/config.json. Config lúc /gsd:new-project hoặc update sau bằng /gsd:settings.
Core Settings


Setting
Options
Default
Mô tả


mode
yolo, interactive
interactive
Auto-approve vs confirm at each step


depth
quick, standard, comprehensive
standard
Planning thoroughness (3-5 / 5-8 / 8-12 phases)


Model Profiles

Control model nào mỗi agent dùng. Balance quality vs token spend.


Profile
Planning
Execution
Verification


quality
Opus
Opus
Sonnet


balanced (default)
Opus
Sonnet
Sonnet


budget
Sonnet
Sonnet
Haiku


/gsd:set-profile budget

Chi tiết per-agent:


Agent
quality
balanced
budget


gsd-planner
Opus
Opus
Sonnet


gsd-roadmapper
Opus
Sonnet
Sonnet


gsd-executor
Opus
Sonnet
Sonnet


gsd-phase-researcher
Opus
Sonnet
Haiku


gsd-verifier
Sonnet
Sonnet
Haiku


gsd-plan-checker
Sonnet
Sonnet
Haiku


gsd-codebase-mapper
Sonnet
Haiku
Haiku


Workflow Toggles


Setting
Default
Mô tả


workflow.research
true
Research domain trước planning


workflow.plan_check
true
Verify plans trước execution (loop max 3)


workflow.verifier
true
Confirm must-haves delivered sau execution


workflow.auto_advance
false
Auto-chain discuss → plan → execute không dừng


Override per-invocation:
/gsd:plan-phase --skip-research
/gsd:plan-phase --skip-verify

Git Branching


Setting
Options
Default
Mô tả


git.branching_strategy
none, phase, milestone
none
Branch creation strategy


Strategy
Tạo branch
Scope
Best for


none
Không bao giờ
N/A
Solo dev, simple projects


phase
Mỗi execute-phase
1 branch per phase
Code review per phase


milestone
Lần execute-phase đầu
All phases share 1 branch
Release branches, PR per version


Speed vs Quality Presets


Scenario
Mode
Depth
Profile
Research
Plan Check
Verifier


Prototyping
yolo
quick
budget
off
off
off


Normal dev
interactive
standard
balanced
on
on
on


Production
interactive
comprehensive
quality
on
on
on


Workflow thực tế

New Project (Full Cycle)

claude --dangerously-skip-permissions
/gsd:new-project            # Answer questions, configure, approve roadmap
/clear
/gsd:discuss-phase 1        # Lock in preferences
/gsd:plan-phase 1           # Research + plan + verify
/gsd:execute-phase 1        # Parallel execution
/gsd:verify-work 1          # Manual UAT
/clear
/gsd:discuss-phase 2        # Repeat for each phase
...
/gsd:audit-milestone        # Check everything shipped
/gsd:complete-milestone     # Archive, tag, done
Existing Codebase

/gsd:map-codebase           # Analyze what exists (parallel agents)
/gsd:new-project            # Questions focus on what you're ADDING
# (normal phase workflow from here)
Quick Bug Fix

/gsd:quick
> "Fix the login button not responding on mobile Safari"
Resuming After a Break

/gsd:progress               # See where you left off
# or
/gsd:resume-work            # Full context restoration
Mid-Milestone Scope Changes

/gsd:add-phase              # Append new phase
/gsd:insert-phase 3         # Insert urgent work between phases 3 and 4
/gsd:remove-phase 7         # Descope phase 7, renumber

Security

Bảo vệ Sensitive Files

GSD's codebase mapping đọc files để hiểu project. Protect files chứa secrets:
{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(**/secrets/*)",
      "Read(**/*credential*)",
      "Read(**/*.pem)",
      "Read(**/*.key)"
    ]
  }
}
GSD có built-in protections chống commit secrets, nhưng defense-in-depth là best practice.

Troubleshooting

Commands không tìm thấy sau install

Nguyên nhân & giải pháp:

Restart Claude Code để reload slash commands
Verify files tồn tại trong ~/.claude/commands/gsd/ (global) hoặc ./.claude/commands/gsd/ (local)
Re-run npx get-shit-done-cc@latest để reinstall

Context degradation trong long sessions

Giải pháp: Clear context window giữa major commands: /clear trong Claude Code. GSD designed around fresh contexts — mỗi subagent nhận clean 200K window. Nếu quality dropping → clear + /gsd:resume-work hoặc /gsd:progress.
Plans không đúng hoặc misaligned

Giải pháp: Chạy /gsd:discuss-phase [N] trước planning. Hầu hết plan quality issues do Claude making assumptions mà CONTEXT.md đã prevent. Hoặc chạy /gsd:list-phase-assumptions [N] để xem approach Claude dự định.
Execution fails hoặc produces stubs

Giải pháp: Check plan không quá ambitious. Plans nên 2-3 tasks max. Nếu tasks quá lớn → exceed single context window → re-plan with smaller scope.
Mất track tiến độ

Giải pháp: /gsd:progress — reads all state files, cho biết chính xác đang ở đâu và cần làm gì tiếp.
Cần sửa gì đó sau execution

Giải pháp: KHÔNG re-run /gsd:execute-phase. Dùng /gsd:quick cho targeted fixes, hoặc /gsd:verify-work để systematically identify issues qua UAT.
Model costs quá cao

Giải pháp: /gsd:set-profile budget. Disable research + plan-check agents qua /gsd:settings.
Docker/Container environments

Nếu file reads fail với tilde paths (~/.claude/...):
CLAUDE_CONFIG_DIR=/home/youruser/.claude npx get-shit-done-cc --global
Update overwrote local changes

Từ v1.17, installer backup locally modified files vào gsd-local-patches/. Chạy /gsd:reapply-patches để merge changes lại.
Recovery Quick Reference


Vấn đề
Giải pháp


Lost context / new session
/gsd:resume-work hoặc /gsd:progress


Phase went wrong
git revert phase commits, re-plan


Need to change scope
/gsd:add-phase, /gsd:insert-phase, /gsd:remove-phase


Milestone audit found gaps
/gsd:plan-milestone-gaps


Something broke
/gsd:debug "description"


Quick targeted fix
/gsd:quick


Plan doesn't match vision
/gsd:discuss-phase [N] then re-plan


Costs running high
/gsd:set-profile budget + /gsd:settings toggle agents off


Update broke local changes
/gsd:reapply-patches


FAQ

Q: GSD khác gì BMAD Method?

A: BMAD dùng 21 agent personas mô phỏng team thực tế (PM, Architect, Developer, QA...) với 50+ workflows. GSD dùng ít agents hơn nhưng focus vào context engineering — mỗi agent nhận context tối ưu, mỗi plan chạy trong fresh window. BMAD phức tạp hơn cho user; GSD giấu complexity behind the scenes.
Q: Tại sao cần /gsd:discuss-phase? Có thể skip không?

A: Có thể skip — bạn nhận reasonable defaults. Nhưng discuss-phase là bước capture your vision trước khi planning. Không có nó, Claude sẽ make assumptions. Kết quả: code works nhưng không build đúng ý bạn.
Q: Context rot là gì và GSD giải quyết thế nào?

A: Context rot = quality degradation khi Claude's context window đầy. Sau 50-70% context, Claude bắt đầu "efficiency mode" — tóm tắt, bỏ qua chi tiết, giảm chất lượng. GSD giải quyết bằng cách: mỗi executor nhận fresh 200K tokens, mỗi plan đủ nhỏ để complete trong ~50% context, orchestrator ở main window chỉ làm thin coordination.
Q: yolo mode là gì?

A: Auto-approve mọi thứ. Không dừng confirm ở mỗi step. Kết hợp với --auto flag: /gsd:new-project --auto sẽ auto-run toàn bộ flow. Phù hợp cho prototyping nhanh, nhưng thiếu human oversight.
Q: Có thể dùng GSD cho existing project không?

A: Có. Chạy /gsd:map-codebase trước → GSD phân tích stack, architecture, conventions, concerns → sau đó /gsd:new-project focus vào what you're adding, planning tự động load patterns.
Q: GSD có hoạt động với OpenCode và Gemini CLI không?

A: Có, native support từ v1.20. Installer hỏi bạn chọn runtime. Commands hoạt động giống nhau trên cả 3 platforms.
Q: Làm sao quản lý chi phí token?

A: Ba cách:

/gsd:set-profile budget — Sonnet cho mọi thứ, Haiku cho research/verification
/gsd:settings → disable workflow.research, workflow.plan_check, workflow.verifier
depth: quick — ít phases hơn, ít plans per phase


Resources & References

Official


Repository: github.com/gsd-build/get-shit-done
npm: npmjs.com/package/get-shit-done-cc
User Guide: docs/USER-GUIDE.md
Changelog: CHANGELOG.md
Discord: discord.gg/5JJgD5svVS
Twitter/X: @gsd_foundation

Community Ports


Project
Platform
Mô tả


gsd-opencode
OpenCode
Original OpenCode adaptation


gsd-gemini (archived)
Gemini CLI
Original Gemini adaptation


Related Frameworks (Bài viết trong Vault)


[[Ucai-Guide]] — Ucai: Claude Code plugin dùng native architecture
[[BMAD-Method-Guide]] — BMAD Method: 21 agent personas, 50+ workflows
[[Bmalph-Guide]] — bmalph: BMAD + Ralph unified framework
[[Claude-Code-Best-Practice-Guide]] — Best practices cho Claude Code
[[Claude-Skills-Zero-2-Hero]] — Hướng dẫn tạo Claude Skills
Tiêu chí	Vibe Coding	BMAD Method	Ucai	bmalph	GSD
Tiếp cận	Prompt → Code	21 agent personas	Native plugin	BMAD + Ralph	Meta-prompting + context engineering
Planning	Không	Chi tiết (personas)	`/plan` + agents	BMAD-level	Research → Plan → Verify loop
Execution	Thủ công	Thủ công	`/build` 8-phase	Ralph loop	Wave-based parallel, fresh 200K/plan
Context rot	Nghiêm trọng	Giảm nhẹ	File-based chain	Fresh per story	Giải quyết triệt để
Verification	Không	Agent review	Agent + manual test	Không	Goal-backward 3-level + UAT
Git strategy	Không	Không	Không	Ralph auto-commit	Atomic per-task + branching strategies
Config/Profiles	Không	Không	Không	Không	3 model profiles + workflow toggles
Runtime	Claude Code	Claude Code	Claude Code	Claude Code	Claude Code + OpenCode + Gemini CLI
Complexity	Không	Cao	Thấp	Cao	Thấp cho user, cao cho system
Loại feature	Hỏi về
Visual features	Layout, density, interactions, empty states
APIs/CLIs	Response format, flags, error handling, verbosity
Content systems	Structure, tone, depth, flow
Organization tasks	Grouping criteria, naming, duplicates, exceptions
Field	Mô tả	Bad example	Good example
`<files>`	Exact file paths	"the auth files"	`src/app/api/auth/login/route.ts`
`<action>`	Specific instructions + what to avoid + WHY	"Add authentication"	"Create POST endpoint, validate bcrypt, return JWT httpOnly cookie 15-min. Use jose (not jsonwebtoken — CommonJS issues)"
`<verify>`	Prove task complete	"It works"	`curl -X POST /api/auth/login returns 200 + Set-Cookie`
`<done>`	Acceptance criteria	"Auth is complete"	"Valid credentials → 200 + JWT cookie, invalid → 401"
Context Usage	Quality	Claude's State
0-30%	PEAK	Thorough, comprehensive
30-50%	GOOD	Confident, solid work
50-70%	DEGRADING	Efficiency mode begins
70%+	POOR	Rushed, minimal
Vertical Slices ✅	Horizontal Layers ❌
Plan 01: User feature (model + API + UI)	Plan 01: All models
Plan 02: Product feature (model + API + UI)	Plan 02: All APIs
Plan 03: Order feature (model + API + UI)	Plan 03: All UIs
→ All 3 run parallel (Wave 1)	→ Fully sequential (02 needs 01, 03 needs 02)
Rule	Trigger	Action
Rule 1: Auto-fix bugs	Code doesn't work as intended	Fix inline, no user permission
Rule 2: Auto-add critical functionality	Missing error handling, validation, security	Fix inline, no user permission
Rule 3: Auto-fix blocking issues	Missing dependency, wrong types	Fix inline, no user permission
Rule 4: Ask about architectural changes	New DB table, switching libraries	STOP → checkpoint → user decision
Agent	Color	Model (balanced)	Mission
`gsd-planner`	🟢 Green	Opus	Tạo execution plans với task breakdown, dependency analysis, goal-backward verification
`gsd-executor`	🟡 Yellow	Sonnet	Thực thi plans: atomic commits, deviation handling, checkpoint protocols
`gsd-verifier`	🟢 Green	Sonnet	Goal-backward verification 3 levels: exists → substantive → wired
`gsd-plan-checker`	—	Sonnet	Verify plans achieve phase goals trước execution
`gsd-phase-researcher`	—	Sonnet	Research per-phase: stack, features, architecture, pitfalls
`gsd-project-researcher`	—	Sonnet	Research project-level domain
`gsd-research-synthesizer`	—	Sonnet	Tổng hợp research findings
`gsd-roadmapper`	—	Sonnet	Tạo roadmap từ requirements
`gsd-debugger`	—	Sonnet	Systematic debugging với persistent state
`gsd-codebase-mapper`	—	Haiku	Phân tích existing codebase (brownfield)
`gsd-integration-checker`	—	Sonnet	Kiểm tra integration giữa các components
Level	Kiểm tra	Phát hiện
Exists	File có tồn tại?	Missing files
Substantive	File có thật sự implement? Hay chỉ là stub/placeholder?	`return <div>Placeholder</div>`, empty handlers
Wired	Components có kết nối với nhau?	Fetch without response handling, state exists but not rendered
Command	Mô tả
`/gsd:new-project [--auto]`	Full initialization: questions → research → requirements → roadmap
`/gsd:discuss-phase [N] [--auto]`	Capture implementation decisions trước planning
`/gsd:plan-phase [N] [--auto]`	Research + plan + verify cho phase
`/gsd:execute-phase <N>`	Execute tất cả plans trong parallel waves, verify khi xong
`/gsd:verify-work [N]`	Manual user acceptance testing
`/gsd:audit-milestone`	Verify milestone đạt definition of done
`/gsd:complete-milestone`	Archive milestone, tag release
`/gsd:new-milestone [name]`	Bắt đầu version tiếp: questions → research → requirements → roadmap
Command	Mô tả
`/gsd:progress`	Đang ở đâu? Cần làm gì tiếp?
`/gsd:help`	Hiển thị tất cả commands
`/gsd:update`	Cập nhật GSD với changelog preview
`/gsd:pause-work`	Tạo handoff khi dừng giữa phase
`/gsd:resume-work`	Restore context từ session trước