Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/jorgeferrando/sdd-skills/llms.txt

Use this file to discover all available pages before exploring further.

/sdd-continue is the everyday navigation command in SDD. Instead of remembering which skill to run next, you run /sdd-continue and the skill inspects the artifacts already present in the change directory, determines the first incomplete phase, and executes the right skill automatically. It works entirely from what is on disk — not from conversation history — so it picks up correctly even after clearing context, switching terminals, or resuming the next day.

​
Usage

/sdd-continue                      # Active change (when exactly one exists)
/sdd-continue {change-name}        # Target a specific change by name
If there is more than one active change under openspec/changes/ and no name is supplied, the skill asks which one to advance.

​
Prerequisites

  • openspec/changes/ must exist — run /sdd-init first if it does not.

​
Phase Detection Logic

/sdd-continue scans openspec/changes/{change-name}/ and executes the skill for the first phase not yet complete:
If this is missing or incompleteSkill runMode
No proposal.md/sdd-proposeInline (interactive)
No specs/*/spec.md/sdd-specInline (interactive)
No design.md/sdd-designAgent (non-interactive)
No tasks.md/sdd-tasksInline (interactive)
tasks.md has unchecked [ ] items/sdd-apply (from first pending task)Inline (manages own agents)
All tasks [x], clean working tree/sdd-verifyAgent (non-interactive)
Everything completeSuggests /sdd-archive—
Phases are never skipped. If design.md is missing, the skill does not run /sdd-tasks even if proposal.md and specs/ both exist.
Use /sdd-continue after clearing your conversation context — it detects the phase entirely from artifacts on disk, not from chat history, so it picks up exactly where you left off.

​
What It Does

1
Identify the active change
2
Lists openspec/changes/ to find the change to advance. Uses the supplied {change-name} if provided; picks the single non-archived directory if only one exists; or asks the user when multiple are present.
3
Detect the pending phase
4
Reads the change directory and applies the detection table above. The first phase whose completion condition is not yet met is the one to execute.
5
Special cases:
6
  • Apply in progress — if tasks.md has a mix of [x] and [ ] items, continue apply from the first unchecked task.
  • Verify blocked by dirty tree — inform the user before running verify.
  • All phases complete — report that the change is ready for /sdd-archive.
    • 7
    Execute the skill
    8
    Announce the detected phase and run the corresponding skill:
    9
    Detected phase: DESIGN
Change: add-health-check
Running sdd-design (as agent — context stays clean)...
    10
    Inline phases (propose, spec, tasks, apply) run directly in the current conversation because the user needs to answer questions and review output.
    11
    Agent phases (design, verify) launch as subagents. Design and verify are non-interactive — they read files, analyze code, and produce artifacts without user input. Running them as agents keeps the orchestrator context free of code-reading and test-output noise. When the agent returns, its summary is presented before continuing.

    ​
    Why Some Phases Run as Agents

    Interactive phases (propose, spec, tasks, apply) stay inline because they rely on back-and-forth with the user. Non-interactive phases (design, verify) run as subagents: they read substantial amounts of code and produce artifacts autonomously, and isolating them prevents that activity from bloating the main conversation context.

    ​
    Custom Skills Extension Point

    If openspec/skills/ exists, /sdd-continue scans it for custom skill files and integrates them into the phase sequence. Each custom skill declares where it fits: 
    ---
name: custom-skill-name
description: What it does
requires: ["openspec/changes/{change}/tasks.md"]
produces: ["openspec/changes/{change}/custom-output.md"]
after: apply       # insert after this built-in phase
mode: inline       # or agent
---
    Custom phases slot in between the built-in phase they follow and the next built-in phase. Multiple custom skills with the same after value run in alphabetical order. A custom skill is skipped if its requires artifacts do not yet exist. This lets teams extend the workflow — adding a performance-benchmark step after apply, for example — without modifying any built-in skill.

    ​
    Skill Metadata

    FieldValue
    model_hinthaiku (orchestrator); delegates to per-skill hints for subagents
    requiresopenspec/changes/
    producesDelegates to the executed skill

    ​
    Next Steps

    /sdd-continue runs until one phase completes, then stops. Run it again to advance to the next phase — or keep running it until the change reaches /sdd-archive. For a fully hands-off planning pass, consider /sdd-ff which chains propose → spec → design → tasks without pausing. For a fully autonomous cycle including implementation, PR creation, and review handling, see /sdd-agent.

    Build docs developers (and LLMs) love

    Get started for freeTalk to us