cc-dev-template 0.1.50 → 0.1.52

package/bin/install.js

@@ -255,6 +255,32 @@ if (fs.existsSync(mergeSettingsPath)) {
 console.log('\nCleanup:');
 let cleanupPerformed = false;
 
+// Remove deprecated skills
+const deprecatedSkills = ['youtube-to-notes'];
+deprecatedSkills.forEach(skill => {
+  const skillPath = path.join(CLAUDE_DIR, 'skills', skill);
+  if (fs.existsSync(skillPath)) {
+    fs.rmSync(skillPath, { recursive: true });
+    console.log(`✓ Removed deprecated skill: ${skill}`);
+    cleanupPerformed = true;
+  }
+});
+
+// Remove deprecated MCP servers
+const deprecatedMcpServers = ['qa-server'];
+deprecatedMcpServers.forEach(server => {
+  const serverPath = path.join(CLAUDE_DIR, 'mcp-servers', server);
+  if (fs.existsSync(serverPath)) {
+    fs.rmSync(serverPath, { recursive: true });
+    // Unregister from Claude Code
+    try {
+      execSync(`claude mcp remove ${server} 2>/dev/null || true`, { stdio: 'pipe' });
+    } catch (e) {}
+    console.log(`✓ Removed deprecated MCP server: ${server}`);
+    cleanupPerformed = true;
+  }
+});
+
 // Remove deprecated bash wrapper files
 const deprecatedFiles = [
   path.join(CLAUDE_DIR, 'hooks', 'bash-precheck.sh'),
@@ -341,13 +367,11 @@ These settings are available globally across all your projects.
 Commands:
   /prime - Start a session (orientation, scaffolding for new projects)
   /done  - End a session (sync docs, commit work)
-
-MCP Server Notes:
-  - qa-server: Spawns a sub-agent for frontend visual inspection
-    Saves ~20k tokens by offloading browser tools to sub-agent
-    If you have chrome-devtools MCP installed, consider removing it:
-    claude mcp remove chrome-devtools
 `);
 }
 
+console.log(`Note: This installer contains no API keys, credentials, or private data.
+It's safe to share and anyone can run it.
+`);
+
 console.log('Restart Claude Code to pick up changes.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-dev-template",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "Structured AI-assisted development framework for Claude Code",
   "bin": {
     "cc-dev-template": "./bin/install.js"

package/src/skills/claude-md/SKILL.md

@@ -1,55 +1,20 @@
 ---
 name: claude-md
-description: This skill should be used when working with CLAUDE.md files. Activate when the user asks to "audit CLAUDE.md", "create a CLAUDE.md", "update the CLAUDE.md", "clean up CLAUDE.md files", or "check CLAUDE.md best practices". Also activate proactively whenever about to create or modify any CLAUDE.md file - the skill contains required principles for how these files should be written.
+description: Manages CLAUDE.md files in a project. Activates when the user says "audit CLAUDE.md files", "update CLAUDE.md", "add to CLAUDE.md", or invokes /claude-md. With no arguments, audits all CLAUDE.md files. With arguments, intelligently updates the appropriate file.
 ---
 
 # CLAUDE.md Management
 
 Base directory for this skill: ~/.claude/skills/claude-md
 
-## When This Activates
-
-- User asks to audit, create, update, or clean up CLAUDE.md files
-- You are about to create or modify any CLAUDE.md file
-
-**If you're about to touch a CLAUDE.md file, read this skill first.**
-
 ## What To Do
 
-Determine the task:
-
-| Task | Action |
-|------|--------|
-| **Creating** a new CLAUDE.md | Read `references/create.md` |
-| **Modifying** an existing CLAUDE.md | Read `references/principles.md`, then edit |
-| **Auditing** a project's CLAUDE.md files | Read `references/audit.md` |
-
-## Core Principle
-
-CLAUDE.md files are **orientation prompts**. They answer: "Where am I? What matters here? What should I know that I can't read from the code?"
-
-The test: **Would Claude know where it is and what matters?**
-
-## Quick Reference
-
-**Belongs in CLAUDE.md:**
-- Why this folder/repo exists
-- Current focus (what matters NOW)
-- Where to find things (progressive disclosure)
-- Tribal knowledge, gotchas, non-obvious learnings
-- Project conventions not obvious from code
-
-**Does NOT belong:**
-- Content duplicated from parent CLAUDE.md (hierarchy is automatic)
-- Step-by-step workflows (put in docs or skills)
-- Detailed examples (trust the model)
-- Operational runbooks
-- Anything over ~100 lines (suspect)
-
-## Hierarchy Rule
-
-Claude automatically reads CLAUDE.md files up through the directory tree. A child file inherits everything from its parents.
+Check if arguments were provided:
 
-**Never duplicate parent content in child files.** Each file should only contain what's specific to that folder.
+| Condition | Action |
+|-----------|--------|
+| No arguments | Read `references/audit.md` |
+| Arguments provided (add, update, modify request) | Read `references/modify.md` |
+| Explicitly asked to create a new CLAUDE.md | Read `references/create.md` |
 
-For full principles, read `references/principles.md`.
+For principles reference: `references/principles.md`

package/src/skills/claude-md/references/audit.md

@@ -1,93 +1,52 @@
-# Auditing CLAUDE.md Files
+# Audit CLAUDE.md Files
 
-## Process
+Perform a full audit of all CLAUDE.md files in this project. Fix issues automatically.
 
-1. **Discover** - Find all CLAUDE.md files in the project
-2. **Map hierarchy** - Understand parent-child relationships
-3. **Check each file** - Against principles
-4. **Fix issues** - Automatically apply best practices
+## Step 1: Discover and Map
 
-## Step 1: Discover
+Find all CLAUDE.md files: `Glob("**/CLAUDE.md")`
 
-Find all CLAUDE.md files:
+Read every file found. Build a mental map of the hierarchy — which files are parents, which are children. Content flows down: children inherit from parents.
 
-```bash
-find . -name "CLAUDE.md" -type f | head -20
-```
-
-Or use Glob:
-```
-**/CLAUDE.md
-```
-
-## Step 2: Map Hierarchy
-
-For each file, identify:
-- Its parent CLAUDE.md files (walking up the tree)
-- Its child CLAUDE.md files (in subdirectories)
-
-This matters because content flows down. Children inherit from parents.
+## Step 2: Check Each File
 
-## Step 3: Check Each File
+Evaluate each file against these criteria:
 
-Read each CLAUDE.md and check for these issues:
+**Length**
+- Over 100 lines → bloated, needs pruning
+- Over 150 lines → severely bloated
 
-### Length Issues
-| Check | Issue | Fix |
-|-------|-------|-----|
-| Over 100 lines | Probably bloated | Extract workflows to docs, remove duplication |
-| Over 150 lines | Definitely bloated | Aggressive pruning needed |
+**Content that doesn't belong**
+- Step-by-step workflows → move to docs/ or skills/
+- Detailed examples → remove, trust the model
+- Credentials/passwords → move to dedicated docs
+- Content duplicated from parent → remove entirely
 
-### Content Issues
-| Check | Issue | Fix |
-|-------|-------|-----|
-| Step-by-step workflows | Doesn't belong | Move to docs/ or skills/, leave pointer |
-| Detailed examples | Over-explaining | Remove, trust the model |
-| Credentials/passwords | Security + bloat | Move to dedicated docs |
-| Duplicate of parent | Redundant | Remove entirely |
+**Structure**
+- Missing purpose statement at top → add one-line description
+- Walls of text → break into sections, use bullets
 
-### Structure Issues
-| Check | Issue | Fix |
-|-------|-------|-----|
-| No clear purpose statement | Disorienting | Add one-line description at top |
-| Missing "Current Focus" | For active projects | Add if this is active work |
-| Walls of text | Hard to scan | Break into sections, use bullets |
+**Hierarchy violations**
+- Child repeats parent content → remove from child
+- Child has general project info → move to root CLAUDE.md
+- Deep file (3+ levels) with no unique content → consider removing
 
-### Hierarchy Issues
-| Check | Issue | Fix |
-|-------|-------|-----|
-| Child repeats parent content | Duplication | Remove from child |
-| Child has general project info | Wrong level | Move to root CLAUDE.md |
-| Deep file (3+ levels) exists | Probably unnecessary | Consider removing |
+## Step 3: Fix Issues
 
-## Step 4: Fix Issues
+For each issue:
+1. Read the file
+2. Apply the fix using Edit
+3. Move extracted content to appropriate location if needed
 
-For each issue found:
+**Extracting workflows:** Create `docs/workflows/[topic].md`, replace inline content with pointer.
 
-1. **Read the file** (required before editing)
-2. **Apply the fix** using Edit tool
-3. **Move extracted content** to appropriate location (docs/, etc.)
-4. **Verify** the result
+**Removing duplication:** Verify parent has content, delete from child.
 
-### Common Fixes
+**Pruning over-explanation:** Reduce to 1-2 lines that trust the model.
 
-**Extracting a workflow:**
-1. Create `docs/workflows/[topic].md` with the detailed content
-2. Replace in CLAUDE.md with: "See `docs/workflows/[topic].md` for [description]"
+## Step 4: Report
 
-**Removing duplication:**
-1. Check parent file has the content
-2. Delete the duplicated section from child
-3. Optionally add: "Inherits [topic] from parent CLAUDE.md"
-
-**Pruning over-explanation:**
-1. Identify the core point
-2. Reduce to 1-2 lines that trust the model
-3. Remove examples, edge cases, detailed instructions
-
-## Audit Report
-
-After checking all files, summarize:
+After all fixes, summarize:
 
 ```
 CLAUDE.md Audit Summary
@@ -98,18 +57,7 @@ Issues fixed: Z
 
 Changes made:
 - [file]: [what was fixed]
-- [file]: [what was fixed]
 
 Remaining concerns:
-- [any issues that need human decision]
+- [any issues needing human decision]
 ```
-
-## Red Flags
-
-These indicate a CLAUDE.md that needs significant rework:
-
-- **200+ lines** - Needs major pruning
-- **Code blocks with >10 lines** - Workflows belong in docs
-- **Tables with >5 rows** - Probably too detailed
-- **Multiple "how to" sections** - Wrong content type
-- **Same content in parent and child** - Hierarchy violation

package/src/skills/claude-md/references/create.md

@@ -6,11 +6,11 @@
 2. **Read them** - Understand what's already covered
 3. **Identify the gap** - What does this folder need that parents don't provide?
 
-If the parent files already cover everything, you probably don't need a new CLAUDE.md.
+Skip creating a new CLAUDE.md if parent files already cover everything needed.
 
 ## Structure Template
 
-Use this as a starting point, not a rigid template. Include only sections that add value.
+Starting template. Include only sections that add value.
 
 ```markdown
 # [Folder/Project Name]

package/src/skills/claude-md/references/modify.md

@@ -0,0 +1,52 @@
+# Modify CLAUDE.md
+
+The user provided a request to add, update, or modify something in the project's CLAUDE.md files. Determine the appropriate file and make the change.
+
+## Step 1: Understand the Request
+
+Parse what the user wants:
+- What content to add or change?
+- Is it project-wide or specific to a folder/component?
+- Is it a gotcha, convention, current focus, or structural info?
+
+## Step 2: Discover Existing Files
+
+Find all CLAUDE.md files: `Glob("**/CLAUDE.md")`
+
+Read each file to understand:
+- What scope each file covers
+- The hierarchy (root → subdirectories)
+- What content already exists
+
+## Step 3: Determine the Right File
+
+Match the request to the appropriate level:
+
+| Request Type | Appropriate File |
+|--------------|------------------|
+| Project-wide convention | Root CLAUDE.md |
+| Folder-specific rule | That folder's CLAUDE.md (create if needed) |
+| Component gotcha | Nearest parent CLAUDE.md covering that area |
+| Current focus/priority | Root CLAUDE.md (or active work area) |
+
+**Hierarchy principle:** Place content at the highest level where it applies. Child files only contain what's specific to that folder.
+
+If unsure which file is appropriate, ask the user.
+
+## Step 4: Make the Change
+
+Read the target file, then edit:
+
+- Add gotchas to a "Gotchas" section (create if missing)
+- Add conventions to relevant existing sections
+- Add current focus to "Current Focus" section
+- Keep additions concise — 1-2 lines, trust the model
+
+If the content would make the file exceed ~100 lines, consider:
+- Is this the right level? Maybe it belongs deeper.
+- Can existing content be pruned?
+- Should a workflow be extracted to docs/?
+
+## Step 5: Confirm
+
+Tell the user what was added and where. If creating a new CLAUDE.md file, explain why that location was chosen.

package/src/skills/initialize-project/SKILL.md

@@ -1,84 +1,33 @@
 ---
 name: initialize-project
-description: Scaffold docs structure for Claude Code sessions. Use when starting a new project or when docs/CURRENT_WORK.md is missing.
+description: Scaffold docs structure for Claude Code sessions. Use when starting a new project, when "docs/CURRENT_WORK.md is missing", or when user says "initialize this project" or "set up session tracking".
 ---
 
 # Initialize Project
 
-Set up the documentation structure for Claude Code session tracking.
+Ask the user:
+- "What is this project? (1-2 sentences)"
+- "Primary language/framework?" (optional)
 
-## Purpose
+## Create the Docs Structure
 
-Create the minimal scaffolding that enables the `/prime` and `/done` workflow. This gives Claude context about project status across sessions without heavy tooling.
+Create `docs/INDEX.md` using `templates/INDEX.md.template`. Replace `{{PROJECT_NAME}}` with the project name.
 
-## What To Do
+Create `docs/CURRENT_WORK.md` using `templates/CURRENT_WORK.md.template`.
 
-1. **Announce:** "Setting up project for Claude Code session tracking..."
+## Handle CLAUDE.md
 
-2. **Gather context** - ask the user:
-   - "What is this project? (1-2 sentences)"
-   - "Primary language/framework?" (optional, for CLAUDE.md context)
+Check if CLAUDE.md exists and has content.
 
-3. **Create the docs structure:**
+**If missing or empty:** Create using `templates/CLAUDE.md.template`. Replace placeholders with user's answers.
 
-   Create `docs/INDEX.md`:
-   ```markdown
-   # [Project Name] Documentation
+**If exists with content:** Leave unchanged.
 
-   ## Quick Links
-   - [Current Work](CURRENT_WORK.md) - Active tasks and project status
+## Confirm Completion
 
-   ## Documentation
-   Add links to documentation as the project grows.
-   ```
+Report what was created:
+- `docs/INDEX.md` - documentation hub
+- `docs/CURRENT_WORK.md` - status tracking
+- `CLAUDE.md` - created or unchanged
 
-   Create `docs/CURRENT_WORK.md`:
-   ```markdown
-   # Current Work
-
-   ## In Progress
-   - (none)
-
-   ## Up Next
-   - (add your first task)
-
-   ## Blocked / Waiting
-   - (none)
-
-   ## Open Questions
-   - (none)
-   ```
-
-4. **Handle CLAUDE.md:**
-
-   Check if CLAUDE.md exists and has content.
-
-   **If missing or empty**, create a minimal starter:
-   ```markdown
-   # [Project Name]
-
-   [User's project description from step 2]
-
-   ## Tech Stack
-   [Language/framework from step 2, if provided]
-
-   ## Structure
-   - `docs/` - Documentation and status tracking
-   - `docs/CURRENT_WORK.md` - What's in progress and up next
-   ```
-
-   **If CLAUDE.md exists with content**, leave it alone - the user has already configured it.
-
-5. **Confirm completion:**
-   "Project initialized with:
-   - `docs/INDEX.md` - documentation hub
-   - `docs/CURRENT_WORK.md` - status tracking
-   - `CLAUDE.md` - [created/unchanged]
-
-   Run `/prime` to start your session."
-
-## Success Criteria
-
-- `docs/` directory exists with INDEX.md and CURRENT_WORK.md
-- CLAUDE.md exists (created if missing, preserved if present)
-- User understands the `/prime` → work → `/done` workflow
+End with: "Run `/prime` to start a session."

package/src/skills/initialize-project/templates/CLAUDE.md.template

@@ -0,0 +1,10 @@
+# {{PROJECT_NAME}}
+
+{{PROJECT_DESCRIPTION}}
+
+## Tech Stack
+{{TECH_STACK}}
+
+## Structure
+- `docs/` - Documentation and status tracking
+- `docs/CURRENT_WORK.md` - What's in progress and up next

package/src/skills/initialize-project/templates/CURRENT_WORK.md.template

@@ -0,0 +1,13 @@
+# Current Work
+
+## In Progress
+- (none)
+
+## Up Next
+- (add your first task)
+
+## Blocked / Waiting
+- (none)
+
+## Open Questions
+- (none)

package/src/skills/initialize-project/templates/INDEX.md.template

@@ -0,0 +1,7 @@
+# {{PROJECT_NAME}} Documentation
+
+## Quick Links
+- [Current Work](CURRENT_WORK.md) - Active tasks and project status
+
+## Documentation
+Add links to documentation as the project grows.

package/src/skills/prompting/SKILL.md

@@ -1,123 +1,16 @@
 ---
 name: prompting
-description: Best practices for creating effective Claude prompts. Use when creating, reviewing, or modifying prompts for agents or commands.
+description: Invoked when user says "review my prompt", "help me write a prompt", "improve this prompt", or "create a prompt for...". Guides prompt creation and improvement using Claude 4.x best practices.
 ---
 
-# Prompting Skill
+# Prompting
 
-Actionable guidance for crafting effective prompts for Claude 4.x models. Apply these principles when creating or reviewing agent prompts, command specifications, or any structured Claude interactions.
+## Determine Intent
 
-## Core Principles
+| User Intent | Action |
+|-------------|--------|
+| Has an existing prompt to review or improve | Read `references/review.md` |
+| Needs to create a new prompt from scratch | Read `references/create.md` |
+| Unclear | Ask: "Do you have an existing prompt to improve, or are you creating one from scratch?" |
 
-Apply in order of importance:
-
-### 1. Explain WHY, Not Just WHAT (Most Important)
-
-Provide purpose and context rather than exhaustive implementation details. Trust Claude's intelligence.
-
-**Mental Model**: Treat Claude like a brilliant senior colleague, not a junior who needs hand-holding.
-
-**Provide**:
-- The goal or purpose of the task
-- Why this matters (business context, use case)
-- Constraints that exist (technical, business, regulatory)
-- What success looks like
-
-**Avoid providing**:
-- Every possible edge case
-- Step-by-step implementation unless genuinely needed
-- Obvious best practices for the domain
-
-### 2. Use Positive Framing
-
-Tell Claude what TO do, not what NOT to do. Negatives require extra processing and can prime unwanted behavior.
-
-| Negative Framing | Positive Framing |
-|------------------|------------------|
-| "Don't hallucinate facts" | "Only use information from the provided documents" |
-| "Don't be too formal" | "Write in a conversational, friendly tone" |
-| "Avoid long paragraphs" | "Keep paragraphs to 3-4 sentences" |
-| "Don't skip error handling" | "Include comprehensive error handling" |
-| "Don't make it complicated" | "Keep the solution simple and maintainable" |
-| "Avoid making assumptions" | "Base responses on the provided data" |
-
-### 3. Be Clear and Direct
-
-Claude 4.x models are more literal than previous versions. State exactly what you want without hedging.
-
-| Vague | Clear |
-|-------|-------|
-| "Can you maybe help me think about..." | "Redesign the authentication flow to support SSO" |
-| "It might be nice to have..." | "Add rate limiting to the login endpoint" |
-| "Create a dashboard" | "Create a fully-featured dashboard with charts, filters, export, and user preferences" |
-
-### 4. Provide Context
-
-Answer these questions:
-1. **Why does this matter?** (Purpose, goal, business context)
-2. **Who is this for?** (Audience, user type, skill level)
-3. **What does success look like?** (Outcomes, metrics, acceptance criteria)
-4. **What constraints exist?** (Technical limits, requirements, policies)
-
-## The Complete Framework Checklist
-
-Every good prompt should answer:
-
-- [ ] **WHAT** are you asking Claude to do?
-- [ ] **WHY** does this matter? (Purpose, goal)
-- [ ] **WHO** is this for? (Audience, user type)
-- [ ] **SUCCESS** looks like what?
-- [ ] Frame everything **POSITIVELY** (what TO do, not what NOT to do)
-
-Then trust Claude to:
-- Handle edge cases intelligently
-- Apply best practices for the domain
-- Make reasonable implementation choices
-- Ask clarifying questions if truly ambiguous
-
-## Quick Diagnostics
-
-When Claude's response is problematic:
-
-| Problem | Likely Cause | Fix |
-|---------|--------------|-----|
-| Too minimal/basic | Not explicit about expectations | Add "Create a fully-featured..." or "Go beyond basics..." |
-| Off-topic | Missing context about purpose | Explain WHY you need this and what it's for |
-| Inconsistent | Vague or ambiguous instructions | Be more direct and specific about requirements |
-| Overly cautious | Negative framing ("don't do X") | Reframe positively ("do Y instead") |
-| Missing key details | Didn't explain what success looks like | Define concrete success criteria |
-
-## Common Antipatterns
-
-### The Micromanager
-Providing step-by-step implementation instead of goals.
-
-**Fix**: Explain the goal, let Claude handle implementation.
-
-### The Negative Nancy
-String of "don't do X" instructions.
-
-**Fix**: Reframe every negative as a positive instruction.
-
-### The Context-Free Zone
-Bare instruction with no purpose or audience.
-
-**Fix**: Explain who will use it, why it exists, what success looks like.
-
-### The Vague Suggestion
-Hedged language like "maybe we could possibly..."
-
-**Fix**: Be direct and explicit about what you want.
-
-## Structural Elements
-
-For multi-step tasks where order matters, use numbered lists.
-
-For complex prompts with distinct sections, consider XML-style tags:
-- `<instructions>`, `<context>`, `<data>`
-- `<examples>`, `<input>`, `<output>`
-- `<requirements>`, `<constraints>`
-
-## ADR Compliance
-
-This skill implements the practices mandated by ADR-002 (Structured Prompting Practices for Agents and Commands). All agents and commands in this framework must follow these principles.
+Route to the appropriate path before proceeding.

package/src/skills/prompting/references/create.md

@@ -0,0 +1,59 @@
+# Create a New Prompt
+
+## Step 1: Gather Requirements
+
+Ask the user these questions (skip any already answered):
+
+1. **What should Claude do?** (The core task)
+2. **Why does this matter?** (Purpose, business context)
+3. **Who will use the output?** (Audience)
+4. **What does success look like?** (Concrete outcomes)
+5. **What constraints exist?** (Technical limits, policies, format requirements)
+
+## Step 2: Draft the Prompt
+
+Structure the prompt with these elements:
+
+### Opening: Task and Purpose
+State the task directly in imperative form. Include why it matters.
+
+```
+[Task in imperative form]. This [purpose/context].
+```
+
+### Context Section (if needed)
+For complex tasks, add structured context:
+
+```
+<context>
+- Audience: [who]
+- Constraints: [limits]
+- Success criteria: [outcomes]
+</context>
+```
+
+### Requirements (if specific)
+List concrete requirements as bullet points. Keep to essentials only.
+
+### Output Format (if specific)
+Specify format only when it genuinely matters. Otherwise trust Claude's judgment.
+
+## Step 3: Self-Review
+
+Before presenting, verify:
+
+- [ ] All instructions use positive framing (what TO do)
+- [ ] Language is direct, no hedging
+- [ ] Purpose and context are clear
+- [ ] No over-specification of obvious practices
+- [ ] Success criteria are concrete
+
+Read `references/principles.md` if any check fails and apply the relevant fix.
+
+## Step 4: Present and Iterate
+
+Present the draft prompt to the user.
+
+Ask: "Does this capture what you need? Any adjustments?"
+
+Incorporate feedback until the user is satisfied.