gsd

Enforce a spec-first SPEC to PLAN to EXECUTE to VERIFY to COMMIT protocol for software engineering tasks.

Updated Jun 30, 2026
One-click install
npx skills add https://github.com/BAIZ1D/macbookM1_rice --skill gsd-baiz1d
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: gsd
Source: https://github.com/BAIZ1D/macbookM1_rice/tree/main/agent/skills/gsd
Command: npx skills add https://github.com/BAIZ1D/macbookM1_rice --skill gsd-baiz1d

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses the inefficiency and inconsistent quality of unstructured "vibe coding" by enforcing a rigorous, spec-first methodology that ensures all software engineering work is well-planned, executable, and verifiable before any code is written.

Core Features & Use Cases

  • SPEC-First Development: Mandates finalized requirement documentation in .gsd/SPEC.md before implementation begins, eliminating scope creep and misalignment.
  • Structured Execution Pipeline: Breaks work into phased roadmaps and atomic commits, with support for autonomous execution loops via /ralph to accelerate repetitive tasks.
  • Empirical Verification Requirements: Mandates concrete proof (test runner output, API responses, UI screenshots) for every code change to guarantee deliverable quality.
  • Use Case: Ideal for engineering teams building new features, resolving critical bugs, or launching greenfield projects where consistent, auditable, high-quality delivery is required.

Quick Start

Use the gsd skill to define a finalized spec and phased roadmap for your new user authentication feature before writing any implementation code.

Frequently Asked Questions about gsd

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I stop unstructured vibe coding and enforce a spec-first workflow?

To stop unstructured vibe coding, use a spec-first workflow that mandates finalized requirements before implementation. This approach enforces a structured SPEC, PLAN, EXECUTE, VERIFY, and COMMIT protocol, ensuring all software engineering tasks are well-planned and verifiable.

What is the best way to plan a phased roadmap for new feature development?

The best way to plan a phased roadmap for feature development is by defining a finalized spec first. This methodology breaks work into phased roadmaps and atomic commits, preventing scope creep and ensuring consistent, high-quality delivery.

How do I require empirical proof for code changes during implementation?

To require empirical proof for code changes, implement a verification phase in your software engineering workflow. This mandates concrete proof like test runner output, API responses, or UI screenshots for every code change before committing.

Can I automate repetitive tasks in a spec-first software engineering workflow?

Yes, you can automate repetitive tasks in a spec-first software engineering workflow. The structured execution pipeline supports autonomous execution loops to accelerate repetitive implementation tasks while maintaining spec adherence and verification.

Does a spec-first methodology work for resolving critical bugs and greenfield projects?

A spec-first methodology works effectively for resolving critical bugs and launching greenfield projects. It applies structured planning and empirical verification to any software engineering task, ensuring consistent and auditable delivery.