Open Gsd@Gsd Core

Execute a trivial task inline — no subagents, no planning overhead

Show available GSD commands and usage guide

Smart entry — detect project state and route to the right next GSD action.

Create PR, run review, and prepare for merge after verification passes

Safe git revert. Roll back phase or plan commits using the phase manifest with dependency checks.

Systematic debugging with persistent state across context resets

Triage and review open GitHub issues and PRs against project templates and contribution guidelines.

Multi-phase management — add, insert, remove, or edit phases in ROADMAP.md (roadmap phase CRUD)

Execute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents

Spike an idea through experiential exploration, or propose what to spike next (frontier mode)

Configure GSD settings — workflow toggles, advanced knobs, integrations, and model profile

Diagnose planning directory health and optionally repair issues

Ingest external plans with conflict detection against project decisions before writing anything.

Request cross-AI peer review of phase plans from external AI CLIs

Sketch UI/design ideas with throwaway HTML mockups, or propose what to sketch next (frontier mode)

Update GSD to latest version with changelog display

Capture ideas, tasks, notes, and seeds to their destination

Archive accumulated phase directories from completed milestones

Socratic ideation and idea routing — think through ideas before committing to plans

Interactive command center for managing multiple phases from one terminal

Guide existing codebase onboarding through mapping, doc ingest, and planning setup

Toggle which skills are surfaced — apply a profile, list, or disable a cluster without reinstall

Build, query, and inspect the project knowledge graph in .planning/graphs/

Check progress, advance workflow, or dispatch freeform intent — the unified GSD situational command

Configure GSD workflow toggles and model profile

Generate UI design contract (UI-SPEC.md) for frontend phases

Generate tests for a completed phase based on UAT criteria and implementation

Autonomous audit-to-fix pipeline — find issues, classify, fix, test, commit

Cross-phase audit of all outstanding UAT and verification items

Post-mortem investigation for failed GSD workflows — diagnoses what went wrong.

Plan a phase as a vertical MVP slice — user story, SPIDR splitting, then plan-phase

exploration capture | explore sketch spike spec capture

config workspace | workstreams thread update ship inbox

quality gates | code review debug audit security eval ui

Create a clean PR branch by filtering out .planning/ commits — ready for code review

Retroactive 6-pillar visual audit of implemented frontend code

Manage GSD workspaces — create, list, or remove isolated workspace environments

Run all remaining phases autonomously — discuss→plan→execute per phase

codebase intel | map graphify docs learnings mempalace

project lifecycle | milestones audits summary

Create context handoff when pausing work mid-phase

Create detailed phase plan (PLAN.md) with verification loop

Clarify WHAT a phase delivers with ambiguity scoring; produces a SPEC.md before discuss-phase.

Review source files changed during a phase for bugs, security issues, and code quality problems

Generate or update project documentation verified against the codebase

Audit an executed AI phase's evaluation coverage and produce an EVAL-REVIEW.md remediation plan.

Bootstrap or merge a .planning/ setup from existing ADRs, PRDs, SPECs, and docs in a repo.

Gsd New Project

workflow | discuss plan execute verify phase progress

Batch several /gsd:quick-shaped tasks together — planned, dispatched, and merged as one run

Resume work from previous session with full context restoration

Validate built features through conversational UAT

Manage parallel workstreams — list, create, switch, status, progress, complete, and resume

Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents

Generate developer behavioral profile and create Claude-discoverable artifacts

Retroactively verify threat mitigations for a completed phase

Gather phase context through adaptive questioning before planning.

SDD phase execution — execute all plans in a phase with dependency-aware wave parallelization

Start a new milestone cycle — update PROJECT.md and route to requirements

Review and promote backlog items to active milestone