GS

gsd-spec-phase

Define requirements and specifications before starting development.

Install

mkdir -p .claude/skills/gsd-spec-phase && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/12652" && unzip -o skill.zip -d .claude/skills/gsd-spec-phase && rm skill.zip

Installs to .claude/skills/gsd-spec-phase

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Clarify WHAT a phase delivers with ambiguity scoring; produces a SPEC.md before discuss-phase.
94 charsno explicit “when” trigger
Intermediate

Key capabilities

  • Clarify phase requirements
  • Score ambiguity quantitatively
  • Generate SPEC.md before discuss-phase
  • Conduct Socratic questioning across multiple rounds
  • Commit SPEC.md with falsifiable requirements

How it works

The skill loads phase context, scouts the codebase, and runs a Socratic interview loop to score ambiguity, generating a SPEC.md when ambiguity is low.

Inputs & outputs

You give it
Phase number as GSD_ARGS, optionally with --auto or --text flags
You get back
{phase_dir}/{padded_phase}-SPEC.md with falsifiable requirements

When to use gsd-spec-phase

  • Defining scope for a new feature
  • Clarifying requirements for complex tasks
  • Creating a specification document
  • Scoring project requirements for clarity

About this skill

<codex_skill_adapter>

A. Skill Invocation

  • This skill is invoked by mentioning $gsd-spec-phase.
  • Treat all user text after $gsd-spec-phase as {{GSD_ARGS}}.
  • If no arguments are present, treat {{GSD_ARGS}} as empty.

B. AskUserQuestion → request_user_input Mapping

GSD workflows use AskUserQuestion (Claude Code syntax). Translate to Codex request_user_input:

Parameter mapping:

  • headerheader
  • questionquestion
  • Options formatted as "Label" — description{label: "Label", description: "description"}
  • Generate id from header: lowercase, replace spaces with underscores

Batched calls:

  • AskUserQuestion([q1, q2]) → single request_user_input with multiple entries in questions[]

Multi-select workaround:

  • Codex has no multiSelect. Use sequential single-selects, or present a numbered freeform list asking the user to enter comma-separated numbers.

Execute mode fallback:

  • When request_user_input is rejected (Execute mode), present a plain-text numbered list and pick a reasonable default.

C. Task() → spawn_agent Mapping

GSD workflows use Task(...) (Claude Code syntax). Translate to Codex collaboration tools:

Direct mapping:

  • Task(subagent_type="X", prompt="Y")spawn_agent(agent_type="X", message="Y")
  • Task(model="...") → omit. spawn_agent has no inline model parameter; GSD embeds the resolved per-agent model directly into each agent's .toml at install time so model_overrides from .planning/config.json and ~/.gsd/defaults.json are honored automatically by Codex's agent router.
  • fork_context: false by default — GSD agents load their own context via <files_to_read> blocks

Spawn restriction:

  • Codex restricts spawn_agent to cases where the user has explicitly requested sub-agents. When automatic spawning is not permitted, do the work inline in the current agent rather than attempting to force a spawn.

Parallel fan-out:

  • Spawn multiple agents → collect agent IDs → wait(ids) for all to complete

Result parsing:

  • Look for structured markers in agent output: CHECKPOINT, PLAN COMPLETE, SUMMARY, etc.
  • close_agent(id) after collecting results from each agent </codex_skill_adapter>
<objective> Clarify phase requirements through structured Socratic questioning with quantitative ambiguity scoring.

Position in workflow: spec-phase → discuss-phase → plan-phase → execute-phase → verify

How it works:

  1. Load phase context (PROJECT.md, REQUIREMENTS.md, ROADMAP.md, STATE.md)
  2. Scout the codebase — understand current state before asking questions
  3. Run Socratic interview loop (up to 6 rounds, rotating perspectives)
  4. Score ambiguity across 4 weighted dimensions after each round
  5. Gate: ambiguity ≤ 0.20 AND all dimensions meet minimums → write SPEC.md
  6. Commit SPEC.md — discuss-phase picks it up automatically on next run

