@codihaus/claude-skills 1.6.11 → 1.6.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codihaus/claude-skills",
-  "version": "1.6.11",
+  "version": "1.6.12",
   "description": "Claude Code skills for software development workflow",
   "main": "src/index.js",
   "bin": {

package/skills/dev-scout/SKILL.md

@@ -11,14 +11,26 @@ version: 3.0.0
 > - **After**: Use `/dev-specs` for implementation plans
 > - **Utils**: `/utils/diagram` for architecture visualization
 
-Discover and document **how the codebase works** - patterns, rules, and team conventions. Not a file inventory.
+Discover and document **how the codebase works** - patterns, rules, and team conventions for EXISTING code.
 
 ## When to Use
 
 - Understand **how the project works** before implementation
 - Document **team patterns and conventions** for new engineers
 - Discover **architectural patterns** that must be followed
-- Capture **the rules** that won't change soon
+- Capture **existing features** and how they're implemented
+
+## What Scout Does vs Doesn't
+
+**Scout documents EXISTING code:**
+- ✅ How the project currently works (patterns, conventions)
+- ✅ Complete list of existing features
+- ✅ How each feature is implemented (for understanding/extending)
+
+**Scout does NOT plan NEW features:**
+- ❌ NOT for creating implementation specs
+- ❌ NOT for planning new features
+- ❌ Use `/dev-specs` for new feature planning
 
 **Not for:** Listing files, counting components, inventorying routes (use Glob/Grep fresh instead)
 
@@ -78,37 +90,48 @@ Discover and document **how the codebase works** - patterns, rules, and team con
 
 ### Project-Level: `tech-context.md` (~150-200 lines)
 
-Answers the question: **How does this project work?**
+Answers: **How does this project work?**
 
-**Captures (stable patterns):**
-- How we make API calls (wrapper, pattern, error handling)
-- How we access data (ORM, queries, abstractions)
-- How we structure code (folders, naming, organization)
-- What our conventions are (naming, formatting, git workflow)
-- Tech stack choices (framework, libraries, tools)
+**For new developers, provide:**
+- **Patterns** - How we make API calls, access data, structure code (with file/location references)
+- **Conventions** - Team standards for naming, formatting, git workflow
+- **Stack** - Tech choices and why
+- **All existing features** - Complete list (important: don't miss any!)
 
-**Does NOT capture (volatile):**
-- File trees (use Glob fresh)
-- Component/route lists (discover when needed)
-- File counts (meaningless)
-- Exhaustive inventories (stale immediately)
+**Format:** Overview + location reference, NOT do/don't lists
+
+**Example:**
+```markdown
+### API Communication
+**Pattern:** All API calls go through `lib/api/client.ts` wrapper
+**Location:** See `lib/api/client.ts` for implementation
+**Usage:** Import `apiClient` and call methods
+```
+
+NOT:
+```markdown
+✅ DO: Use apiClient
+❌ DON'T: Use fetch directly
+```
 
 ### Feature-Level: `codebase-context.md`
 
-Answers the question: **How does THIS feature work?**
+Answers: **How does THIS already-implemented feature work?**
 
-**Prerequisite:** MUST have `tech-context.md` first (patterns already documented)
+**Purpose:** Document existing implementation for understanding/extending, NOT create specs
+
+**Prerequisite:** MUST have `tech-context.md` first
 
 **Captures:**
-- How this feature implements the patterns (not the patterns themselves)
-- Where the key files are (entry points, core logic)
-- How to extend this feature
-- Feature-specific gotchas
+- How this feature uses the patterns (reference tech-context.md)
+- Where key files are (locations, entry points)
+- How it currently works (flow, architecture)
+- How to extend it (what to modify where)
 
-**Does NOT repeat:**
-- Project-wide patterns (already in tech-context.md)
-- Tech stack info (already documented)
-- Code conventions (already documented)
+**Does NOT:**
+- Create implementation specs (this is for EXISTING code)
+- Repeat patterns (reference tech-context.md instead)
+- Include do/don't lists (show pattern usage with locations)
 
 ## Success Criteria
 
@@ -128,6 +151,7 @@ Answers the question: **How does THIS feature work?**
 - Detect tech stack from package.json, configs
 - Sample 2-3 files per category to discover patterns
 - Extract conventions from configs
+- **Discover ALL existing features** (don't miss any - scan routes, pages, API endpoints)
 
 **Deep Mode:**
 - All of Medium +
@@ -135,14 +159,22 @@ Answers the question: **How does THIS feature work?**
 - Code convention detection
 - Git & team process
 
+**Output:** `tech-context.md` with patterns + complete feature list
+
 ### Feature-Level
 
-**Lightweight approach - reads patterns, not rediscovering:**
+**Purpose:** Document existing implementation for understanding/extending
+
+**NOT FOR:** Creating specs or planning new features
+
+**Lightweight approach:**
 
 1. **Check prerequisite:** tech-context.md exists? If not, run project-level first
 2. **Read patterns:** Load tech-context.md (now you know API pattern, data access, conventions)
 3. **Focus on feature:** Find files (Glob/Grep), read 2-3 key files, identify entry points
-4. **Document:** How THIS feature uses the patterns, where code lives, how to extend
+4. **Document existing code:** How it works NOW, where files are, how to extend
+
+**Output:** `codebase-context.md` describing current implementation
 
 ## Pattern Discovery Rules
 

package/skills/dev-scout/references/output-template.md

@@ -39,23 +39,32 @@
 
 ## Architecture Patterns (How We Build)
 
+**Format:** Overview + location reference (NOT do/don't lists)
+
 ### 1. API Communication
-**How:** {pattern description}
-**Rule:** {what must be followed}
-**Example:** {code example showing pattern}
-**Why:** {reason}
+**Pattern:** {description of approach}
+**Location:** `{file/folder}` - {what's there}
+**Usage Example:** {short code snippet showing usage}
 
 ### 2. Data Access
-{same structure}
+**Pattern:** {description}
+**Location:** `{file/folder}`
+**Usage Example:** {snippet}
 
 ### 3. Client-Side Data Fetching
-{same structure}
+**Pattern:** {description}
+**Location:** `{file/folder}`
+**Usage Example:** {snippet}
 
 ### 4. Validation & Forms
-{same structure}
+**Pattern:** {description}
+**Location:** `{file/folder}`
+**Usage Example:** {snippet}
 
 ### 5. State Management
-{same structure}
+**Pattern:** {description}
+**Location:** `{file/folder}`
+**Usage Example:** {snippet}
 
 ## Code Conventions (Team Standards)
 
@@ -94,6 +103,16 @@
 ### Available MCPs
 {what they provide}
 
+## Existing Features (Complete List)
+
+**IMPORTANT:** List ALL features found in codebase, don't sample.
+
+| Feature | Status | Location | Key Files |
+|---------|--------|----------|-----------|
+| {feature} | Complete | `{folder}` | `{main files}` |
+
+**Discovery method:** Scan routes, pages, components, API endpoints
+
 ## Project Structure (High-Level)
 
 {core directories only, not exhaustive}
@@ -131,7 +150,8 @@
 ## 2. Feature-Level: codebase-context.md
 
 **Location:** `plans/features/{feature}/codebase-context.md`
-**Purpose:** How THIS feature works (implementation details, not patterns)
+**Purpose:** Document how THIS already-implemented feature works (for understanding/extending)
+**NOT FOR:** Creating specs or planning new features (use /dev-specs for that)
 **Prerequisite:** MUST read tech-context.md first (patterns already documented)
 **Length:** ~100-150 lines
 
@@ -186,35 +206,27 @@
 
 ## Integration Points
 
-**Where to add new code:**
-{location + pattern}
-
-**What to extend:**
-{existing abstraction}
-
 **Dependencies:**
 {what must exist}
 
 **Used By:**
 {what depends on this}
 
-## Patterns to Follow
-
-**✅ DO:**
-{feature-specific guidance}
-
-**❌ DON'T:**
-{feature-specific anti-pattern}
+## How to Extend
 
-## Gotchas
+**To add new functionality:**
+1. Location: `{file/folder}`
+2. Pattern reference: See tech-context.md → {section}
+3. Example: {how similar functionality was added}
 
-{feature-specific issues}
+**To modify behavior:**
+1. Location: `{file}`
+2. Pattern reference: See tech-context.md → {section}
+3. Note: {what to watch out for}
 
-## For Implementation
+## Gotchas & Notes
 
-**Start here:** `{file}` - {why}
-**Follow pattern:** See tech-context.md → {section}
-**Watch out:** {warning}
+{feature-specific issues, edge cases, known limitations}
 ```
 
 ---