5-phase-workflow 1.4.2 → 1.4.4

package/src/commands/5/configure.md

@@ -1,6 +1,6 @@
 ---
 name: 5:configure
-description: Phase 1 of project configuration. Analyzes project, gathers preferences, and creates a configuration feature spec. Follow up with /5:plan-implementation CONFIGURE.
+description: Configures the project. Analyzes project, gathers preferences, writes config.json, and creates feature spec for remaining setup. Follow up with /5:plan-implementation CONFIGURE.
 allowed-tools: Read, Write, Bash, Glob, Grep, AskUserQuestion
 context: inherit
 user-invocable: true
@@ -10,7 +10,7 @@ user-invocable: true
 
 ## Overview
 
-This command is **Phase 1** of the 5-phase workflow applied to project configuration itself. It analyzes the project, asks the user questions, and outputs a feature spec at `.5/CONFIGURE/feature.md`.
+This command is **Phase 1** of the 5-phase workflow applied to project configuration itself. It analyzes the project, asks the user questions, and outputs a feature spec at `.5/features/CONFIGURE/feature.md`.
 
 After running this command, proceed through the standard phases:
 1. **`/5:configure`** (this command) - Plan the configuration feature
@@ -21,34 +21,25 @@ After running this command, proceed through the standard phases:
 
 ## ⚠️ CRITICAL SCOPE CONSTRAINT
 
-**THIS COMMAND ONLY CREATES THE CONFIGURATION FEATURE SPEC. IT DOES NOT CONFIGURE.**
+**THIS COMMAND WRITES config.json AND CREATES THE FEATURE SPEC. NOTHING ELSE.**
 
 Your job in this command:
 ✅ Analyze project (detect type, build commands, etc.)
 ✅ Gather user preferences via questions
-✅ Create feature spec at `.5/CONFIGURE/feature.md`
+✅ Write `.claude/.5/config.json` directly
+✅ Create feature spec at `.5/features/CONFIGURE/feature.md` for remaining work
 ✅ Tell user to run /5:plan-implementation CONFIGURE
 
 Your job is NOT:
-❌ Write config.json directly (Phase 3 does this)
 ❌ Create CLAUDE.md directly (Phase 3 does this)
+❌ Generate documentation files directly (Phase 3 does this)
 ❌ Generate skills directly (Phase 3 does this)
 ❌ Skip user interaction
 ❌ Assume project structure
 
-**After creating the feature spec and informing the user, YOUR JOB IS COMPLETE. EXIT IMMEDIATELY.**
+**After writing config.json, creating the feature spec, and informing the user, YOUR JOB IS COMPLETE. EXIT IMMEDIATELY.**
 
-## ❌ Boundaries: What This Command Does NOT Do
-
-**CRITICAL:** This command has a LIMITED scope. Do NOT:
-
-- ❌ **Write config.json** - That's Phase 3's job (via configure-project skill)
-- ❌ **Create CLAUDE.md** - That's Phase 3's job
-- ❌ **Generate skills** - That's Phase 3's job
-- ❌ **Skip questions** - Always confirm detected values with user
-- ❌ **Assume structure** - Detect or ask, don't guess
-
-**If you find yourself creating config files or CLAUDE.md, STOP IMMEDIATELY. You should only be creating the feature spec.**
+**If you find yourself creating CLAUDE.md, documentation files, or skills, STOP IMMEDIATELY. You should only be writing config.json and the feature spec.**
 
 ## Configuration Process
 