Output: {phase_dir}/{padded_phase}-SPEC.md — falsifiable requirements that lock "what/why" before discuss-phase handles "how" </objective>

<execution_context> @/Volumes/Auxilary/Side_Projects/May_Project/.codex/get-shit-done/workflows/spec-phase.md @/Volumes/Auxilary/Side_Projects/May_Project/.codex/get-shit-done/templates/spec.md </execution_context>

<runtime_note> Copilot (VS Code): Use vscode_askquestions wherever this workflow calls AskUserQuestion. They are equivalent. </runtime_note>

<context> Phase number: {{GSD_ARGS}} (required)

Flags:

  • --auto — Skip interactive questions; the agent selects recommended defaults and writes SPEC.md
  • --text — Use plain-text numbered lists instead of TUI menus (required for /rc remote sessions)

Context files are resolved in-workflow using init phase-op. </context>

<process> Execute the spec-phase workflow from @/Volumes/Auxilary/Side_Projects/May_Project/.codex/get-shit-done/workflows/spec-phase.md end-to-end.

MANDATORY: Read the workflow file BEFORE taking any action. The workflow contains the complete step-by-step process including the Socratic interview loop, ambiguity scoring gate, and SPEC.md generation. Do not improvise from the objective summary above. </process>

<success_criteria>

  • Codebase scouted for current state before questioning begins
  • All 4 ambiguity dimensions scored after each interview round
  • Gate passed: ambiguity ≤ 0.20 AND all dimension minimums met
  • SPEC.md written with falsifiable requirements, explicit boundaries, and acceptance criteria
  • SPEC.md committed atomically
  • User knows they can now run $gsd-discuss-phase which will load SPEC.md automatically </success_criteria>

When not to use it

  • When the phase requirements are already clear and unambiguous
  • When a SPEC.md is not required for the next phase

Limitations

  • Requires user interaction for questions unless --auto flag is used
  • Multi-select questions require a workaround using sequential single-selects or numbered freeform lists

How it compares

This skill uses structured questioning and quantitative ambiguity scoring to define phase requirements, providing a more rigorous approach than manual specification writing.

Compared to similar skills

gsd-spec-phase side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
gsd-spec-phase (this skill)03moNo flagsIntermediate
pmbok-project-management389moNo flagsIntermediate
project-planner329moReviewIntermediate
spec-kit-workflow118moNo flagsIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

pmbok-project-management

jgtolentino

Comprehensive PMP/PMBOK project management methodologies and best practices. Use this skill when users need guidance on project management processes, templates, knowledge areas, process groups, tools, techniques, or certification preparation. Covers all 10 PMBOK Knowledge Areas and 5 Process Groups with practical templates, frameworks, and industry-standard approaches. Includes risk management, stakeholder engagement, schedule management, cost control, quality assurance, and resource planning.

38183

project-planner

adrianpuiu

Comprehensive project planning and documentation generator for software projects. Creates structured requirements documents, system design documents, and task breakdown plans with implementation tracking. Use when starting a new project, defining specifications, creating technical designs, or breaking down complex systems into implementable tasks. Supports user story format, acceptance criteria, component design, API specifications, and hierarchical task decomposition with requirement traceability.

32115

spec-kit-workflow

jmanhype

Guides specification-driven development workflow. Automatically invoked when discussing new features, specifications, technical planning, or implementation tasks. Ensures proper workflow phases (specify → clarify → plan → checklist → tasks → analyze → implement).

11111

product-manager-toolkit

davila7

Comprehensive toolkit for product managers including RICE prioritization, customer interview analysis, PRD templates, discovery frameworks, and go-to-market strategies. Use for feature prioritization, user research synthesis, requirement documentation, and product strategy development.

3280

planning-agent

parcadei

Planning agent that creates implementation plans and handoffs from conversation context

531

pdd

mikeyobrien

Transforms a rough idea into a detailed design document with implementation plan. Follows Prompt-Driven Development — iterative requirements clarification, research, design, and planning.

66

Search skills

Search the agent skills registry