@ngxtm/devkit 3.11.1 → 3.13.0

package/SKILLS_INDEX.md

@@ -1036,7 +1036,7 @@ Identifies high-quality leads for your product or service by analyzing your busi
 ### learn
 `skills/learn`
 
-Interactive step-by-step learning mode. Teaches concepts from basics to advanced while solving real problems. Auto-detects language, verifies code at ...
+Guided project building — you code, AI mentors. Build your own product step-by-step with best practices and deep understanding.
 
 ### legacy-modernizer
 `skills/legacy-modernizer`

package/merged-commands/learn.md

@@ -1,16 +1,16 @@
 ---
 name: learn
-description: Interactive learning mode. Teaches by doing with verified code, adaptive difficulty, and Socratic questioning.
+description: Guided project building — you code, AI mentors. Build your own product step-by-step with best practices and deep understanding.
 argument-hint: [topic]
 ---
 
-# Learn Mode v2.0
+# Learn Mode v3.0
 
-> Learn by doing. Verified at every step. Adapted to your level.
+> Build your product. Write every line. Understand every decision.
 
 ## Activation
 
-`/learn "topic"` — e.g., `/learn "JWT auth in Express"`, `/learn "React custom hooks"`
+`/learn "topic"` — e.g., `/learn "JWT auth in Express"`, `/learn "build real-time chat"`
 
 ---
 
@@ -44,13 +44,23 @@ If multiple detected → ask user. If none → ask user.
 
 3. **Codebase scan**: Read key project files (entry points, configs, existing code related to topic) for context. Use project's conventions in all examples.
 
-4. **Mode from codingLevel** (read from `.claude/.ck.json`):
+4. **Difficulty from codingLevel** (read from `.claude/.ck.json`):
    - Level 0-1 → **Deep**: full concepts, analogies, Socratic questions at every step
    - Level 2-3 → **Standard**: concepts + code, balanced explanations
    - Level 4-5 → **Quick**: minimal explanation, jump straight to code
    - Not set → ask user with `AskUserQuestion`
 
-5. **Create output file**: `learn/{YYYY-MM-DD}-{topic-slug}.md` with YAML frontmatter:
+5. **Teaching mode** — ask user via `AskUserQuestion`:
+
+| Mode | Who codes? | AI does what? | Best for |
+|------|-----------|---------------|----------|
+| **Guided** | User writes all code | Describe task + review after | Deep understanding, own the code |
+| **Scaffolded** | User fills in key parts | Provide skeleton + hints | Learning new patterns |
+| **Demonstrated** | AI writes, user reads | Write code + explain | Quick overview, reading comprehension |
+
+   Default suggestion based on difficulty: Deep → Guided, Standard → Scaffolded, Quick → Demonstrated.
+
+6. **Create output file**: `learn/{YYYY-MM-DD}-{topic-slug}.md` with YAML frontmatter:
 ```yaml
 ---
 topic: "{topic}"
@@ -58,7 +68,8 @@ language: {detected}
 phase: INIT
 step: 0
 total_steps: 0
-mode: {deep|standard|quick}
+difficulty: {deep|standard|quick}
+teaching: {guided|scaffolded|demonstrated}
 started: {ISO timestamp}
 updated: {ISO timestamp}
 ---
@@ -66,7 +77,7 @@ updated: {ISO timestamp}
 
 ---
 
-## Phase 2: LEARN (skip entirely in Quick mode)
+## Phase 2: LEARN (skip entirely in Quick difficulty)
 
 1. **WebSearch** official docs: `WebSearch("{topic} {language} official documentation")`, then `WebFetch` the most relevant result. Cite sources in tutorial.
 
@@ -86,24 +97,75 @@ Update frontmatter: `phase: LEARN`
 
 1. **Plan steps**: Break implementation into 3-7 verifiable steps. Show plan to user.
 
-2. **For each step**:
+2. **For each step, follow the teaching mode**:
+
+### Guided Mode (user codes everything)
+
+   a. **Describe the task**: Explain WHAT to implement and WHY. Include:
+      - The goal of this step
+      - Which file(s) to create or modify
+      - Key concepts/APIs to use
+      - Acceptance criteria (what "done" looks like)
+      - **Do NOT show the solution code.**
+
+   b. **User codes**: Tell user to write the code. Wait for them to say "done" or ask for help.
+      - If user asks for a hint → give a small hint, not the full answer
+      - If user is stuck after 2 hints → offer to show one specific part
+
+   c. **AI reviews**: Read the file(s) user modified. Provide:
+      - Does it work? Run verify commands.
+      - Best-practice review: naming, patterns, security, performance
+      - Specific feedback: "Line X: consider Y because Z"
+      - If issues found → explain and let user fix (don't fix for them)
+
+   d. **Socratic**: "Why did you choose this approach?" or "What happens if X fails?" via `AskUserQuestion`
+
+### Scaffolded Mode (AI provides skeleton, user fills in)
 
-   a. **Explain** what we're doing and why (skip in Quick mode)
+   a. **Explain** what we're building and why
+
+   b. **Write skeleton code** with clearly marked `// TODO: implement` sections. Use `Edit`/`Write` tools. The skeleton should include:
+      - File structure and imports
+      - Function signatures with parameter types
+      - Comments describing what each TODO section should do
+      - Keep TODOs focused (each is 3-15 lines of real code)
+
+   c. **User fills in TODOs**: Wait for user to complete them.
+
+   d. **AI reviews**: Read filled-in code. Same review process as Guided mode.
+
+### Demonstrated Mode (AI codes, user reads)
+
+   a. **Explain** what we're doing and why
 
    b. **Write real code** — no placeholders, no pseudocode. Use project conventions. Use `Edit` for existing files, `Write` for new files.
 
