Skip to main content
GSD Core is designed to run without you watching every step. Autonomous mode lets you fire off an entire multi-phase delivery and come back when it is done, or use the interactive manager to oversee parallel phase work from a single terminal. Understanding when to use each mode — and how to keep human checkpoints when you need them — is the key to getting the most out of GSD Core’s parallelization.

​
/gsd-autonomous — hands-free phase execution

Run /gsd-autonomous to execute all remaining phases in your roadmap without any human intervention. GSD runs each phase through the full discuss → plan → execute → verify loop in sequence, skipping phases that are already complete. 
/gsd-autonomous                     # Run all remaining phases
/gsd-autonomous --from 3            # Start from phase 3
/gsd-autonomous --to 5              # Run up to and including phase 5
/gsd-autonomous --from 3 --to 5     # Run phases 3 through 5
/gsd-autonomous --only 4            # Run only phase 4
/gsd-autonomous --interactive       # Answer discuss questions inline; plan and execute run as background agents
FlagEffect
--from NStart autonomous execution from phase N; phases before N are skipped
--to NStop after completing phase N
--only NExecute only phase N in single-phase mode
--interactiveRun discuss inline with user input, then dispatch plan and execute as background agents
/gsd-autonomous without --interactive commits code and advances STATE.md without asking for confirmation at each phase. Review your ROADMAP.md and REQUIREMENTS.md carefully before running fully autonomous mode on a project for the first time.

​
/gsd-manager — interactive multi-phase command center

Run /gsd-manager to open a dashboard that shows the status of all phases and lets you dispatch work to individual phases from a single terminal. Unlike /gsd-autonomous, the manager does not run phases sequentially on its own — it gives you a visual command center to orchestrate phase work interactively. 
/gsd-manager                        # Open the command center dashboard
/gsd-manager --analyze-deps         # Scan ROADMAP for phase dependencies before parallel execution
The manager runs discuss-phase commands inline in the terminal so you can answer questions directly. Plan and execute commands run as background agents, emitting [checkpoint] markers at every wave and plan boundary so the stream never times out on long-running phases. If a background phase fails partway through, look for [checkpoint] in the transcript to identify the last confirmed wave boundary and resume from there.
You can configure per-step flags that the manager appends automatically to every dispatched command: 
{
  "manager": {
    "flags": {
      "discuss": "--auto",
      "plan": "--skip-research",
      "execute": "--validate"
    }
  }
}

​
Auto-advance via config

Set workflow.auto_advance: true in .planning/config.json to automatically chain discuss → plan → execute without stopping between steps. This is a project-level toggle — once set, every phase command that completes successfully will immediately invoke the next step. 
{
  "workflow": {
    "auto_advance": true
  }
}
Enable or disable it interactively via /gsd-settings or /gsd-config: 
/gsd-settings       # Interactive six-section configuration wizard
/gsd-config         # Focused interactive config for common toggles

​
When to use autonomous vs interactive mode

Choosing the right mode depends on how much confidence you have in your requirements and how much you want to inspect intermediate artifacts.

Use autonomous mode when…

  • Your requirements and ROADMAP are well-defined and stable
  • You are running repeated phases on a familiar domain
  • You want to leave work running overnight or between sessions
  • The project is in a yolo mode prototype and speed matters more than review

Use interactive mode when…

  • You are working on a novel architecture or unfamiliar domain
  • Your requirements have open questions that need human judgment
  • Each phase has significant infrastructure changes worth reviewing
  • You want to run cross-AI review between discuss and plan

​
Keeping human checkpoints with —interactive

The --interactive flag on /gsd-autonomous strikes a balance between automation and oversight. GSD runs the discuss step inline so you can answer questions directly, then dispatches plan and execute as background agents. This keeps the main context lean while preserving your input on implementation decisions before any code is written. 
/gsd-autonomous --interactive       # Discuss inline, plan and execute as background agents
Combine --interactive with --from N to let earlier phases run fully autonomous while you stay hands-on for a specific phase range: /gsd-autonomous --from 4 --to 6 --interactive.

​
Discuss-phase skip for fully captured projects

If your PROJECT.md and REQUIREMENTS.md already capture all developer preferences and implementation decisions, skip the discuss step entirely by setting workflow.skip_discuss: true. GSD will write a minimal CONTEXT.md from the ROADMAP phase goal and proceed directly to planning. 
{
  "workflow": {
    "skip_discuss": true
  }
}
skip_discuss only affects /gsd-autonomous. Running /gsd-discuss-phase directly always runs the full session regardless of this setting.