gsd-cc 0.2.1 → 0.3.1

package/bin/install.js

@@ -27,7 +27,7 @@ ${cyan}   ██████╗ ███████╗██████╗
 `;
 
 // Sub-skills that get their own top-level directory under .claude/skills/
-const SUB_SKILLS = ['apply', 'auto', 'discuss', 'plan', 'seed', 'status', 'unify', 'update'];
+const SUB_SKILLS = ['apply', 'auto', 'discuss', 'help', 'plan', 'seed', 'status', 'tutorial', 'unify', 'update'];
 
 // Shared directories that go into gsd-cc-shared/
 const SHARED_DIRS = ['checklists', 'prompts', 'templates'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-cc",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Get Shit Done on Claude Code — structured AI development with your Max plan",
   "author": "Philipp Briese (https://github.com/0ui-labs)",
   "homepage": "https://github.com/0ui-labs/GSD-CC#readme",

package/skills/gsd/SKILL.md

@@ -148,6 +148,8 @@ When routing to a sub-skill, tell the user what you're doing and then invoke the
 - Auto mode → `/gsd-cc-auto`
 - Status overview → `/gsd-cc-status`
 - Update skills → `/gsd-cc-update`
+- Help → `/gsd-cc-help`
+- Tutorial → `/gsd-cc-tutorial`
 
 Power users can invoke these directly. But the default path only needs `/gsd-cc` + Enter.
 

package/skills/gsd/help/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: gsd-cc-help
+description: >
+  Show available GSD-CC commands and how they work. Use when user says
+  /gsd-cc-help, /gsd-cc help, or asks what commands are available.
+allowed-tools: Read, Glob
+---
+
+# /gsd-cc-help — Command Reference
+
+## Language
+
+Read the `language` field from `.gsd/STATE.md` if it exists. All output must use that language. If no project exists or no language is set, default to English.
+
+## Output
+
+Show this reference, adapted to the configured language:
+
+```
+GSD-CC — Get Shit Done on Claude Code
+
+MAIN COMMAND
+  /gsd-cc                 Reads project state, suggests the next action.
+                          This is the only command you need.
+
+PHASE COMMANDS (power users)
+  /gsd-cc-seed            Start a new project — guided ideation
+  /gsd-cc-discuss         Resolve ambiguities before planning
+  /gsd-cc-plan            Break a slice into tasks with acceptance criteria
+  /gsd-cc-apply           Execute the next task (manual mode)
+  /gsd-cc-auto            Start autonomous execution via claude -p
+  /gsd-cc-unify           Mandatory plan-vs-actual reconciliation
+
+INFO & MANAGEMENT
+  /gsd-cc-status          Show project progress and AC tracking
+  /gsd-cc-update          Update GSD-CC to the latest version
+  /gsd-cc-help            This help screen
+  /gsd-cc-tutorial        Guided walkthrough with a sample project
+
+THE FLOW
+  1. /gsd-cc  →  Seed (what are you building?)
+  2. /gsd-cc  →  Roadmap (milestones and slices)
+  3. /gsd-cc  →  Plan (tasks with ACs and boundaries)
+  4. /gsd-cc  →  Execute (manual or auto)
+  5. /gsd-cc  →  UNIFY (mandatory quality check)
+  6. /gsd-cc  →  Next slice or milestone complete
+
+PROJECT FILES
+  .gsd/STATE.md           Current position and progress
+  .gsd/PLANNING.md        Project brief from ideation
+  .gsd/PROJECT.md         Elevator pitch (3-5 sentences)
+  .gsd/M001-ROADMAP.md    Milestones and slices
+  .gsd/S01-PLAN.md        Slice plan with architecture notes
+  .gsd/S01-T01-PLAN.md    Task plan with ACs and boundaries
+  .gsd/S01-T01-SUMMARY.md What actually happened
+  .gsd/S01-UNIFY.md       Plan vs. actual comparison
+  .gsd/DECISIONS.md       All decisions, append-only
+  .gsd/COSTS.jsonl        Token usage tracking (auto-mode)
+
+TIPS
+  • You only need /gsd-cc — it always knows what to do next
+  • Type "auto" when asked to run tasks autonomously
+  • Come back tomorrow — state survives between sessions
+  • UNIFY cannot be skipped — it's what keeps quality high
+```
+
+## After showing help
+
+If a `.gsd/` directory exists, add a one-line status: where the project currently is and what the suggested next step would be.

package/skills/gsd/tutorial/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: gsd-cc-tutorial
+description: >
+  Interactive walkthrough that builds a small sample project step by step.
+  Use when user says /gsd-cc-tutorial, /gsd-cc tutorial, or asks for a
+  guided introduction to GSD-CC.
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# /gsd-cc-tutorial — Guided Walkthrough
+
+You guide the user through building a small project with GSD-CC, explaining each phase as it happens. This is a teaching mode — go slow, explain what's happening and why.
+
+## Language
+
+Ask the user which language to use before starting, just like `/gsd-cc-seed` does. Default to English.
+
+## Step 1: Welcome
+
+```
+Welcome to the GSD-CC Tutorial!
+
+I'll walk you through building a small project from start to finish.
+You'll see every phase in action: Seed → Plan → Execute → UNIFY.
+
+The whole tutorial takes about 10-15 minutes.
+
+We'll build a simple CLI tool together — small enough to finish quickly,
+big enough to see every GSD-CC feature.
+
+Ready? (yes to start)
+```
+
+Wait for confirmation.
+
+## Step 2: Explain the Philosophy
+
+Briefly explain (3-4 sentences max):
+- Claude Code is the agent, GSD-CC tells it what to do and when
+- Projects are broken into Milestones → Slices → Tasks
+- Each task fits one context window (fresh session, no context rot)
+- UNIFY checks that what was built matches what was planned
+
+Then say: "Let's start. I'll run `/gsd-cc-seed` now — this is the ideation phase."
+
+## Step 3: Run Seed (with commentary)
+
+Delegate to `/gsd-cc-seed` but with a twist: use this project idea:
+
+```
+A Node.js CLI tool called "mdcount" that counts words, sentences,
+and reading time in Markdown files. Takes a file path as argument,
+outputs a summary.
+```
+
+Let the user confirm or pick their own idea. If they pick their own, use that instead.
+
+Before each seed question, add a brief explanation:
+- "Now I'll ask about [topic]. This helps me understand [why]."
+
+After seed completes, explain what was created:
+- "Seed created 5 files in .gsd/. Let me show you the key one..."
+- Show a brief excerpt of PLANNING.md
+
+## Step 4: Run Roadmap (with commentary)
+
+Say: "Next, /gsd-cc would create a roadmap. For this small project, we'll have 1 milestone with 2-3 slices."
+
+Create the roadmap. After creation, explain:
+- What a milestone is (a major deliverable)
+- What a slice is (a coherent work unit, 2-7 tasks)
+- Why ordering matters (foundations first)
+
+## Step 5: Run Plan (with commentary)
+
+Say: "Now I'll plan the first slice in detail. Each task gets acceptance criteria (Given/When/Then) and boundaries (what NOT to touch)."
+
+Delegate to `/gsd-cc-plan`. After planning, show:
+- One task plan as an example
+- Highlight the acceptance criteria format
+- Highlight the boundaries section
+- "These boundaries prevent Claude from going on tangents — a common problem in AI coding."
+
+## Step 6: Execute One Task (manual)
+
+Say: "Let's execute the first task manually so you can see what happens."
+
+Delegate to `/gsd-cc-apply` for T01 only. After execution:
+- Show the SUMMARY.md that was created
+- Explain how it compares to the plan
+- "In auto-mode, this happens for every task without you doing anything."
+
+## Step 7: Explain Auto-Mode
+
+Don't actually run auto-mode (that would take too long for a tutorial). Instead explain:
+- "For the remaining tasks, you'd type `/gsd-cc` and choose 'auto'"
+- "Auto-mode runs each task in a fresh `claude -p` session"
+- "It uses your Max Plan — no API costs"
+- "When all tasks in a slice are done, UNIFY runs automatically"
+
+## Step 8: Explain UNIFY
+
+Explain what UNIFY does:
+- Compares what was planned vs. what was built
+- Documents deviations and decisions
+- Cannot be skipped — the router blocks until it's done
+- "This is what prevents 'it sort of works but doesn't match the design'"
+
+## Step 9: Wrap Up
+
+```
+That's GSD-CC!
+
+What you learned:
+  ✓ Seed     — turns your idea into a structured plan
+  ✓ Roadmap  — breaks it into milestones and slices
+  ✓ Plan     — creates tasks with acceptance criteria + boundaries
+  ✓ Apply    — executes tasks (manual or auto)
+  ✓ UNIFY    — mandatory quality check after each slice
+
+Next steps:
+  1. Delete this tutorial project: rm -rf .gsd/
+  2. Start your real project: /gsd-cc
+  3. Or explore: /gsd-cc-help for all commands
+
+Happy building!
+```
+
+## Rules
+
+- **Go slow.** This is teaching, not production. Pause between phases.
+- **Explain the WHY**, not just the what. Users should understand the design decisions.
+- **Keep the project small.** 1 milestone, 2-3 slices, 2-3 tasks per slice max.
+- **Only execute 1 task.** The tutorial should take 10-15 minutes, not an hour.
+- **Be encouraging.** The user is learning something new.