claude-code-starter 0.13.0 → 0.14.1

package/README.md

@@ -48,9 +48,9 @@ Automatically detects and configures for:
 | -------------- | ------------------------------------------------------------------- |
 | **Languages**  | TypeScript, JavaScript, Python, Go, Rust, Java, Ruby, Swift, Kotlin |
 | **Frameworks** | Next.js, React, Vue, Svelte, FastAPI, Django, NestJS, Express, etc. |
-| **Tools**      | npm, yarn, pnpm, bun, pip, cargo, go modules                       |
+| **Tools**      | npm, yarn, pnpm, bun, pip, cargo, go modules                        |
 | **Testing**    | Jest, Vitest, Pytest, Go test, Rust test                            |
-| **Linting**    | ESLint, Biome, Ruff, Pylint                                        |
+| **Linting**    | ESLint, Biome, Ruff, Pylint                                         |
 
 ## Generated Configurations
 
@@ -64,13 +64,13 @@ Based on your stack, creates:
 
 ## Commands
 
-| Command           | Description                              |
-| ----------------- | ---------------------------------------- |
-| `/task <desc>`    | Start a new task                         |
-| `/status`         | Show current task                        |
-| `/done`           | Mark task complete                       |
-| `/analyze <area>` | Deep dive into code                      |
-| `/code-review`    | Review changes for quality and security  |
+| Command           | Description                             |
+| ----------------- | --------------------------------------- |
+| `/task <desc>`    | Start a new task                        |
+| `/status`         | Show current task                       |
+| `/done`           | Mark task complete                      |
+| `/analyze <area>` | Deep dive into code                     |
+| `/code-review`    | Review changes for quality and security |
 
 ## CLI Options
 
@@ -179,41 +179,41 @@ flowchart LR
 
 ### Artifact Generation
 
-| Artifact Type | Generation Method |
-|---------------|-------------------|
-| **CLAUDE.md** | Claude CLI deep analysis of your actual source files |
-| **settings.json** | Generated with safe default permissions |
-| **Skills** | Core skills + framework-specific patterns (if detected) |
-| **Agents** | Code reviewer and test writer agents |
-| **Rules** | Language-specific conventions + general code style |
-| **Commands** | Task workflow commands (/task, /status, /done, /analyze) |
+| Artifact Type     | Generation Method                                        |
+| ----------------- | -------------------------------------------------------- |
+| **CLAUDE.md**     | Claude CLI deep analysis of your actual source files     |
+| **settings.json** | Generated with safe default permissions                  |
+| **Skills**        | Core skills + framework-specific patterns (if detected)  |
+| **Agents**        | Code reviewer and test writer agents                     |
+| **Rules**         | Language-specific conventions + general code style       |
+| **Commands**      | Task workflow commands (/task, /status, /done, /analyze) |
 
 ### Conflict Resolution
 
 When running on an existing project with `.claude/` configuration:
 
-| Scenario | Behavior |
-|----------|----------|
-| **New file** | Created |
-| **Existing file** | Skipped (preserved) |
-| **With `-f` flag** | Overwritten |
-| **state/task.md** | Always preserved |
+| Scenario           | Behavior            |
+| ------------------ | ------------------- |
+| **New file**       | Created             |
+| **Existing file**  | Skipped (preserved) |
+| **With `-f` flag** | Overwritten         |
+| **state/task.md**  | Always preserved    |
 
 ### Framework-Specific Patterns
 
 When a framework is detected, additional skills are generated:
 
