Skip to main content
The workflow commands form the backbone of GSD Core’s phase pipeline. Each command maps to one discrete step in the loop: initialize → discuss → plan → execute → verify → ship. Run them in order for a new project, or invoke any individual command when you need to repeat or adjust a specific step. All commands read from and write to the .planning/ directory at your project root.

​
/gsd-new-project

Initialize a new project with deep context gathering. Syntax
What it does Walks you through a structured questioning flow, optionally runs domain research, then generates requirements and a phase roadmap. All subsequent workflow commands build on the artifacts this command produces. Produces Flags
​
flag
Automatic mode. Skips interactive questioning and runs research → requirements → roadmap without further interaction. Pass your idea document via an @ reference, for example --auto @brief.md.
Next step: Run /gsd-plan-phase 1 to begin the first phase.

​
/gsd-discuss-phase N

Gather phase context through adaptive questioning before planning. Syntax
What it does Loads prior context from PROJECT.md, REQUIREMENTS.md, STATE.md, and any earlier CONTEXT.md files. Scouts the codebase for reusable assets, identifies unresolved gray areas, guides you through a deep-dive on any you choose to discuss, and writes a CONTEXT.md that gives the planner and researcher everything they need — so they never have to ask you the same question twice. Produces {phase_num}-CONTEXT.md — locked decisions and scope guidance for downstream agents. Flags
​
flag
Discuss all identified gray areas in one session rather than letting you pick a subset.
​
flag
Auto-answer discussion questions using existing context. Useful in autonomous or CI pipelines where interactive input is not available.
​
flag
Group related gray areas and address them together instead of one at a time.
​
flag
Run a deeper analysis pass on the codebase before presenting gray areas.
​
flag
Power mode. Runs an extended questioning protocol with richer probing — best for complex or ambiguous phases.
​
flag
List the assumptions implicit in the current phase plan instead of opening a discussion session.

​
/gsd-ui-phase N

Generate a UI design contract for frontend phases. Syntax
What it does Orchestrates a gsd-ui-researcher and a gsd-ui-checker to produce a UI-SPEC.md design contract for a frontend phase. Run this before /gsd-plan-phase on any phase that involves user-facing components so the planner has a verified UI specification to work from. Produces {phase_num}-UI-SPEC.md — design contract covering component structure, interaction patterns, and brand alignment.

​
/gsd-plan-phase N