-   c. **Tiered verify**:
-      - Always: run syntax check command from table above
+   c. **Explain key decisions**: After writing, highlight WHY specific choices were made.
+
+### All Modes — after coding:
+
+   e. **Tiered verify**:
+      - Always: run syntax check command from language table
       - When possible: run the code
       - If test framework detected: write/run a test
 
-   d. **Socratic** (Deep mode only): Ask "Why did we use X instead of Y?" via `AskUserQuestion`
+   f. **Best-practice review** (all modes): Check the completed code for:
+      - Security issues (injection, XSS, exposed secrets)
+      - Anti-patterns for the language/framework
+      - Naming and convention consistency with project
+      - Performance concerns
+      - Present findings to user with explanations
 
-   e. **Checkpoint**: `AskUserQuestion` — "Step {N}/{total} verified. Understood?"
-      - If user reports error → debug, fix, re-verify, update tutorial
+   g. **Checkpoint**: `AskUserQuestion` — "Step {N}/{total} verified. Ready for next?"
+      - If user reports error → debug together (Guided: guide user to fix; Demonstrated: fix directly)
       - If user needs explanation → explain, then continue
 
-   f. **Write to tutorial file**: step title, explanation, code, key points, verify result
+   h. **Explain-back check** (every 2-3 steps): Ask user via `AskUserQuestion`:
+      > "Quick check — can you explain in your own words what we built in the last {N} steps and how they connect?"
+      - If user explains well → acknowledge and continue
+      - If gaps → re-explain the unclear parts before proceeding
+
+   i. **Write to tutorial file**: step title, explanation, code, key points, verify result
 
    Update frontmatter: `phase: BUILD`, `step: {N}`, `total_steps: {total}`
 
@@ -126,22 +188,27 @@ Display: `Tutorial saved: learn/{filename}.md`
 
 ## Principles
 
-1. **Verify everything** — never assume code works
-2. **Real code only** — no placeholders, no pseudocode
-3. **User controls pace** — always checkpoint before proceeding
-4. **Teach with their code** — use project's actual codebase, not generic examples
+1. **User owns the code** — in Guided/Scaffolded mode, user writes; AI reviews, never writes for them
+2. **Verify everything** — never assume code works
+3. **Real code only** — no placeholders, no pseudocode (except Scaffolded TODOs)
+4. **User controls pace** — always checkpoint before proceeding
+5. **Teach with their code** — use project's actual codebase, not generic examples
+6. **Best practices always** — review every step for security, patterns, conventions
+7. **Understanding > completion** — if user doesn't understand, stop and re-explain
 
 ---
 
 ## Error Handling
 
 - **Verify tool missing**: Ask user to install or switch to manual verification
-- **Code doesn't work on user's machine**: Get error message, debug, fix, re-verify, update tutorial
+- **Code doesn't work on user's machine**: Get error message, debug together, re-verify, update tutorial
 - **Language not detected**: Ask user to specify, set verify strategy accordingly
+- **User stuck in Guided mode**: After 2 hints, offer to show solution for that specific part only
 
 ---
 
 ## Version History
 