-| Framework | Generated Skill |
-|-----------|-----------------|
-| Next.js | `nextjs-patterns.md` - App Router, Server Components |
-| React | `react-components.md` - Hooks, component patterns |
-| FastAPI | `fastapi-patterns.md` - Async endpoints, Pydantic |
-| NestJS | `nestjs-patterns.md` - Modules, decorators, DI |
-| SwiftUI | `swiftui-patterns.md` - Declarative UI patterns |
-| UIKit | `uikit-patterns.md` - View controller patterns |
-| Vapor | `vapor-patterns.md` - Server-side Swift |
-| Jetpack Compose | `compose-patterns.md` - Compose UI patterns |
-| Android Views | `android-views-patterns.md` - XML views |
+| Framework       | Generated Skill                                      |
+| --------------- | ---------------------------------------------------- |
+| Next.js         | `nextjs-patterns.md` - App Router, Server Components |
+| React           | `react-components.md` - Hooks, component patterns    |
+| FastAPI         | `fastapi-patterns.md` - Async endpoints, Pydantic    |
+| NestJS          | `nestjs-patterns.md` - Modules, decorators, DI       |
+| SwiftUI         | `swiftui-patterns.md` - Declarative UI patterns      |
+| UIKit           | `uikit-patterns.md` - View controller patterns       |
+| Vapor           | `vapor-patterns.md` - Server-side Swift              |
+| Jetpack Compose | `compose-patterns.md` - Compose UI patterns          |
+| Android Views   | `android-views-patterns.md` - XML views              |
 
 ## Requirements
 
@@ -228,14 +228,14 @@ This project uses GitHub Actions for continuous integration and automated releas
 
 Every pull request targeting `main` runs:
 
-| Check | Description |
-|-------|-------------|
-| **Lint** | Biome lint and format validation |
-| **Type Check** | TypeScript compilation check |
-| **Unit Tests** | Full test suite with Bun |
+| Check            | Description                                        |
+| ---------------- | -------------------------------------------------- |
+| **Lint**         | Biome lint and format validation                   |
+| **Type Check**   | TypeScript compilation check                       |
+| **Unit Tests**   | Full test suite with Bun                           |
 | **Code Quality** | Checks for console.log, `any` types, skipped tests |
-| **Build** | Verifies package builds successfully |
-| **Package Size** | Reports bundle size (warns if > 500KB) |
+| **Build**        | Verifies package builds successfully               |
+| **Package Size** | Reports bundle size (warns if > 500KB)             |
 
 ### Automated Releases (`.github/workflows/release.yml`)
 
@@ -252,24 +252,25 @@ When code is merged to `main`, semantic-release automatically:
 
 Use these prefixes for automatic versioning:
 
-| Prefix | Version Bump | Example |
-|--------|--------------|---------|
-| `feat:` | Minor | `feat: add dark mode support` |
-| `fix:` | Patch | `fix: resolve memory leak` |
-| `perf:` | Patch | `perf: optimize image loading` |
-| `BREAKING CHANGE:` | Major | `feat!: redesign API` |
-| `docs:`, `chore:`, `ci:` | No release | `docs: update README` |
+| Prefix                   | Version Bump | Example                        |
+| ------------------------ | ------------ | ------------------------------ |
+| `feat:`                  | Minor        | `feat: add dark mode support`  |
+| `fix:`                   | Patch        | `fix: resolve memory leak`     |
+| `perf:`                  | Patch        | `perf: optimize image loading` |
+| `BREAKING CHANGE:`       | Major        | `feat!: redesign API`          |
+| `docs:`, `chore:`, `ci:` | No release   | `docs: update README`          |
 
 ### Required Secrets
 
 Configure these in your GitHub repository settings:
 
-| Secret | Description | Required For |
-|--------|-------------|--------------|
-| `NPM_TOKEN` | npm authentication token | Publishing to npm |
-| `GITHUB_TOKEN` | Auto-provided by GitHub | Creating releases |
+| Secret         | Description              | Required For      |
+| -------------- | ------------------------ | ----------------- |
+| `NPM_TOKEN`    | npm authentication token | Publishing to npm |
+| `GITHUB_TOKEN` | Auto-provided by GitHub  | Creating releases |
 
 To create an npm token:
