gsd-clawSpec-driven development with built-in verification for substantial projects. Use when user wants to plan a project, scope a feature, build something with structure, or says "GSD mode", "let's plan", "scope out", "spec-driven". Workflow is Discuss → Plan → Execute → Verify. Based on glittercowboy's GSD system (MIT license). NOT for quick questions or simple tasks.
Install via ClawdBot CLI:
clawdbot install RubenAQuispe/gsd-clawA spec-driven development system adapted for OpenClaw. Transforms vague ideas into verified, working implementations through structured workflows.
Based on: glittercowboy/get-shit-done
Original Author: Lex Christopherson (@glittercowboy)
License: MIT
Trigger this skill when user says:
NOT for: Quick questions, simple tasks, chat conversations.
From the original GSD:
"The complexity is in the system, not in your workflow."
Principles:
┌─────────────────────────────────────────────────────────────┐
│ 1. DISCUSS Capture decisions before planning │
│ 2. PLAN Research → Create verified specs │
│ 3. EXECUTE Work through tasks with deviation rules │
│ 4. VERIFY Confirm deliverables actually work │
└─────────────────────────────────────────────────────────────┘Purpose: Capture user's vision BEFORE any planning.
Process:
{project}/.gsd/CONTEXT.mdOutput Structure:
# Context: [Project/Phase Name]
## Decisions (Locked)
- [User decision 1]
- [User decision 2]
## Agent Discretion (Freedom Areas)
- [Area where agent can choose approach]
## Deferred Ideas (Out of Scope)
- [Not doing this now]Rule: Never assume. Always ask.
Purpose: Create executable task specs with built-in verification.
Spawn sub-agent to investigate:
Save to: {project}/.gsd/RESEARCH.md
Each plan = 2-3 tasks maximum (context efficiency).
Task XML Structure:
<task type="auto">
<name>Task N: Action-oriented name</name>
<files>src/path/file.ts, src/other/file.ts</files>
<action>
What to do, what to avoid and WHY.
Be specific. No guessing.
</action>
<verify>Command or check to prove completion</verify>
<done>Measurable acceptance criteria</done>
</task>Task Types:
type="auto" — Agent executes autonomouslytype="checkpoint:verify" — User must verifytype="checkpoint:decision" — User must chooseBefore execution, verify plans against:
Save plans to: {project}/.gsd/plans/{phase}-{N}-PLAN.md
Purpose: Work through tasks with deviation handling.
Apply automatically — track for summary:
| Rule | Trigger | Action | Permission |
|------|---------|--------|------------|
| Bug | Broken behavior, errors, security issues | Fix → verify → track | Auto |
| Missing Critical | Missing validation, auth, error handling | Add → verify → track | Auto |
| Blocking | Prevents completion (missing deps, wrong types) | Fix blocker → track | Auto |
| Architectural | New table, schema change, breaking API | STOP → ask user | Ask |
Rule 4 (Architectural) Format:
⚠️ Architectural Decision Needed
Current task: [task name]
Discovery: [what prompted this]
Proposed change: [modification]
Why needed: [rationale]
Alternatives: [other approaches]
Proceed? (yes / different approach / defer)For multi-task execution, spawn sub-agents:
After each task:
Purpose: Confirm deliverables actually work.
Walk user through testable deliverables:
If all pass: Mark phase complete.
If issues: Don't debug manually — create fix plan and re-execute.
{project}/
└── .gsd/
├── PROJECT.md # Vision, always loaded
├── STATE.md # Current position, decisions, blockers
├── REQUIREMENTS.md # Scoped v1/v2 requirements
├── ROADMAP.md # Phases and progress
├── CONTEXT.md # User decisions from discuss phase
├── RESEARCH.md # Domain research (optional)
└── plans/
├── 01-01-PLAN.md # Phase 1, Plan 1
├── 01-01-SUMMARY.md # Execution results
└── ...Templates: Copy from assets/ directory when initializing project files.
For small tasks that don't need full planning:
Trigger: "Quick: [task description]"
Process:
When to use:
# Project State
## Current Position
Phase: [N]
Plan: [N of M]
Status: [planning | executing | verifying | blocked]
## Decisions Made
- [Decision 1] — [rationale]
- [Decision 2] — [rationale]
## Blockers
- [Blocker if any]
## Deviations Applied
- [Rule N] [Description] — [resolution]Update STATE.md after each significant action.
From original GSD:
❌ Enterprise theater
❌ Vague tasks
<!-- BAD -->
<task>
<name>Add authentication</name>
<action>Implement auth</action>
<verify>???</verify>
</task>❌ Filler language
✅ Direct, imperative, technical
Original GSD → OpenClaw Version
| GSD | OpenClaw |
|-----|----------|
| /gsd:command slash commands | Natural language triggers |
| Claude Code Task() spawning | sessions_spawn sub-agents |
| .claude/ directory | {project}/.gsd/ directory |
| Bash scripts | PowerShell/cross-platform |
| git commit protocol | Optional, user preference |
Preserved Core:
User: "Let's plan the ORO website SEO overhaul"
Agent (DISCUSS):
Starting GSD workflow for: ORO Website SEO Overhaul
Before planning, I need to understand your vision.
1. What's the primary goal?
a) Rank higher for specific keywords
b) Improve technical SEO scores
c) Both
d) Something else
2. Any pages that are highest priority?
3. Budget constraints for tools/services?
4. Timeline expectations?After discussion → creates CONTEXT.md
Agent (PLAN):
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
GSD ► PLANNING: ORO SEO Overhaul
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Spawning research sub-agent...
[Research complete]
Creating plans...
- Plan 1: Technical SEO fixes (3 tasks)
- Plan 2: Content optimization (2 tasks)
- Plan 3: Performance improvements (3 tasks)
Verifying plans against requirements...
✓ All checks passed
Ready to execute?This skill is adapted from Get Shit Done (GSD) by Lex Christopherson (@glittercowboy).
Thank you Lex for creating an incredibly effective system for building things with AI.
Generated Mar 1, 2026
A tech startup founder wants to build a minimum viable product for a new SaaS platform. They need to scope out core features, create executable development plans, and ensure the implementation meets business requirements with built-in verification before launch.
An enterprise IT team needs to migrate a legacy customer database to a modern cloud platform. The project requires careful planning of data mapping, validation rules, and phased execution with deviation handling for unexpected architectural issues.
An e-commerce company wants to add a new payment gateway integration. The project involves planning API specifications, implementing secure transaction handling, and verifying the feature works across different customer scenarios before deployment.
A mobile development team needs to add push notification capabilities to an existing application. The project requires planning notification workflows, implementing platform-specific code, and verifying delivery across iOS and Android devices.
A media company wants to upgrade their content management system with new editorial workflows. The project involves planning user permission structures, implementing content approval processes, and verifying the system handles various content types correctly.
Agencies use GSD Claw to structure client projects from initial discussion through verified delivery. The systematic approach ensures clear scope definition, prevents scope creep, and provides documented verification for client acceptance.
Product companies use the skill to manage internal feature development with spec-driven workflows. The verification phase ensures features work as intended before release, reducing bugs and rework while maintaining development velocity.
Digital agencies implement GSD Claw across multiple client projects to standardize delivery processes. The structured phases (Discuss→Plan→Execute→Verify) provide consistent quality control and clear documentation for client communications.
💬 Integration Tip
Start with a small pilot project to familiarize your team with the four-phase workflow before applying it to mission-critical initiatives.
Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
Provides a 7-step debugging protocol plus language-specific commands to systematically identify, verify, and fix software bugs across multiple environments.
A comprehensive skill for using the Cursor CLI agent for various software engineering tasks (updated for 2026 features, includes tmux automation guide).
Write, run, and manage unit, integration, and E2E tests across TypeScript, Python, and Swift using recommended frameworks.
Control and operate Opencode via slash commands. Use this skill to manage sessions, select models, switch agents (plan/build), and coordinate coding through Opencode.
Coding style memory that adapts to your preferences, conventions, and patterns for consistent coding.