@@ -67,56 +58,25 @@ else
 fi
 ```
 
-**1b. Detect project type** by examining files:
-
-```javascript
-// Node.js/JavaScript/TypeScript
-if (exists('package.json')) {
-  const pkg = readJSON('package.json');
-
-  if (pkg.dependencies?.['next'] || pkg.devDependencies?.['next'])
-    return 'nextjs';
-  if (pkg.dependencies?.['@nestjs/core'])
-    return 'nestjs';
-  if (pkg.dependencies?.['express'])
-    return 'express';
-  if (pkg.dependencies?.['react'])
-    return 'react';
-  if (pkg.dependencies?.['vue'])
-    return 'vue';
-
-  return 'javascript';
-}
-
-// Java
-if (exists('build.gradle') || exists('build.gradle.kts'))
-  return 'gradle-java';
-if (exists('pom.xml'))
-  return 'maven-java';
-
-// Python
-if (exists('requirements.txt') || exists('pyproject.toml')) {
-  if (exists('manage.py')) return 'django';
-  if (exists('app.py') || exists('wsgi.py')) return 'flask';
-  return 'python';
-}
-
-// Rust
-if (exists('Cargo.toml'))
-  return 'rust';
-
-// Go
-if (exists('go.mod'))
-  return 'go';
-
-// Ruby
-if (exists('Gemfile')) {
-  if (exists('config/routes.rb')) return 'rails';
-  return 'ruby';
-}
-
-return 'unknown';
-```
+**1b. Detect project type** by checking files (first match wins):
+
+| File Present | Dependency / Sub-check | Type |
+|---|---|---|
+| `package.json` | `next` | nextjs |
+| `package.json` | `@nestjs/core` | nestjs |
+| `package.json` | `express` | express |
+| `package.json` | `react` | react |
+| `package.json` | `vue` | vue |
+| `package.json` | *(none matched)* | javascript |
+| `build.gradle(.kts)` | — | gradle-java |
+| `pom.xml` | — | maven-java |
+| `requirements.txt` / `pyproject.toml` | + `manage.py` | django |
+| `requirements.txt` / `pyproject.toml` | + `app.py`/`wsgi.py` | flask |
+| `requirements.txt` / `pyproject.toml` | *(none matched)* | python |
+| `Cargo.toml` | — | rust |
+| `go.mod` | — | go |
+| `Gemfile` | + `config/routes.rb` | rails |
+| `Gemfile` | *(none matched)* | ruby |
 
 **1c. Detect build/test commands** based on project type:
 
@@ -158,126 +118,31 @@ fi
 
 **1g. Detect codebase patterns** for potential skills:
 
-Use Glob to count files matching common architectural patterns:
-
-| Pattern | Glob Patterns                                                                 | Typical Location |
-|---------|-------------------------------------------------------------------------------|------------------|
-| **Core Architecture** |                                                                               | |
-| Controllers | `**/*Controller.{ts,js,java,py,rb}`, `**/controllers/**`                      | src/controllers/ |
-| Services | `**/*Service.{ts,js,java,py,rb}`, `**/services/**`                            | src/services/ |
-| Repositories | `**/*Repository.{ts,js,java,py}`, `**/repositories/**`                        | src/repositories/ |
-| Models/Entities | `**/*Model.{ts,js}`, `**/*Entity.java`, `**/models/**`                        | src/models/ |
-| Handlers | `**/*Handler.{ts,js,java,go}`, `**/handlers/**`                               | src/handlers/ |
-| **Data Transfer** |                                                                               | |
-| DTOs | `**/*Dto.{ts,js,java}`, `**/*DTO.{ts,js,java}`, `**/dto/**`                   | src/dto/ |
-| Requests | `**/*Request.{ts,js,java}`, `**/requests/**`                                  | src/requests/ |
-| Responses | `**/*Response.{ts,js,java}`, `**/responses/**`                                | src/responses/ |
-| Mappers | `**/*Mapper.{ts,js,java}`, `**/mappers/**`                                    | src/mappers/ |
-| Validators | `**/*Validator.{ts,js,java}`, `**/validators/**`                              | src/validators/ |
-| Schemas | `**/*Schema.{ts,js}`, `**/schemas/**`                                         | src/schemas/ |
-| **Frontend (React/Vue)** |                                                                               | |
-| Components | `**/components/**/*.{tsx,jsx,vue}`                                            | src/components/ |
-| Hooks | `**/hooks/**/*.{ts,js}`, `**/use*.{ts,js}`                                    | src/hooks/ |
-| Contexts | `**/contexts/**/*.{tsx,jsx}`, `**/*Context.{tsx,jsx}`                         | src/contexts/ |
-| Stores | `**/stores/**/*.{ts,js}`, `**/*Store.{ts,js}`                                 | src/stores/ |
-| Pages | `**/pages/**/*.{tsx,jsx}`, `**/app/**/page.{tsx,jsx}`                         | pages/, app/ |
-| Layouts | `**/layouts/**/*.{tsx,jsx,vue}`, `**/*Layout.{tsx,jsx}`                       | src/layouts/ |
-| **API/Routes** |                                                                               | |
-| API Routes | `**/api/**/*.{ts,js}`, `**/routes/**`                                         | src/api/, pages/api/ |
-| Middleware | `**/*Middleware.{ts,js,java}`, `**/middleware/**`                             | src/middleware/ |
-| Guards | `**/*.guard.{ts,js}`, `**/guards/**`                                          | src/guards/ |
-| Interceptors | `**/*.interceptor.{ts,js}`, `**/interceptors/**`                              | src/interceptors/ |
-| Filters | `**/*.filter.{ts,js}`, `**/*Filter.java`                                      | src/filters/ |
-| **Testing** |                                                                               | |
-| Tests | `**/*.test.{ts,js,tsx,jsx}`, `**/*.spec.{ts,js,tsx,jsx}`, `**/tests/**`       | src/, tests/ |
-| Specs | `**/*_spec.rb`, `**/spec/**/*.rb`, `**/*_test.go`, `**/test_*.py`             | spec/, tests/ |
-| Test Fixtures | `**/fixtures/**`,`**/testFixtures/**`, `**/__fixtures__/**`, `**/testdata/**` | fixtures/, testdata/ |
-| Factories | `**/*Factory.{ts,js,java,rb}`, `**/factories/**`                              | factories/ |
-| Mocks | `**/__mocks__/**`, `**/mocks/**`, `**/*Mock.{ts,js}`                          | __mocks__/, mocks/ |
-| **Utilities** |                                                                               | |
-| Utils | `**/utils/**/*.{ts,js,java,py}`, `**/*Utils.{ts,js,java}`                     | src/utils/ |
-| Helpers | `**/helpers/**/*.{ts,js,java,py,rb}`, `**/*Helper.{ts,js,java}`               | src/helpers/ |
-| Constants | `**/constants/**/*.{ts,js}`, `**/*Constants.{ts,js}`                          | src/constants/ |
-| Types/Interfaces | `**/types/**/*.{ts,js}`, `**/interfaces/**/*.{ts,java}`                       | src/types/ |
-| Config | `**/config/**/*.{ts,js,py}`, `**/*Config.{ts,js}`                             | src/config/ |
-| **Framework-Specific** |                                                                               | |
-| Modules (NestJS/Angular) | `**/*.module.{ts,js}`                                                         | src/modules/ |
-| Pipes (NestJS) | `**/*.pipe.{ts,js}`, `**/pipes/**`                                            | src/pipes/ |
-| Decorators | `**/decorators/**/*.{ts,js}`, `**/*.decorator.{ts,js}`                        | src/decorators/ |
-| Blueprints (Flask) | `**/blueprints/**/*.py`                                                       | blueprints/ |
-| Views (Django) | `**/views.py`, `**/views/**/*.py`                                             | app/views/ |
-| Serializers (Django) | `**/serializers.py`, `**/serializers/**/*.py`                                 | app/serializers/ |
-| **Background/Async** |                                                                               | |
-| Jobs | `**/jobs/**/*.{ts,js,rb}`, `**/*Job.{ts,js,rb}`                               | src/jobs/ |
-| Workers | `**/workers/**/*.{ts,js}`, `**/*Worker.{ts,js}`                               | src/workers/ |
-| Events | `**/events/**/*.{ts,js,java}`, `**/*Event.{ts,js,java}`                       | src/events/ |
-| Listeners | `**/listeners/**/*.{ts,js,java}`, `**/*Listener.{ts,js}`                      | src/listeners/ |
-| Commands (CLI) | `**/commands/**/*.{ts,js,java}`, `**/*Command.{ts,js}`                        | src/commands/ |
-| **Database** |                                                                               | |
-| Migrations | `**/migrations/**/*.{ts,js,sql,rb,py}`                                        | migrations/ |
-| Seeds | `**/seeds/**/*.{ts,js,rb}`, `**/seeders/**`                                   | seeds/ |
-| **Error Handling** |                                                                               | |
-| Exceptions | `**/exceptions/**/*.{ts,js,java}`, `**/*Exception.{ts,js,java}`               | src/exceptions/ |
-| Errors | `**/errors/**/*.{ts,js}`, `**/*Error.{ts,js}`                                 | src/errors/ |
-
-For each pattern found:
-- Count matching files
-- Identify primary location (most common directory)
-- Sample 1 file name to show convention
+Use Glob to scan for architectural patterns. For each, check both suffix-based (`*{Pattern}.{ts,js,java,py,rb}`) and directory-based (`{patterns}/**`) globs.
+
+**Pattern categories to scan:**
+- **Core:** Controllers, Services, Repositories, Models/Entities, Handlers
+- **Data Transfer:** DTOs, Requests, Responses, Mappers, Validators, Schemas
+- **Frontend:** Components, Hooks, Contexts, Stores, Pages, Layouts
+- **API/Routes:** API Routes, Middleware, Guards, Interceptors, Filters
+- **Testing:** Tests/Specs, Fixtures, Factories, Mocks
+- **Utilities:** Utils, Helpers, Constants, Types/Interfaces, Config
+- **Framework-Specific:** Modules, Pipes, Decorators, Blueprints, Views, Serializers
+- **Background/Async:** Jobs, Workers, Events, Listeners, Commands
+- **Database:** Migrations, Seeds
+- **Error Handling:** Exceptions, Errors
+
+For each pattern found: count matching files, identify primary location, sample 1 filename.
 
 **1h. Detect runnable commands** for potential command skills:
 
-Scan project configuration files for commands that can become skills:
-
-| Source | How to Detect | Example Commands |
-|--------|---------------|------------------|
-| package.json | Read `scripts` object | build, test, lint, format, dev, start, typecheck |
-| Makefile | Grep for targets (lines ending with `:`) | build, test, lint, clean, docker-build |
-| pyproject.toml | Read `[tool.poetry.scripts]` or `[project.scripts]` | test, lint, format, typecheck |
-| Cargo.toml | Check for `[[bin]]` sections, common cargo commands | build, test, clippy, fmt |
-| build.gradle | Grep for `task` definitions | build, test, lint, spotlessApply |
-| composer.json | Read `scripts` object | test, lint, format, analyse |
-| Rakefile | Grep for `task :name` patterns | test, lint, db:migrate, db:seed |
-
-**Common command categories to detect:**
-
-| Category | Common Names | Skill Name |
-|----------|--------------|------------|
-| **Build** | build, compile, bundle, pack | run-build |
-| **Test** | test, test:unit, test:integration, test:e2e, spec | run-tests |
-| **Lint** | lint, eslint, pylint, rubocop, clippy | run-lint |
-| **Format** | format, prettier, fmt, black, gofmt | run-format |
-| **Type Check** | typecheck, tsc, mypy, type-check | run-typecheck |
-| **Dev Server** | dev, start, serve, watch | run-dev |
-| **Database** | db:migrate, migrate, db:seed, seed, db:reset | run-db-migrate, run-db-seed |
-| **Docker** | docker:build, docker:up, docker:down, compose | run-docker |
-| **Deploy** | deploy, release, publish | run-deploy |
-| **Clean** | clean, reset, purge | run-clean |
-| **Generate** | generate, codegen, gen | run-generate |
-
-For each command found:
-- Record the exact command syntax
-- Identify any required environment or flags
-- Note if it has watch/CI variants
-
-Store results internally as:
-```json
-{
-  "detectedPatterns": {
-    "controller": { "count": 12, "location": "src/controllers/", "example": "UserController.ts" },
-    "service": { "count": 8, "location": "src/services/", "example": "AuthService.ts" },
-    "component": { "count": 25, "location": "src/components/", "example": "Button.tsx" }
-  },
-  "detectedCommands": {
-    "build": { "source": "package.json", "command": "npm run build", "variants": ["build:prod", "build:dev"] },
-    "test": { "source": "package.json", "command": "npm test", "variants": ["test:unit", "test:e2e"] },
-    "lint": { "source": "package.json", "command": "npm run lint", "variants": ["lint:fix"] },
-    "format": { "source": "package.json", "command": "npm run format", "variants": [] }
-  }
-}
-```
+Scan config files (`package.json` scripts, `Makefile` targets, `pyproject.toml` scripts, `Cargo.toml`, `build.gradle` tasks, `composer.json` scripts, `Rakefile` tasks) for commands in these categories:
+
+Build, Test, Lint, Format, Type Check, Dev Server, Database (migrate/seed), Docker, Deploy, Clean, Generate
+
+Skill naming: `run-{category}` (e.g., `run-build`, `run-tests`, `run-lint`).
 
-Only include patterns/commands that are actually detected.
+For each command found: record exact syntax, note variants (e.g., `test:unit`, `test:e2e`), and environment requirements. Only include commands that are actually detected.
 
 ### Step 2: Gather User Preferences (interactive via AskUserQuestion)
 
@@ -414,36 +279,76 @@ If no patterns/commands detected:
 - Inform user: "No common patterns detected. Would you like to specify patterns manually?"
 - Allow manual entry of pattern names/locations or command names
 
+### Step 2.5: Write config.json
+
+Using the values gathered from Steps 1 and 2, write `.claude/.5/config.json` directly.
+
+**If "Update existing" flow:** Read current config, merge updated values.
+**If "Start fresh" or new install:** Write new config.
+
+**Ensure directory exists:**
+```bash
+mkdir -p .claude/.5
+```
+
+**Schema:**
+
+```json
+{
+  "projectType": "{type}",
+  "ticket": {
+    "pattern": "{regex-pattern-or-null}",
+    "extractFromBranch": true
+  },
+  "branch": {
+    "convention": "{convention}"
+  },
+  "build": {
+    "command": "{build-command}",
+    "testCommand": "{test-command}",
+    "timeout": {
+      "compile": 120000,
+      "test": 300000
+    }
+  },
+  "tools": {
+    "coderabbit": {
+      "available": false,
+      "authenticated": false
+    },
+    "ide": {
+      "available": false,
+      "type": null
+    },
+    "context7": {
+      "available": false
+    }
+  },
+  "reviewTool": "claude",
+  "git": {
+    "autoCommit": false,
+    "commitMessage": {
+      "pattern": "{ticket-id} {short-description}"
+    }
+  }
+}
+```
+
+Fill all values from user responses. Write with pretty-printed JSON. Read back to verify correctness.
+
 ### Step 3: Create Feature Spec
 
-Write `.5/CONFIGURE/feature.md` containing all gathered data:
+Write `.5/features/CONFIGURE/feature.md` containing all gathered data:
 
 ```markdown
 # Feature: Project Configuration
 
 ## Summary
-Configure the 5-phase workflow for this {project-type} project. Creates config.json, generates CLAUDE.md with codebase analysis, and creates project-specific skills.
+Generates CLAUDE.md with codebase analysis and creates project-specific skills. (config.json already written.)
 
 ## Requirements
 
-### Requirement 1: Create config.json
-Create `.claude/.5/config.json` with the following values:
-- Project type: {project-type}
-- Ticket pattern: {pattern}
-- Extract from branch: {yes/no}
-- Branch convention: {convention}
-- Build command: {build-command}
-- Test command: {test-command}
-- Build timeout: 120000ms
-- Test timeout: 300000ms
-- CodeRabbit: {available/not-available}, authenticated: {yes/no}
-- IDE integration: {available/not-available}, type: {type}
-- Context7: {available/not-available}
-- Review tool: {claude/coderabbit/none}
-- Auto-commit: {yes/no}
-- Commit message pattern: {pattern or "default"}
-
-### Requirement 2: Generate Documentation Files
+### Requirement 1: Generate Documentation Files
 Analyze the codebase and generate modular documentation:
 
 **Create separate documentation files in `.5/` folder:**
@@ -470,62 +375,21 @@ Analyze the codebase and generate modular documentation:
 **Preserve existing content:**
 - If CLAUDE.md already exists, preserve user-written custom sections
 
-### Requirement 3: Generate Project-Specific Skills
-
-#### 3a. Create-* Skills (Architectural Patterns)
-
-Generate skills based on detected file patterns:
-
-| Pattern | Files | Location | Skill Name | Generate |
-|---------|-------|----------|------------|----------|
-| Controller | {count} | {location} | create-controller | ✓ |
-| Service | {count} | {location} | create-service | ✓ |
-| Component | {count} | {location} | create-component | ✓ |
-| {pattern} | {count} | {location} | create-{pattern} | ✗ (user skipped) |
-
-{Include only patterns where user selected "Generate = ✓"}
-
-For each selected pattern skill:
-1. Analyze 2-3 existing files from the pattern location
-2. Extract naming conventions, file structure, imports
-3. Generate SKILL.md with project-specific template
-
-Each create-* skill should:
-- Follow standard SKILL.md frontmatter pattern
-- Set `user-invocable: true` so users can invoke directly (e.g., `/create-controller UserController`)
-- Set `model: haiku` for fast, cheap pattern-following
-- Derive patterns from existing code in the project
-- Include file naming and location conventions
-- Include template/pattern based on existing examples
+### Requirement 2: Generate Project-Specific Skills
 
-#### 3b. Run-* Skills (Command Skills)
+**Create-* skills** for each user-selected architectural pattern:
+- Skill name: `create-{pattern}` (e.g., `create-controller`, `create-service`)
+- Analyze 2-3 existing files, extract conventions, generate SKILL.md with project-specific template
+- Set `user-invocable: true`, `model: haiku`
 
-Generate skills based on detected commands:
+**Run-* skills** for each user-selected command:
+- Skill name: `run-{category}` (e.g., `run-tests`, `run-lint`)
+- Document exact command syntax, variants, flags
+- Set `user-invocable: true`, `model: haiku`
 
-| Command | Source | Full Command | Skill Name | Generate |
-|---------|--------|--------------|------------|----------|
-| build | {source} | {command} | run-build | ✓ |
-| test | {source} | {command} | run-tests | ✓ |
-| lint | {source} | {command} | run-lint | ✓ |
-| {command} | {source} | {full-command} | run-{command} | ✗ (user skipped) |
-
-{Include only commands where user selected "Generate = ✓"}
-
-For each selected command skill:
-1. Document the exact command and any variants
-2. Include common flags and options
-3. Document expected output and error handling
-
-Each run-* skill should:
-- Follow standard SKILL.md frontmatter pattern
-- Set `user-invocable: true` so users can invoke directly (e.g., `/run-tests`, `/run-lint`)
-- Set `model: haiku` for simple command execution
-- Include the exact command syntax
-- Document any environment requirements
-- Include common options/flags
+Include only patterns/commands where user selected "Generate".
 
 ## Acceptance Criteria
-- [ ] `.claude/.5/config.json` exists with correct values (no `steps` array)
 - [ ] `.5/` directory created
 - [ ] All 7 documentation files exist and are populated:
   - [ ] `.5/ARCHITECTURE.md`
@@ -549,80 +413,12 @@ Each run-* skill should:
 
 Tell the user:
 
-1. "Configuration feature planned at `.5/features/CONFIGURE/feature.md`"
-2. "Next steps:"
+1. "Configuration saved to `.claude/.5/config.json`"
+2. "Configuration feature planned at `.5/features/CONFIGURE/feature.md`"
+3. "Next steps:"
    - "Run `/clear` to reset context"
    - "Then run `/5:plan-implementation CONFIGURE`"
-3. "After that: Continue with `/5:implement-feature CONFIGURE` -> `/5:verify-implementation` -> `/5:review-code` (clearing context between each phase)"
-
-## DO NOT
-
-- DO NOT write config.json directly (that's Phase 3's job via the configure-project skill)
-- DO NOT create CLAUDE.md directly (that's Phase 3's job)
-- DO NOT generate skills directly (that's Phase 3's job)
-- DO NOT skip user interaction - always confirm detected values
-- DO NOT assume project structure - always detect or ask
-
-## Example Usage
-
-```
-User: /5:configure
-
-[Step 1: Auto-detection runs silently]
-
-Claude: "Detected project type: Next.js. Is this correct?"
-User: "Yes"
-
-Claude: "How do you track work items?"
-User: "GitHub Issues"
-
-Claude: "Extract ticket ID from branch name?"
-User: "Yes"
-
-Claude: "Branch naming convention?"
-User: "feature/description"
-
-Claude: "Build command: `npm run build`. Use this?"
-User: "Yes"
-
-Claude: "Test command: `npm test`. Use this?"
-User: "Yes"
-
-Claude: "Should Claude make atomic commits during implementation?"
-User: "No"
-
-Claude: "Which code review tool would you like to use?"
-User: "Claude (built-in)"
-
-Claude: "Generate CLAUDE.md with codebase analysis?"
-User: "Yes"
-
-Claude: "I analyzed your codebase and found these patterns:
-| Pattern | Files | Location | Example |
-|---------|-------|----------|---------|
-| Component | 25 files | src/components/ | Button.tsx |
-| Hook | 8 files | src/hooks/ | useAuth.ts |
-| API Route | 12 files | pages/api/ | users.ts |
-| Page | 15 files | pages/ | index.tsx |
-
-Which patterns would you like `create-*` skills generated for?"
-User: [Selects Component, Hook, API Route]
-
-Claude: "I also found these runnable commands:
-| Command | Source | Full Command |
-|---------|--------|--------------|
-| build | package.json | npm run build |
-| test | package.json | npm test |
-| lint | package.json | npm run lint |
-| typecheck | package.json | npm run typecheck |
-
-Which commands would you like `run-*` skills generated for?"
-User: [Selects test, lint]
-
-Claude: [Writes .5/features/CONFIGURE/feature.md]
-Claude: "Configuration feature planned at `.5/features/CONFIGURE/feature.md`"
-Claude: "Next: Run `/clear` followed by `/5:plan-implementation CONFIGURE`"
-```
+4. "After that: Continue with `/5:implement-feature CONFIGURE` -> `/5:verify-implementation` -> `/5:review-code` (clearing context between each phase)"
 
 ## Related Documentation