project-skill-creator

What this skill does

# Project Skill Creator

## Overview

**Creating project-specific skills captures institutional knowledge and patterns that generic skills cannot provide.**

This skill analyzes your project and creates specialized skills (e.g., `project-architecture`, `project-conventions`, `project-testing`) that document project-specific patterns, standards, and workflows that all agents and future developers should follow.

**Core principle:** Project-specific skills transform tribal knowledge into discoverable documentation.

**REQUIRED BACKGROUND:** Use `writing-skills` for skill creation methodology. This skill applies those principles to project-specific content.

## When to Use

Use this skill when:
- User runs `/cc:setup-project` command
- User requests "create custom skills for my project"
- Project has unique architecture or patterns to document
- Team needs standardized conventions
- Onboarding new developers or agents

Do NOT use for:
- Generic patterns already covered by existing skills
- One-off projects without reusable patterns
- Projects still in early prototyping phase

## Project-Specific Skills to Create

### 1. project-architecture
**Purpose:** Document and explain the system architecture

**When to create:** Always (if project has clear architecture)

**Content:**
- High-level architecture diagram/description
- Component responsibilities
- Data flow and interactions
- Key design decisions and trade-offs
- How to extend the architecture

**Example trigger:** "Use when implementing features, adding components, or understanding system design - documents THIS project's architecture, component responsibilities, and design patterns"

### 2. project-conventions
**Purpose:** Capture code style and naming conventions

**When to create:** If project has specific conventions beyond standard linters

**Content:**
- Naming conventions (files, classes, functions)
- Code organization patterns
- Import/export conventions
- Comment and documentation standards
- File/directory structure rules

**Example trigger:** "Use when writing new code in this project - enforces naming conventions, code organization, and style patterns specific to this codebase"

### 3. project-testing
**Purpose:** Document testing approach and patterns

**When to create:** If project has specific testing patterns

**Content:**
- Testing philosophy and requirements
- Test organization (unit/integration/e2e)
- Fixture patterns and test utilities
- Mocking strategies
- Coverage requirements
- Example test patterns from project

**Example trigger:** "Use when writing tests - follows THIS project's testing patterns, fixture conventions, and test organization structure"

### 4. project-deployment
**Purpose:** Document build, release, and deployment process

**When to create:** If project has specific deployment workflow

**Content:**
- Build process and commands
- Environment setup
- Deployment steps
- Release checklist
- CI/CD pipeline explanation
- Rollback procedures

**Example trigger:** "Use when deploying, releasing, or setting up environments - documents THIS project's build process, deployment steps, and release workflow"

### 5. project-domain
**Purpose:** Capture domain-specific knowledge

**When to create:** If project has unique business domain

**Content:**
- Domain terminology and glossary
- Business rules and constraints
- Domain models and relationships
- Common workflows and use cases
- Domain-specific patterns

**Example trigger:** "Use when implementing business logic or understanding domain concepts - documents THIS project's business domain, terminology, and domain-specific rules"

## Project Analysis Workflow

### Phase 1: Project Understanding

**1. Architecture Discovery**

Analyze project structure:
```bash
# Get overview of directory structure
ls -R | head -100

# Look for architecture documentation
find . -name "README*" -o -name "ARCHITECTURE*" -o -name "DESIGN*"

# Analyze directory organization
tree -d -L 3
```

Identify architectural patterns:
- Monolith vs microservices
- Layered architecture (presentation/business/data)
- Clean architecture (domain/application/infrastructure)
- MVC, MVVM, or other patterns
- Frontend architecture (components, state management)

**2. Convention Discovery**

Sample 10-15 files to find patterns:
- File naming: kebab-case, snake_case, PascalCase?
- Class naming conventions
- Function naming patterns
- Import organization
- Comment styles

**3. Testing Pattern Discovery**

Examine test files:
```bash
# Find test files
find . -name "*test*" -o -name "*spec*" | head -20

# Read sample tests to understand patterns
```

Identify:
- Test organization structure
- Fixture patterns
- Mocking approach
- Assertion style
- Test naming conventions

**4. Deployment Process Discovery**

Check for:
- CI/CD configuration (`.github/workflows`, `.gitlab-ci.yml`)
- Build scripts (`package.json scripts`, `Makefile`, `justfile`)
- Docker setup (`Dockerfile`, `docker-compose.yml`)
- Deployment documentation

### Phase 2: Interactive Planning

**CRITICAL: Present findings and proposed skills to user.**

Create summary:

```markdown
## Project Analysis Summary

**Architecture Pattern:** {discovered pattern}
**Key Components:**
- {component 1} - {purpose}
- {component 2} - {purpose}

**Conventions Found:**
- File naming: {pattern}
- Class naming: {pattern}
- Import organization: {pattern}

**Testing Approach:**
- Test organization: {structure}
- Fixture patterns: {description}
- Coverage: {requirements}

**Deployment:**
- Build process: {description}
- CI/CD: {platform and approach}

## Recommended Skills

I recommend creating these project-specific skills:

1. **project-architecture** - Document {architecture pattern} and component responsibilities
2. **project-conventions** - Capture {naming} and {organization} conventions
3. **project-testing** - Document {testing approach} and fixture patterns
4. **project-deployment** - Document {build process} and deployment steps

Should I create these skills?
```

Get user approval before proceeding.

### Phase 3: Skill Generation

For each approved skill, follow `writing-skills` methodology:

**1. Create Skill Directory**
```bash
mkdir -p .claude/skills/project-{skill-name}
```

**2. Generate SKILL.md**

Use template:

```yaml
---
name: project-{skill-name}
description: Use when {specific triggers} - {what this skill provides specific to THIS project}
---

# Project {Skill Name}

## Overview

{One paragraph explaining what this skill provides for THIS project}

**Core principle:** {Key principle from project}

## {Main Content Sections}

{Content specific to this skill type - see templates below}

## When NOT to Use

- {Situations where this skill doesn't apply}
- {Edge cases or exceptions}

## Examples from This Project

{2-3 concrete examples from actual project code}

## Common Mistakes

{Project-specific anti-patterns to avoid}
```

**3. Populate with Project-Specific Content**

**For project-architecture:**
```markdown
## Architecture Overview

{High-level description}

**Pattern:** {Architecture pattern name}

## Component Responsibilities

### {Component 1}
**Location:** `{path}`
**Purpose:** {what it does}
**Dependencies:** {what it depends on}

### {Component 2}
{...}

## Data Flow

{How data moves through the system}

## Key Design Decisions

### Decision: {Decision name}
**Rationale:** {why this decision was made}
**Trade-offs:** {what we gave up}
**Alternatives considered:** {what else was considered}

## Extending the Architecture

When adding new features:
1. {Step 1 with specific guidance}
2. {Step 2}

{Include actual examples from project}
```

**For project-conventions:**
```markdown
## File Naming

**Pattern:** {discovered pattern}

Examples from this project:
- {actual file 1}
- {actual file 2}

## Class/Component Naming

**Pattern:** {discovered pattern}

Examples:
```{language}
{actual code example 1}
{actual code example 2}
```

## Import Organization

**Pattern:** {discovered pattern}

Stan