+
 1. Go to [npmjs.com](https://npmjs.com) -> Access Tokens
 2. Generate a new "Automation" token
 3. Add it as `NPM_TOKEN` in GitHub repo -> Settings -> Secrets
@@ -298,4 +299,4 @@ bun run typecheck
 
 ## License
 
-MIT
+MIT License. See [LICENSE](LICENSE) for details.

package/dist/cli.js

@@ -511,38 +511,12 @@ function countSourceFiles(rootDir, _languages) {
   countFiles(rootDir);
   return count;
 }
-function summarizeTechStack(stack) {
-  const parts = [];
-  if (stack.primaryLanguage) {
-    parts.push(`Language: ${stack.primaryLanguage}`);
-  }
-  if (stack.primaryFramework) {
-    parts.push(`Framework: ${stack.primaryFramework}`);
-  }
-  if (stack.packageManager) {
-    parts.push(`Package Manager: ${stack.packageManager}`);
-  }
-  if (stack.testingFramework) {
-    parts.push(`Testing: ${stack.testingFramework}`);
-  }
-  if (stack.isMonorepo) {
-    parts.push("Monorepo: yes");
-  }
-  return parts.join(" | ");
-}
 
 // src/generator.ts
 import fs2 from "fs";
 import path2 from "path";
 function ensureDirectories(rootDir) {
-  const dirs = [
-    ".claude",
-    ".claude/skills",
-    ".claude/agents",
-    ".claude/rules",
-    ".claude/commands",
-    ".claude/state"
-  ];
+  const dirs = [".claude", ".claude/skills", ".claude/agents", ".claude/rules", ".claude/commands"];
   for (const dir of dirs) {
     fs2.mkdirSync(path2.join(rootDir, dir), { recursive: true });
   }
@@ -658,14 +632,15 @@ ${templateVars}
 
 1. Read this entire prompt to understand all phases
 2. Execute Phase 1 completely - read files, analyze code, gather all data
-3. Execute Phase 2 - generate the CLAUDE.md using only discovered information
+3. Execute Phase 2 - generate the CLAUDE.md (max 120 lines) using only discovered information
 4. Execute Phase 3 - verify quality before writing
 5. Use the Write tool to create \`.claude/CLAUDE.md\` with the final content
-6. Execute Phase 4 - generate ALL skill files
+6. Execute Phase 4 - generate ALL skill files (4 core + framework-specific if detected)
 7. Execute Phase 5 - generate agent files
 8. Execute Phase 6 - generate rule files
-9. Execute Phase 7 - generate command files
-10. Output a brief summary of what was generated and any gaps found
+9. Execute Phase 7 - generate command files (2 commands: analyze, code-review)
+10. Run the Anti-Redundancy Enforcement checks one final time across ALL generated files \u2014 if any convention is restated, any command is duplicated, or any rule lacks a \`paths:\` filter, fix it before proceeding
+11. Output a brief summary of what was generated and any gaps found
 
 Do NOT output file contents to stdout. Write all files to disk using the Write tool.
 Generate ALL files in a single pass \u2014 do not stop after CLAUDE.md.`;
@@ -807,6 +782,51 @@ something, omit that section entirely - do not fill in generic boilerplate.
 
 ---
 
+## Artifact Architecture
+
+Understanding the context cost of each artifact type is critical. Artifacts load at different
+frequencies, so place information where it costs the least while remaining accessible:
+
+| Artifact | When Loaded | Context Cost |
+|----------|-------------|--------------|
+| CLAUDE.md | Every turn | Highest \u2014 keep concise |
+| Rule without \`paths:\` | Every session | High \u2014 avoid generating these |
+| Rule with \`paths:\` | When matching files are open | Medium \u2014 use sparingly |
+| Skill / Command | On-demand (user invokes) | Low |
+| Agent | Spawned in subprocess | Zero main-context cost |
+
+### Placement Rules
+
+1. **CLAUDE.md is the single source of truth for conventions.** All naming, style, commit format, and project rules live here and ONLY here.
+2. **NEVER generate rules without \`paths:\` filters.** A rule without \`paths:\` loads every session and competes with CLAUDE.md for context. All general style information belongs in CLAUDE.md.
+3. **Rules must be concise, non-redundant supplements.** A language rule (e.g., \`typescript.md\` with \`paths: ["**/*.ts"]\`) should ONLY contain language-specific gotchas (compiler flags, import quirks, tooling-specific settings) that don't belong in CLAUDE.md.
+4. **Skills are for rich on-demand methodology.** Write "Follow conventions in CLAUDE.md" instead of restating conventions. Focus skills on HOW (methodology), not WHAT (conventions).
+5. **Agents have zero main-context cost.** Put detailed checklists and review criteria in agent files \u2014 they run in subprocesses and don't consume the user's context window.
+6. **Each piece of information must live in exactly ONE place.** If it's in CLAUDE.md, don't repeat it in rules, skills, or commands.
+
+### Anti-Redundancy Enforcement
+
+Before writing EACH artifact, apply these hard constraints:
+
+- **REJECT** any artifact that restates a convention from CLAUDE.md. If a convention appears in CLAUDE.md, it MUST NOT appear in any other file. Not paraphrased, not summarized, not restated in different words.
+- **Test commands, lint commands, and build commands** MUST appear in exactly ONE place: CLAUDE.md's Common Commands section. Skills and agents MUST write "See Common Commands in CLAUDE.md" instead.
+- **All rules MUST have a \`paths:\` filter** \u2014 no unfiltered rules.
+- **Cross-references replace copies** \u2014 write "Follow conventions in CLAUDE.md" instead of restating any convention.
+
+#### Forbidden Duplication List
+
+The following MUST NOT appear in skills, agents, rules, or commands \u2014 they belong exclusively in CLAUDE.md:
+- Test commands (the literal test runner invocation)
+- Lint commands (the literal linter invocation)
+- Build commands (the literal build invocation)
+- Import convention descriptions (absolute vs relative, ordering, type imports)
+- Naming convention descriptions (camelCase, PascalCase, file naming)
+- Commit format descriptions (conventional commits, message format)
+- Anti-patterns list (things to avoid)
+- Testing framework syntax examples (describe/it/expect \u2014 belongs in test-writer agent only)
+
+---
+
 ## Phase 1: Discovery (Read Before You Write)
 
 Perform these analysis steps IN ORDER. Do not skip any step. Do not start writing
@@ -902,9 +922,13 @@ Read at least 3-5 source files and document the ACTUAL patterns used:
 Using ONLY information discovered in Phase 1, generate the \`.claude/CLAUDE.md\` file.
 Every section must contain PROJECT-SPECIFIC content. Skip sections that don't apply.
 
+**The CLAUDE.md MUST NOT exceed 120 lines. Prioritize density over completeness.**
+
+Do NOT include sections that duplicate information available in package.json, tsconfig.json, or other config files the agent can read directly.
+
 ### Output Structure
 
-The CLAUDE.md MUST follow this structure:
+The CLAUDE.md MUST follow this compact structure:
 
 \`\`\`markdown
 # {Project Name}
@@ -918,17 +942,9 @@ Written for an AI assistant that needs to understand PURPOSE to make good decisi
 
 ## Architecture
 
-{Describe the actual architecture pattern found}
-
-### Directory Structure
-
-\\\`\\\`\\\`
-{Actual directory tree, depth 3, with annotations}
-\\\`\\\`\\\`
-
-### Data Flow
-
-{How a typical request flows through the system}
+{1-2 sentences describing the actual architecture pattern found, then the Key Files table.
+Do NOT include a Directory Structure ASCII tree or Data Flow subsection \u2014 the agent can
+read the filesystem directly.}
 
 ### Key Files
 
@@ -936,42 +952,18 @@ Written for an AI assistant that needs to understand PURPOSE to make good decisi
 |------|---------|
 | \`path/to/file\` | What it does |
 
-## Tech Stack
-
-| Category | Technology | Notes |
-|----------|-----------|-------|
-| Language | X | Config details |
-| Framework | Y | How it's used |
-
-## Development Setup
-
-### Prerequisites
-
-{Exact versions and tools needed}
-
-### Getting Started
-
-\\\`\\\`\\\`bash
-{Actual commands to get running}
-\\\`\\\`\\\`
-
-### Environment Variables
-
-| Variable | Description | Example |
-|----------|-------------|---------|
-| \`VAR_NAME\` | What it's for | \`example_value\` |
-
 ## Common Commands
 
 \\\`\\\`\\\`bash
-{Actual commands from package.json scripts or equivalent}
+{5 critical commands max, from package.json scripts or equivalent.
+Only the commands developers use daily \u2014 not every script.}
 \\\`\\\`\\\`
 
 ## Code Conventions
 
 ### Naming
 
-{ACTUAL naming patterns found}
+{ACTUAL naming patterns found \u2014 be brief}
 
 ### Patterns to Follow
 
@@ -981,27 +973,19 @@ Written for an AI assistant that needs to understand PURPOSE to make good decisi
 
 {What NOT to do based on codebase conventions}
 
-## Testing
-
-### Running Tests
+> **This Code Conventions section is the single source of truth.**
+> Rules and skills cross-reference this section \u2014 they do not repeat it.
 
-\\\`\\\`\\\`bash
-{actual test commands}
-\\\`\\\`\\\`
-
-### Writing Tests
+## Testing
 
-{Testing patterns, utilities, fixtures available}
+{2-3 lines: test command, test file location, key testing pattern.
+NOT a full guide \u2014 the test-writer agent handles detailed test methodology.}
 
 ## Domain Knowledge
 
 ### Core Entities
 
-{Main domain objects and relationships}
-
-### Key Workflows
-
-{3-5 most important workflows}
+{Brief list of main domain objects and relationships}
 
 ## Gotchas & Important Notes
 
@@ -1015,19 +999,41 @@ Written for an AI assistant that needs to understand PURPOSE to make good decisi
 4. {project-specific rules discovered during analysis}
 \`\`\`
 
+**Sections NOT to include** (the agent can read these from config files directly):
+- Directory Structure ASCII tree (agent uses Glob/Read)
+- Tech Stack table (available in package.json, tsconfig.json, etc.)
+- Development Setup / Getting Started / Prerequisites
+- Environment Variables table (available in .env.example)
+- Skills index table
+- Agents index table
+- Key Workflows (duplicates Data Flow / Architecture)
+
 ---
 
 ## Phase 3: Quality Checklist
 
 Before writing the CLAUDE.md, verify:
 
+- [ ] The file does NOT exceed 120 lines
 - [ ] Every section contains PROJECT-SPECIFIC information (not generic boilerplate)
 - [ ] File paths referenced actually exist in the project
+- [ ] File references use \`path/to/file.ts (functionName)\` format, not line numbers
 - [ ] Commands listed are verified from package.json scripts or equivalent
 - [ ] Code conventions were observed from ACTUAL source files
 - [ ] The "Gotchas" section contains genuinely useful, non-obvious information
 - [ ] An AI reading this CLAUDE.md could add a new feature following existing patterns
 - [ ] Sections without real content have been omitted entirely
+- [ ] No section duplicates information available in config files the agent can read
+
+### Cross-Artifact Deduplication Check
+
+Before writing ANY artifact (rule, skill, agent, command), verify:
+- [ ] No conventions from CLAUDE.md are restated (naming, commit format, import order, style)
+- [ ] No item from the Forbidden Duplication List appears outside CLAUDE.md
+- [ ] No content from one artifact is duplicated in another
+- [ ] Cross-references are used instead of copies (e.g., "Follow conventions in CLAUDE.md")
+- [ ] Every rule file has a \`paths:\` filter \u2014 no unfiltered rules
+- [ ] Single-language rules are justified (add genuine value beyond CLAUDE.md)
 
 ---
 
@@ -1035,7 +1041,7 @@ Before writing the CLAUDE.md, verify:
 
 1. **Be specific, not generic.** "Uses React with hooks" is useless. "Uses React 18 with Server Components via Next.js App Router, client components in src/components/client/ with 'use client' directive" is useful.
 
-2. **Reference real files.** Every pattern should reference an actual file as an example. Use \`path/to/file.ts:lineNumber\` format.
+2. **Reference real files.** Every pattern should reference an actual file as an example. Use \`path/to/file.ts (functionName)\` format \u2014 NOT line numbers, which become stale as code changes.
 
 3. **Prioritize actionable information.** Focus on what helps an AI write correct code: where to put new code, what patterns to follow, what to avoid, how to test.
 
@@ -1051,51 +1057,38 @@ var SKILLS_PROMPT = `---
 Write each skill file to \`.claude/skills/\` using the Write tool. Every skill must have
 YAML frontmatter with \`name\`, \`description\`, and optionally \`globs\` for file matching.
 
-**Tailor ALL skills to this specific project** \u2014 use the actual test command, lint command,
-file patterns, and conventions discovered during Phase 1.
+**Tailor ALL skills to this specific project** \u2014 use the actual file patterns and
+conventions discovered during Phase 1.
 
-### 4.1 Core Skills (ALWAYS generate all 8)
+### Skill Content Rules
 
-**\`.claude/skills/pattern-discovery.md\`**
-- Name: pattern-discovery
-- Description: Analyze codebase to discover and document patterns
-- Content: How to search for patterns in THIS project's structure. Include the actual source directories, key file patterns, and import conventions found.
+1. **Cross-reference, don't copy** \u2014 write "Follow conventions in CLAUDE.md" instead of restating naming, style, or commit conventions. Skills focus on methodology (HOW to do something), not conventions (WHAT the conventions are).
+2. **Use stable references** \u2014 reference code as \`path/to/file.ts (functionName)\`, not line numbers which become stale.
+3. **No convention duplication** \u2014 if CLAUDE.md already documents commit format, import order, or naming rules, the skill must not repeat them.
+4. **No command duplication** \u2014 for test, lint, and build commands, write "See Common Commands in CLAUDE.md" instead of repeating the literal command.
 
-**\`.claude/skills/systematic-debugging.md\`**
-- Name: systematic-debugging
-- Description: 4-phase debugging methodology \u2014 Reproduce, Locate, Diagnose, Fix
-- Content: Tailor reproduction steps to the project's actual test runner and dev server commands. Include how to use the project's logging/debugging setup.
-
-**\`.claude/skills/testing-methodology.md\`**
-- Name: testing-methodology
-- Description: AAA testing pattern with project-specific framework syntax
-- Content: Use the project's actual testing framework syntax. Include real examples of test patterns found in the codebase (describe/it blocks, pytest fixtures, etc.). Reference the actual test command. Include mocking/stubbing patterns specific to the stack.
+### 4.1 Core Skills (ALWAYS generate all 4)
 
 **\`.claude/skills/iterative-development.md\`**
 - Name: iterative-development
-- Description: TDD workflow with project-specific test and lint commands
-- Content: The TDD loop using the actual test command and lint command. Include the project's verification steps (typecheck, build, etc.).
-
-**\`.claude/skills/commit-hygiene.md\`**
-- Name: commit-hygiene
-- Description: Atomic commits, conventional format, size thresholds
-- Content: Size thresholds (\xB1300 lines per commit), when-to-commit triggers, conventional commit format. If the project uses commitlint or similar, reference its config.
+- Description: TDD workflow with debugging methodology and verification chain
+- Content: The TDD loop referencing "See Common Commands in CLAUDE.md" for actual commands. Include the project's verification steps (typecheck, build, etc.). Add a Debugging section with: 4-phase methodology (Reproduce, Locate, Diagnose, Fix), project-specific file-to-module mapping for tracing bugs, how to use the project's logging/debugging setup. Add commit guidance: size thresholds (\xB1300 lines per commit), when-to-commit triggers, "Follow commit conventions in CLAUDE.md" for format.
 
 **\`.claude/skills/code-deduplication.md\`**
 - Name: code-deduplication
-- Description: Check-before-write principle and search checklist
-- Content: Search existing code before writing new code. Include project-specific glob patterns for source files. Reference the actual directory structure for where to look.
-
-**\`.claude/skills/simplicity-rules.md\`**
-- Name: simplicity-rules
-- Description: Function and file size limits, decomposition patterns
-- Content: Function length limits (40 lines), file limits (300 lines), cyclomatic complexity. Decomposition patterns appropriate for the project's architecture style.
+- Description: Check-before-write principle, search checklist, and size limits
+- Content: Search existing code before writing new code. Include project-specific glob patterns for source files. Reference the actual directory structure for where to look. Include a "Where to Look" checklist for discovering patterns in THIS project's structure (source directories, key file patterns). Add size limits: function length (40 lines), file length (300 lines), decomposition patterns appropriate for the project's architecture style.
 
 **\`.claude/skills/security.md\`**
 - Name: security
 - Description: Security patterns and secrets management for this stack
 - Content: .gitignore entries appropriate for the detected stack. Environment variable handling patterns. OWASP checklist items relevant to the detected framework. Include actual secrets patterns to watch for (API keys, database URLs, etc.).
 
+**\`.claude/skills/testing-methodology.md\`**
+- Name: testing-methodology
+- Description: Test design methodology \u2014 what to test, edge cases, test organization
+- Content: Focus on test DESIGN: what to test, how to identify edge cases, test organization strategy, when to use unit vs integration tests. Include project-specific test file naming and location conventions. Reference "See Common Commands in CLAUDE.md" for the test command. Do NOT include testing framework syntax examples (describe/it/expect, pytest fixtures, etc.) \u2014 those belong in the test-writer agent, not here. The \`testing-methodology\` skill focuses on test DESIGN (what to test, edge cases, test organization). The \`test-writer\` agent focuses on test EXECUTION (writing code, running tests). They must not overlap.
+
 ### 4.2 Framework-Specific Skills (ONLY if detected)
 
 Generate the matching skill ONLY if the framework was detected in the tech stack:
@@ -1183,26 +1176,29 @@ Body content \u2014 instructions for the test writer agent:
 - Follow existing test file naming conventions
 - Include edge cases: empty inputs, nulls, errors, boundaries
 - Mock external dependencies following project patterns
-- Run tests after writing to verify they pass`;
+- Run tests after writing to verify they pass
+- Do NOT duplicate the testing-methodology skill content. The skill covers test design (what to test, edge cases, organization); this agent covers writing and running tests (framework syntax, assertions, execution).`;
 var RULES_PROMPT = `---
 
 ## Phase 6: Generate Rules
 
 Write rule files to \`.claude/rules/\`. Each rule file needs YAML frontmatter.
 
-### Always Generate:
+### Important: No Unfiltered Rules
 
-**\`.claude/rules/code-style.md\`** (no \`paths\` \u2014 applies to all files)
+Do NOT generate a \`code-style.md\` rule or any rule without a \`paths:\` filter. General style information (formatter, linter commands, comment style, error handling, commit conventions, import ordering) belongs in CLAUDE.md \u2014 not in a rule that loads every session and duplicates it.
 
-Content based on what was discovered in Phase 1:
-- Which formatter/linter to use and how (include actual commands)
-- Comment style: "why" not "what", keep comments current
-- Error handling patterns specific to this project
-- Git commit message conventions (conventional commits if commitlint is configured)
-- Import ordering conventions found in the codebase
+NEVER generate rules without \`paths:\` filters. Every rule must target specific file types.
 
 ### Conditional Rules (generate ONLY if the language was detected):
 
+**Constraints for all conditional rules:**
+- Every rule MUST have a \`paths:\` filter targeting language-specific file extensions
+- Keep rules concise: 5-15 lines of content maximum
+- Rules must NOT repeat conventions already in CLAUDE.md (naming, style, commit format, import order)
+- For single-language projects: only generate a language rule if it adds genuine value beyond CLAUDE.md (compiler flags, import quirks, tooling-specific gotchas)
+- Focus on: compiler/interpreter settings, language-specific gotchas, tooling-specific configuration \u2014 not general naming or style
+
 **TypeScript detected** \u2192 Write \`.claude/rules/typescript.md\`
 \`\`\`yaml
 ---
@@ -1246,39 +1242,11 @@ var COMMANDS_PROMPT = `---
 
 ## Phase 7: Generate Commands
 
-Write 5 command files to \`.claude/commands/\`. Each needs YAML frontmatter with
+Write 2 command files to \`.claude/commands/\`. Each needs YAML frontmatter with
 \`allowed-tools\`, \`description\`, and optionally \`argument-hint\`.
 
-### \`.claude/commands/task.md\`
-\`\`\`yaml
----
-allowed-tools: ["Read", "Write", "Edit", "Glob"]
-description: "Start or switch to a new task"
-argument-hint: "<task description>"
----
-\`\`\`
-Body: Instructions to read current \`.claude/state/task.md\`, update status to "In Progress",
-record the task description and timestamp. If starting a new task, archive the previous one.
-
-### \`.claude/commands/status.md\`
-\`\`\`yaml
----
-allowed-tools: ["Read", "Glob", "Grep", "Bash(git status)", "Bash(git diff --stat)"]
-description: "Show current task and session state"
----
-\`\`\`
-Body: Read \`.claude/state/task.md\`, show git status, list recently modified files,
-summarize current state in a concise format.
-
-### \`.claude/commands/done.md\`
-\`\`\`yaml
----
-allowed-tools: ["Read", "Write", "Edit", "Glob", "Grep", "Bash(git:*)", "Bash({test_command})", "Bash({lint_command})"]
-description: "Mark current task complete"
----
-\`\`\`
-Body: Run tests and lint checks. If they pass, update \`.claude/state/task.md\`
-status to "Done". Show a summary of what was accomplished. Suggest next steps.
+Do NOT generate task management commands (\`task.md\`, \`status.md\`, \`done.md\`) \u2014
+Claude Code has built-in TaskCreate/TaskUpdate/TaskList tools for task management.
 
 ### \`.claude/commands/analyze.md\`
 \`\`\`yaml
@@ -1298,10 +1266,11 @@ allowed-tools: ["Read", "Glob", "Grep", "Bash(git diff)", "Bash(git diff --cache
 description: "Review code changes for quality and security"
 ---
 \`\`\`
-Body: Review staged and unstaged changes. Check for: naming consistency,
-error handling, security issues, test coverage, import organization,
-code duplication. Run the project's linter. Provide a summary with
-severity levels (critical, warning, suggestion).`;
+Body: This command delegates to the code-reviewer agent for thorough review.
+1. Run \`git diff\` and \`git diff --cached\` to identify staged and unstaged changes
+2. Spawn the \`code-reviewer\` agent to perform the full review
+3. If the agent is unavailable, perform a lightweight review: run the linter and check for obvious issues
+Do NOT duplicate the code-reviewer agent's checklist here \u2014 the agent has the full review criteria.`;
 
 // src/cli.ts
 var __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
@@ -1681,61 +1650,6 @@ function mapFormatter(linter) {
   };
   return mapping[linter] ?? null;
 }
-function createTaskFile(projectInfo, preferences) {
-  const taskPath = path3.join(projectInfo.rootDir, ".claude", "state", "task.md");
-  fs3.mkdirSync(path3.dirname(taskPath), { recursive: true });
-  if (fs3.existsSync(taskPath)) {
-    return;
-  }
-  let content;
-  if (projectInfo.isExisting) {
-    content = `# Current Task
-
-## Status: Ready
-
-No active task. Start one with \`/task <description>\`.
-
-## Project Summary
-
-${projectInfo.name}${projectInfo.description ? ` - ${projectInfo.description}` : ""}
-
-**Tech Stack:** ${summarizeTechStack(projectInfo.techStack)}
-
-## Quick Commands
-
-- \`/task\` - Start working on something
-- \`/status\` - See current state
-- \`/analyze\` - Deep dive into code
-- \`/done\` - Mark task complete
-`;
-  } else {
-    const description = preferences?.description || "Explore and set up project";
-    content = `# Current Task
-
-## Status: In Progress
-
-**Task:** ${description}
-
-## Context
-
-New project - setting up from scratch.
-
-${preferences?.framework ? `**Framework:** ${formatFramework(preferences.framework)}` : ""}
-${preferences?.primaryLanguage ? `**Language:** ${formatLanguage(preferences.primaryLanguage)}` : ""}
-
-## Next Steps
-
-1. Define project structure
-2. Set up development environment
-3. Start implementation
-
-## Decisions
-
-(None yet - starting fresh)
-`;
-  }
-  fs3.writeFileSync(taskPath, content);
-}
 function formatLanguage(lang) {
   const names = {
     typescript: "TypeScript",
@@ -1833,7 +1747,7 @@ function runClaudeAnalysis(projectDir, projectInfo) {
       text: "Claude is analyzing your project...",
       spinner: {
         interval: 200,
-        frames: ["\xB7", "\u2722", "\u2733", "\u2736", "\u273B", "\u273D", "\u273B", "\u2736", "\u2733", "\u2722"]
+        frames: ["\xB7", "\u2722", "\u2733", "\u2736", "\u2733", "\u2722"]
       },
       color: "cyan"
     }).start();
@@ -1964,7 +1878,6 @@ async function main() {
   console.log(pc.green("Created:"));
   console.log(pc.green("  + .claude/settings.json"));
   console.log();
-  createTaskFile(projectInfo, preferences);
   const success = await runClaudeAnalysis(projectDir, projectInfo);
   if (!success) {
     console.error(pc.red("Claude analysis failed. Please try again."));
@@ -2022,7 +1935,6 @@ try {
 }
 export {
   checkClaudeCli,
-  createTaskFile,
   formatFramework,
   formatLanguage,
   getVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-starter",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "description": "A lightweight starter kit for AI-assisted development with Claude Code",
   "keywords": [
     "claude",