+- **3.0.0** - Teaching modes (guided/scaffolded/demonstrated), best-practice review, explain-back checkpoints, user-codes-first philosophy
 - **2.0.0** - Rewrite: adaptive difficulty via codingLevel, 4 phases, WebSearch, Socratic method, resume support, tiered verify, 17 languages, codebase-aware
 - **1.0.0** - Initial release

package/merged-commands/skill/sync.md

@@ -0,0 +1,108 @@
+---
+description: Sync new skills from upstream repos with AI evaluation
+argument-hint: [options]
+---
+
+# Sync Skills from Upstream
+
+> AI-assisted upstream skill sync: fetch, evaluate, select, build.
+
+## Workflow
+
+### Step 1: Pre-flight Check
+
+Verify clean working directory:
+```bash
+git status --porcelain
+```
+If not clean → ask user to commit or stash first.
+
+### Step 2: Fetch Upstream
+
+Run the sync script to clone upstream repos and get a report:
+```bash
+npm run sync:upstream
+```
+
+This creates a sync branch and clones repos to temp directory.
+
+### Step 3: Evaluate New Skills
+
+After the script runs, it shows which skills are new. For each **new** skill:
+
+1. Read its `SKILL.md` from the temp directory
+2. Evaluate:
+   - **Useful**: Skill covers a distinct domain not already well-covered
+   - **Duplicate**: Similar skill already exists in the local collection
+   - **Irrelevant**: Too niche or low quality
+
+3. Present summary to user:
+```
+Upstream sync found N new skills:
+
+✅ Useful (X):
+  - skill-name: short reason
+  - skill-name: short reason
+
+⚠️ Possibly duplicate (Y):
+  - skill-name: overlaps with existing-skill
+
+❌ Skip (Z):
+  - skill-name: reason
+
+Sync options:
+  1. Sync all useful (X skills)
+  2. Sync all useful + duplicates (X+Y skills)
+  3. Let me choose manually
+```
+
+### Step 4: Copy Selected Skills
+
+Use `AskUserQuestion` to get user's choice. Then for selected skills:
+
+```bash
+cp -r /tmp/devkit-sync/{source}/{skill-name} ./skills/{skill-name}
+```
+
+### Step 5: Rebuild Indexes
+
+```bash
+npm run build
+```
+
+This regenerates all indexes (merged-commands, rules-index, skills-index, skills-compact).
+
+### Step 6: Review & Commit
+
+Show summary of changes:
+```bash
+git diff --stat
+```
+
+Ask user if they want to commit:
+```bash
+git add skills/ merged-commands/ SKILLS_INDEX.md skills-index.json skills-compact.json rules-index.json
+git commit -m "feat(skills): sync N new skills from upstream"
+```
+
+## Options
+
+- `$ARGUMENTS` can specify:
+  - `--auto`: Skip evaluation, sync all new skills automatically
+  - `--dry-run`: Only show report, don't copy anything
+  - A specific upstream name to sync from (e.g., `antigravity` or `agent-assistant`)
+
+## Evaluation Criteria
+
+When evaluating skills, consider:
+- Does it cover a technology the project uses or might use?
+- Is there already a similar skill? (check by name and description)
+- Is the SKILL.md well-structured with actionable content?
+- Is it too generic (just says "be a senior X engineer")?
+
+## Important
+
+- **NEVER** auto-sync without user confirmation (unless `--auto` flag)
+- **ALWAYS** run `npm run build` after copying skills
+- Keep the sync branch for PR review if needed
+- The temp directory is at the path shown by the sync script output

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@ngxtm/devkit",
-  "version": "3.11.1",
+  "version": "3.13.0",
   "description": "Per-project AI skills with smart tech detection - lightweight and context-optimized",
   "main": "cli/index.js",
   "bin": {
     "devkit": "cli/index.js"
   },
   "scripts": {
-    "build": "npm run merge-commands && npm run organize-rules && npm run generate-index",
+    "build": "npm run merge-commands && npm run organize-rules && npm run generate-index && npm run build-compact-index",
+    "build-compact-index": "node scripts/build-compact-index.js",
     "merge-commands": "node scripts/merge-commands.js",
     "organize-rules": "node scripts/organize-rules.js",
     "generate-index": "node scripts/generate-index.js",

package/rules-index.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "generatedAt": "2026-01-28T15:40:42.094Z",
+  "generatedAt": "2026-02-19T07:09:25.835Z",
   "templates": {
     "dart": {
       "path": "templates/dart/rules",
@@ -9,6 +9,13 @@
       ],
       "sizeKB": 4
     },
+    "dotnet": {
+      "path": "templates/dotnet/rules",
+      "rules": [
+        "dotnet"
+      ],
+      "sizeKB": 92
+    },
     "flutter": {
       "path": "templates/flutter/rules",
       "rules": [

package/skills/learn/SKILL.md

@@ -1,16 +1,16 @@
 ---
 name: learn
-description: Interactive learning mode. Teaches by doing with verified code, adaptive difficulty, and Socratic questioning.
+description: Guided project building — you code, AI mentors. Build your own product step-by-step with best practices and deep understanding.
 argument-hint: [topic]
 ---
 
-# Learn Mode v2.0
+# Learn Mode v3.0
 
-> Learn by doing. Verified at every step. Adapted to your level.
+> Build your product. Write every line. Understand every decision.
 
 ## Activation
 
-`/learn "topic"` — e.g., `/learn "JWT auth in Express"`, `/learn "React custom hooks"`
+`/learn "topic"` — e.g., `/learn "JWT auth in Express"`, `/learn "build real-time chat"`
 
 ---
 
@@ -44,13 +44,23 @@ If multiple detected → ask user. If none → ask user.
 
 3. **Codebase scan**: Read key project files (entry points, configs, existing code related to topic) for context. Use project's conventions in all examples.
 
-4. **Mode from codingLevel** (read from `.claude/.ck.json`):
+4. **Difficulty from codingLevel** (read from `.claude/.ck.json`):
    - Level 0-1 → **Deep**: full concepts, analogies, Socratic questions at every step
    - Level 2-3 → **Standard**: concepts + code, balanced explanations
    - Level 4-5 → **Quick**: minimal explanation, jump straight to code
    - Not set → ask user with `AskUserQuestion`
 
-5. **Create output file**: `learn/{YYYY-MM-DD}-{topic-slug}.md` with YAML frontmatter:
+5. **Teaching mode** — ask user via `AskUserQuestion`:
+
+| Mode | Who codes? | AI does what? | Best for |
+|------|-----------|---------------|----------|
+| **Guided** | User writes all code | Describe task + review after | Deep understanding, own the code |
+| **Scaffolded** | User fills in key parts | Provide skeleton + hints | Learning new patterns |
+| **Demonstrated** | AI writes, user reads | Write code + explain | Quick overview, reading comprehension |
+
+   Default suggestion based on difficulty: Deep → Guided, Standard → Scaffolded, Quick → Demonstrated.
+
+6. **Create output file**: `learn/{YYYY-MM-DD}-{topic-slug}.md` with YAML frontmatter:
 ```yaml
 ---
 topic: "{topic}"
@@ -58,7 +68,8 @@ language: {detected}
 phase: INIT
 step: 0
 total_steps: 0
-mode: {deep|standard|quick}
+difficulty: {deep|standard|quick}
+teaching: {guided|scaffolded|demonstrated}
 started: {ISO timestamp}
 updated: {ISO timestamp}
 ---
@@ -66,7 +77,7 @@ updated: {ISO timestamp}
 
 ---
 
-## Phase 2: LEARN (skip entirely in Quick mode)
+## Phase 2: LEARN (skip entirely in Quick difficulty)
 
 1. **WebSearch** official docs: `WebSearch("{topic} {language} official documentation")`, then `WebFetch` the most relevant result. Cite sources in tutorial.
 
@@ -86,24 +97,75 @@ Update frontmatter: `phase: LEARN`
 
 1. **Plan steps**: Break implementation into 3-7 verifiable steps. Show plan to user.
 
-2. **For each step**:
+2. **For each step, follow the teaching mode**:
+
+### Guided Mode (user codes everything)
+
+   a. **Describe the task**: Explain WHAT to implement and WHY. Include:
+      - The goal of this step
+      - Which file(s) to create or modify
+      - Key concepts/APIs to use
+      - Acceptance criteria (what "done" looks like)
+      - **Do NOT show the solution code.**
+
+   b. **User codes**: Tell user to write the code. Wait for them to say "done" or ask for help.
+      - If user asks for a hint → give a small hint, not the full answer
+      - If user is stuck after 2 hints → offer to show one specific part
+
+   c. **AI reviews**: Read the file(s) user modified. Provide:
+      - Does it work? Run verify commands.
+      - Best-practice review: naming, patterns, security, performance
+      - Specific feedback: "Line X: consider Y because Z"
+      - If issues found → explain and let user fix (don't fix for them)
+
+   d. **Socratic**: "Why did you choose this approach?" or "What happens if X fails?" via `AskUserQuestion`
+
+### Scaffolded Mode (AI provides skeleton, user fills in)
 
-   a. **Explain** what we're doing and why (skip in Quick mode)
+   a. **Explain** what we're building and why
+
+   b. **Write skeleton code** with clearly marked `// TODO: implement` sections. Use `Edit`/`Write` tools. The skeleton should include:
+      - File structure and imports
+      - Function signatures with parameter types
+      - Comments describing what each TODO section should do
+      - Keep TODOs focused (each is 3-15 lines of real code)
+
+   c. **User fills in TODOs**: Wait for user to complete them.
+
+   d. **AI reviews**: Read filled-in code. Same review process as Guided mode.
+
+### Demonstrated Mode (AI codes, user reads)
+
+   a. **Explain** what we're doing and why
 
    b. **Write real code** — no placeholders, no pseudocode. Use project conventions. Use `Edit` for existing files, `Write` for new files.
 
-   c. **Tiered verify**:
-      - Always: run syntax check command from table above
+   c. **Explain key decisions**: After writing, highlight WHY specific choices were made.
+
+### All Modes — after coding:
+
+   e. **Tiered verify**:
+      - Always: run syntax check command from language table
       - When possible: run the code
       - If test framework detected: write/run a test
 
-   d. **Socratic** (Deep mode only): Ask "Why did we use X instead of Y?" via `AskUserQuestion`
+   f. **Best-practice review** (all modes): Check the completed code for:
+      - Security issues (injection, XSS, exposed secrets)
+      - Anti-patterns for the language/framework
+      - Naming and convention consistency with project
+      - Performance concerns
+      - Present findings to user with explanations
 
-   e. **Checkpoint**: `AskUserQuestion` — "Step {N}/{total} verified. Understood?"
-      - If user reports error → debug, fix, re-verify, update tutorial
+   g. **Checkpoint**: `AskUserQuestion` — "Step {N}/{total} verified. Ready for next?"
+      - If user reports error → debug together (Guided: guide user to fix; Demonstrated: fix directly)
       - If user needs explanation → explain, then continue
 
-   f. **Write to tutorial file**: step title, explanation, code, key points, verify result
+   h. **Explain-back check** (every 2-3 steps): Ask user via `AskUserQuestion`:
+      > "Quick check — can you explain in your own words what we built in the last {N} steps and how they connect?"
+      - If user explains well → acknowledge and continue
+      - If gaps → re-explain the unclear parts before proceeding
+
+   i. **Write to tutorial file**: step title, explanation, code, key points, verify result
 
    Update frontmatter: `phase: BUILD`, `step: {N}`, `total_steps: {total}`
 
@@ -126,22 +188,27 @@ Display: `Tutorial saved: learn/{filename}.md`
 
 ## Principles
 
-1. **Verify everything** — never assume code works
-2. **Real code only** — no placeholders, no pseudocode
-3. **User controls pace** — always checkpoint before proceeding
-4. **Teach with their code** — use project's actual codebase, not generic examples
+1. **User owns the code** — in Guided/Scaffolded mode, user writes; AI reviews, never writes for them
+2. **Verify everything** — never assume code works
+3. **Real code only** — no placeholders, no pseudocode (except Scaffolded TODOs)
+4. **User controls pace** — always checkpoint before proceeding
+5. **Teach with their code** — use project's actual codebase, not generic examples
+6. **Best practices always** — review every step for security, patterns, conventions
+7. **Understanding > completion** — if user doesn't understand, stop and re-explain
 
 ---
 
 ## Error Handling
 
 - **Verify tool missing**: Ask user to install or switch to manual verification
-- **Code doesn't work on user's machine**: Get error message, debug, fix, re-verify, update tutorial
+- **Code doesn't work on user's machine**: Get error message, debug together, re-verify, update tutorial
 - **Language not detected**: Ask user to specify, set verify strategy accordingly
+- **User stuck in Guided mode**: After 2 hints, offer to show solution for that specific part only
 
 ---
 
 ## Version History
 
+- **3.0.0** - Teaching modes (guided/scaffolded/demonstrated), best-practice review, explain-back checkpoints, user-codes-first philosophy
 - **2.0.0** - Rewrite: adaptive difficulty via codingLevel, 4 phases, WebSearch, Socratic method, resume support, tiered verify, 17 languages, codebase-aware
 - **1.0.0** - Initial release

package/skills-index.json

@@ -1977,7 +1977,7 @@
   {
     "name": "learn",
     "path": "skills/learn",
-    "description": "Interactive step-by-step learning mode. Teaches concepts from basics to advanced while solving real problems. Auto-detects language, verifies code at each step, creates markdown tutorials. Triggers on"
+    "description": "Guided project building — you code, AI mentors. Build your own product step-by-step with best practices and deep understanding."
   },
   {
     "name": "legacy-modernizer",

package/templates/base/rules/auto-skill.md

@@ -48,11 +48,12 @@ User Request → Extract keywords (react, auth, test, etc.)
 ### Step 1: Read Compact Index
 ```
 Read: .claude/skills-compact.json
-Format: { "_categories": {...}, "skills": { "skill-name": "category-code" } }
+Format: { "_categories": {...}, "skills": { "skill-name": { "c": "category", "d": "short description" } } }
+Note: Some skills may be just a category string if no description available.
 ```
 
 ### Step 2: Match by Name/Keyword
-Look for skills whose name contains user's keywords:
+Look for skills whose name OR description contains user's keywords:
 - User says "react" → find skills with "react" in name
 - User says "authentication" → find "auth" skills
 - User says "docker" → find "docker" skills

package/templates/base/rules/command-routing.md

@@ -0,0 +1,71 @@
+# Command Routing Guide
+
+> Help Claude choose the right command and execution mode for each task.
+
+## Decision Tree
+
+```
+Is this a learning/educational request?
+  → /learn
+
+Is this brainstorming/ideation only (no code)?
+  → /brainstorm
+
+Is this just planning (no implementation)?
+  → /plan
+
+Is this a bug fix?
+  → /fix (simple) or /fix:hard (complex)
+
+Is this a small, well-defined task?
+  → /cook:fast
+
+Is this a medium task with clear requirements?
+  → /cook:auto (auto: plan → code → commit)
+  → OR /plan → /code (manual control)
+
+Is this a complex, full-lifecycle feature?
+  → /cook:hard (includes brainstorm+research+plan+code+test+review)
+  → OR /brainstorm → /plan → /code (manual, more control)
+```
+
+## Anti-Patterns
+
+- **NEVER** chain `/brainstorm` → `/plan` before `/cook:hard` — it already includes both internally, causing duplicate work
+- **NEVER** use `/cook:hard` for trivial fixes — overkill, wastes context
+- **NEVER** use `/cook:fast` for complex features — skips research/design, leads to rework
+
+## Command Reference
+
+| Command | Complexity | Multi-Agent | Best For |
+|---------|-----------|-------------|----------|
+| `/cook:fast` | Low | Light (scouter, engineer) | Well-defined small tasks |
+| `/cook` | Medium | Yes (full team) | Standard feature work |
+| `/cook:auto` | Medium | Yes (plan → code → git) | Autonomous implementation |
+| `/cook:hard` | High | Full (8 phases, all agents) | Complex features from scratch |
+| `/brainstorm` | N/A | No | Ideation, design exploration |
+| `/plan` | N/A | Optional (researcher) | Creating implementation plans |
+| `/code` | Medium | Yes (tester, reviewer) | Executing an existing plan |
+| `/learn` | N/A | No | Interactive tutorials |
+| `/fix` | Low | No | Quick bug fixes |
+| `/fix:hard` | Medium | Yes (debugger, tester) | Complex debugging |
+
+## Multi-Agent Phases in /cook:hard
+
+```
+Phase 1: brainstormer  → Requirements discovery
+Phase 2: researcher    → Best practices research
+Phase 3: scouter       → Codebase analysis
+Phase 4: designer      → UI/UX design (if needed)
+Phase 5: planner       → Implementation plan
+Phase 6: tech-lead     → Routes to specialist engineers
+Phase 7: tester        → Testing
+Phase 8: reviewer      → Code review
+```
+
+## When to Suggest Skills
+
+After choosing the right command, check if a domain-specific skill would help:
+- User says "react" → suggest `/react-expert` skill alongside chosen command
+- User says "auth" → suggest `/auth-implementation-patterns` skill
+- See `auto-skill.md` for full detection flow