Memory Generator Skill

Generate comprehensive CLAUDE.md project memory files by exploring and analyzing codebases.

When to Use

Invoke this skill when:

• Starting work on a new/unfamiliar project
• A project lacks CLAUDE.md documentation
• User asks to "create memory" or "generate context" for a project
• Beginning exploration of a repository

Exploration Process

Phase 1: Project Structure Analysis

1. Identify project root markers:

   • .git/ directory
   • package.json, Cargo.toml, pyproject.toml, go.mod, etc.
   • Makefile, CMakeLists.txt, build.gradle

2. Map directory structure:

   tree -L 3 -d --dirsfirst
   # Or for large projects:
   find . -type d -maxdepth 3 | head -50
   

3. Identify key directories:

   • Source code: src/, lib/, app/, pkg/
   • Tests: tests/, test/, __tests__/, spec/
   • Config: config/, .github/, .vscode/
   • Docs: docs/, doc/, documentation/

Phase 2: Technology Detection

1. Language detection:

   # Count files by extension
   find . -type f -name "*.py" | wc -l
   find . -type f -name "*.go" | wc -l
   find . -type f -name "*.rs" | wc -l
   find . -type f -name "*.ts" -o -name "*.tsx" | wc -l
   

2. Framework detection:

   • Python: Django, Flask, FastAPI, pytest
   • JavaScript: React, Vue, Next.js, Express
   • Go: Gin, Echo, standard library patterns
   • Rust: Actix, Axum, Tokio

3. Dependency analysis:

   • Read requirements.txt, pyproject.toml
   • Read package.json, package-lock.json
   • Read Cargo.toml, go.mod

Phase 3: Pattern Recognition

1. Architecture patterns:

   • Monolith vs microservices
   • MVC, clean architecture, hexagonal
   • Module organization

2. Code conventions:

   • Naming patterns (snake_case, camelCase)
   • File naming conventions
   • Import organization

3. Testing patterns:

   • Test file naming (test_*.py, *_test.go)
   • Fixture patterns
   • Mock usage

Phase 4: Entry Point Discovery

1. Application entry points:

   • main.py, app.py, index.ts
   • cmd/, bin/ directories
   • Makefile targets

2. Build/run commands:

   • npm scripts
   • Makefile targets
   • Docker compose services

Phase 5: Documentation Review

1. Existing documentation:
   • README.md content
   • API documentation
   • Architecture docs
   • Contributing guides

Output: CLAUDE.md Template

# [Project Name]

## Overview
[1-2 sentence project description based on README or package metadata]

## Tech Stack
- **Language**: [Primary language and version]
- **Framework**: [Main framework if applicable]
- **Key Dependencies**: [Important libraries]
- **Testing**: [Test framework]
- **Build Tool**: [npm, cargo, make, etc.]

## Project Structure

[Simplified tree showing key directories]

### Key Directories
- `src/` - [Description]
- `tests/` - [Description]
- [Other important directories]

## Development Commands

```bash
# Install dependencies
[command]

# Run tests
[command]

# Run application
[command]

# Build
[command]

Architecture

Code Organization

[Brief description of how code is organized - modules, packages, layers]

Key Patterns

• [Pattern 1]: [Where/how it's used]
• [Pattern 2]: [Where/how it's used]

Entry Points

• [Main entry point and what it does]
• [Other important entry points]

Conventions

Naming

• Files: [convention]
• Functions/methods: [convention]
• Classes/types: [convention]

Code Style

• [Formatter used]
• [Linter used]
• [Key style rules]

Testing

• Test files: [naming pattern]
• Fixtures: [location/pattern]
• Running: [command]

Important Files

File	Purpose
[file1]	[purpose]
[file2]	[purpose]

Notes for Claude

• [Important context about how to work with this codebase]
• [Any quirks or non-obvious patterns]
• [Preferred approaches for this project]

## Customization

Tailor the generated CLAUDE.md based on:

### For ML/AI Projects
- Add sections on:
  - Model architecture locations
  - Training scripts
  - Dataset handling
  - Experiment tracking

### For Web Applications
- Add sections on:
  - API endpoints
  - Frontend structure
  - Database schema location
  - Authentication flow

### For Libraries/Packages
- Add sections on:
  - Public API surface
  - Versioning approach
  - Breaking change policy
  - Example usage

### For Monorepos
- Add sections on:
  - Package/workspace structure
  - Shared dependencies
  - Inter-package relationships
  - Build order

## Usage Example

When user says:
- "Generate memory for this project"
- "Create CLAUDE.md for this repo"
- "Help me understand this codebase"

Execute exploration process and generate CLAUDE.md:

```bash
# Step 1: Basic structure
ls -la
tree -L 2 -d --dirsfirst 2>/dev/null || find . -type d -maxdepth 2

# Step 2: Detect language/framework
cat package.json 2>/dev/null | head -30
cat pyproject.toml 2>/dev/null | head -30
cat Cargo.toml 2>/dev/null | head -30
cat go.mod 2>/dev/null

# Step 3: Read existing docs
cat README.md 2>/dev/null | head -100

# Step 4: Sample source files to understand patterns
# Find representative files and read them

# Step 5: Generate CLAUDE.md

Output Location

• Primary: ./CLAUDE.md (project root, version controlled)
• Alternative: ./.claude/CLAUDE.md (claude-specific directory)
• Private: ./CLAUDE.local.md (gitignored, personal notes)

Ask user preference if unclear.