Research, plan, and verify a phase — the core planning step. Syntax
What it does Runs the full planning pipeline: optional domain research → gsd-planner agent → gsd-plan-checker verification loop → plan approval. By default it auto-detects the next unplanned phase if you omit the phase number. Produces {phase_num}-PLAN.md files containing executable prompts for each task in the phase, plus RESEARCH.md when research runs. Flags
​
flag
Force-refresh research even when a RESEARCH.md already exists for this phase.
​
flag
Skip research entirely and go straight to planning. Use when the implementation approach is already clear.
​
string
Research-only mode. Spawns the researcher for phase N, writes RESEARCH.md, and exits before the planner runs. Useful for cross-phase research or iterating on research alone without replanning.
​
flag
Gap-closure mode. Reads VERIFICATION.md and re-plans only to address verified gaps. Skips research.
​
string
Path to a PRD or acceptance-criteria file. Parses requirements into CONTEXT.md automatically, skipping the discuss phase entirely. Example: --prd docs/prd.md.
​
string
Path or glob of ADR files to use instead of a discuss session. Parses locked decisions and scope fences into CONTEXT.md. Example: --ingest docs/adr/*.md.
​
flag
Vertical MVP mode. Organizes tasks as feature slices (UI → API → DB) instead of horizontal layers. On Phase 1 of a new project, also emits a SKELETON.md walking skeleton document. Persist this mode for a phase by adding **Mode:** mvp to ROADMAP.md.
​
flag
TDD mode. Instructs the planner to organize tasks around test-first RED-GREEN cycles.
​
flag
Replan incorporating cross-AI feedback from a REVIEWS.md file produced by /gsd-review.
​
flag
Skip the plan-checker verification loop and present the plan immediately after the planner completes.

​
/gsd-plan-review-convergence N

Run a cross-AI convergence loop until no HIGH-severity concerns remain. Syntax
What it does Repeatedly runs external AI reviewers against the phase plan, feeds HIGH-severity findings back into the planner via --reviews, then re-reviews. Stops when no HIGH concerns remain or the cycle cap is reached. Requires workflow.plan_review_convergence=true in your config. Flags
​
flag
Use Codex CLI as the reviewer. Default when no reviewer flag is specified.
​
flag
Use Gemini CLI as the reviewer.
​
flag
Use a separate Claude CLI session as the reviewer.
​
flag
Use OpenCode as the reviewer.
​
flag
Use a local Ollama server (OpenAI-compatible, default host http://localhost:11434). Configure the model via review.models.ollama.
​
flag
Use a local LM Studio server (default host http://localhost:1234). Configure the model via review.models.lm_studio.
​
flag
Use a local llama.cpp server (default host http://localhost:8080). Configure the model via review.models.llama_cpp.
​
flag
Use every available CLI and running local model server.
​
number
Maximum number of replan → review cycles before escalating to you. Default: 3.

​
/gsd-execute-phase N

Execute all plans in a phase with wave-based parallelization. Syntax
What it does Discovers all plan files in the phase, analyzes task dependencies, groups them into parallel execution waves, spawns subagents for each wave, and collects results. Phase verification and completion only trigger when no incomplete plans remain after the selected wave finishes. Flags
​
number
Execute only Wave N of the phase. Use to pace execution, manage API usage limits, or perform a staged rollout.
​
flag
Execute only gap-closure plans — those with gap_closure: true in their frontmatter. Run this after /gsd-verify-work creates fix plans.
​
flag
Execute plans sequentially inline (no subagents) with user checkpoints between tasks. Lower token usage, pair-programming style. Best for small phases, bug fixes, and verification gap closures.

​
/gsd-verify-work N

Validate built features through conversational UAT with auto-diagnosis. Syntax
What it does Runs a conversational user acceptance test against the features built in the specified phase. Presents one test at a time in plain language, tracks results in a UAT.md file, and when issues are found automatically diagnoses root causes, produces fix plans, and queues them for /gsd-execute-phase. If you omit the phase number it checks for an active session or prompts you. Produces {phase_num}-UAT.md — test results with pass/fail status. When issues are found: diagnosed gap descriptions and verified fix plans ready for re-execution.

​
/gsd-ship N

Create a pull request and prepare the phase for merge. Syntax
What it does Bridges local completion to a merged pull request. Pushes the phase branch, creates a PR with an auto-generated body summarizing what was built, optionally triggers a review, and tracks the merge. Closes the plan → execute → verify → ship loop. Flags
​
flag
Open the pull request as a draft instead of a ready-for-review PR. Use when you want the branch visible to your team but not yet requesting review.

​
/gsd-progress

Check where you are and what comes next. Syntax
What it does Your unified situational command. In default mode it shows a progress report and intelligently routes to the next action. With --next it advances automatically. With --do it maps natural language intent to the most appropriate GSD command, confirms the match, and hands off. Flags
​
flag
Automatically advance to the next logical workflow step. Scans all prior phases for incomplete work before routing. Add --force to bypass safety gates.
​
flag
Like --next, but after the determined step completes, re-invokes /gsd-progress --next --auto automatically to keep chaining steps. Enables hands-free plan → execute → verify progression until a blocking decision is required.
​
string
Smart dispatcher. Matches freeform natural language to the best GSD command using routing rules, confirms the match, then hands off execution.
​
flag
Append a 6-check integrity audit after the standard progress report.

​
/gsd-autonomous

Run all remaining phases without manual intervention. Syntax
What it does Executes every remaining milestone phase in sequence: discuss → plan → execute per phase. Pauses only for user decisions on gray areas, blockers, or validation gates. After all phases complete, runs a milestone audit, completes the milestone, and runs cleanup. Flags
​
number
Start from phase N instead of the first incomplete phase.
​
number
Stop after phase N completes instead of continuing to the end of the milestone.
​
number
Execute only phase N — single-phase mode.
​
flag
Run the discuss step inline so you can answer questions directly, then dispatch plan and execute as background agents. Keeps the main context lean while preserving your input on decisions.
​
flag
Use plain-text numbered lists instead of interactive TUI menus. Required for /rc remote sessions.