zhongwei/gh-hirefrank-hirefrank-marketplace-plugins-claude-skills-analyzer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-29 18:45:47 +08:00
commit 857aa79f37
12 changed files with 2705 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
.claude-plugin/plugin.json Normal file
View File

@@ -0,0 +1,15 @@
{
"name": "claude-skills-analyzer",
"description": "Analyze AI conversation exports to generate reusable Custom Skills",
"version": "1.2.0",
"author": {
"name": "Frank Harris",
"email": "frank@hirefrank.com"
},
"skills": [
"./skills"
],
"commands": [
"./commands"
]
}

3
README.md Normal file
View File

@@ -0,0 +1,3 @@
# claude-skills-analyzer
Analyze AI conversation exports to generate reusable Custom Skills

427
commands/analyze-skills.md Normal file
View File

@@ -0,0 +1,427 @@
---
description: Analyze AI conversation exports to generate reusable Custom Skills
---
# Analyze Skills Command
You are a Claude Skills Architect analyzing a user's complete AI conversation history to identify, prioritize, and automatically generate custom Claude Skills. Custom Skills are reusable instruction sets with proper YAML frontmatter, supporting documentation, and templates that help Claude consistently produce high-quality outputs for recurring tasks.
**ultrathink**: Use extended thinking capabilities when you encounter:
- Large conversation datasets (>50 conversations) requiring deep pattern analysis
- Complex cross-platform deduplication decisions
- Ambiguous skill boundary determinations
- Statistical validation of pattern significance
- Strategic tradeoffs in skill consolidation
You decide when extended reasoning will improve analysis quality. Trust your judgment.
## Your Mission
Perform comprehensive analysis of conversation exports to:
1. Identify all potential custom skill opportunities
2. Eliminate redundancies and optimize skill boundaries
3. Generate complete, ready-to-use skill packages
4. Provide implementation roadmap and maintenance guidance
5. **Enable incremental processing** - skip previously analyzed conversations and build on prior work
**Analysis Approach:**
- Use extended reasoning to identify non-obvious patterns across conversations
- Think deeply about skill boundaries and overlap resolution
- Consider temporal patterns and user expertise evolution
- Validate pattern significance statistically before recommending skills
- Reason through cross-platform deduplication decisions carefully
## Input Format
The user should have their conversation export files in the `data-exports/` directory structure. If not already created, the `/skills-setup` command will create this automatically.
Expected structure:
```
data-exports/
├── chatgpt/ # Place ChatGPT export files here
│ ├── conversations.json
│ ├── user.json
│ ├── shared_conversations.json
│ └── message_feedback.json (optional)
└── claude/ # Place Claude export files here
├── conversations.json
├── projects.json
└── users.json
```
**Note**: If you haven't run `/skills-setup` yet, use it first to create the necessary directory structure and get detailed export instructions.
### Claude Export Format (data-exports/claude/):
1. **conversations.json** - Complete conversation history with messages, timestamps, and metadata
2. **projects.json** - Project information including descriptions, documentation, and workflows
3. **users.json** - User account information (for privacy considerations and expertise assessment)
### ChatGPT Export Format (data-exports/chatgpt/):
1. **conversations.json** - Conversation history with mapping structure and message objects
2. **user.json** - User profile information with account details
3. **shared_conversations.json** - Shared conversation metadata with titles and IDs
4. **message_feedback.json** - User feedback on AI responses (if available)
5. **shopping.json** - Transaction and purchase data (if available)
### Platform Detection:
Automatically detect available platforms by scanning both data-exports/ directories and adapt processing accordingly.
## Analysis Framework
This command uses the **[shared analysis methodology](../shared/analysis-methodology.md)** with export-specific enhancements.
### Phase 0: Analysis Scope Determination (Export-Specific)
1. **Check for Previous Analysis Log**:
- If user provides a previous analysis log (from prior runs), parse it to identify:
- Previously analyzed conversation IDs and their analysis dates
- Generated skills and their source conversations
- File modification dates or content hashes of processed files
- Analysis metadata (dates, conversation counts, skill counts)
2. **Determine Analysis Scope**:
- Compare current conversation files with previous analysis log
- Identify new conversations (not in previous log)
- Identify potentially modified conversations (based on message counts, dates, or user indication)
- Flag conversations that need analysis vs. those to skip for efficiency
3. **Output Analysis Plan**:
- List conversations to be analyzed (new + potentially modified)
- List conversations being skipped (unchanged from previous run)
- Estimated processing scope and rationale
- Expected time and complexity of analysis
### Phase 1: Data Processing & Pattern Discovery
**Use extended reasoning to identify subtle patterns across large conversation sets.**
1. **Platform Detection and Data Parsing** (Export-Specific):
- Auto-detect export format (Claude vs ChatGPT)
- Parse conversations, projects, user data based on platform
- Extract expertise indicators and usage patterns
2. **Apply [Shared Pattern Discovery](../shared/analysis-methodology.md#phase-1-pattern-discovery--classification)**:
- **Data-driven domain discovery** (let actual topics emerge - DO NOT force into predefined categories)
- Task types (creation, transformation, analysis, troubleshooting, curation)
- Explicit and implicit pattern markers
- Niche & specialized pattern detection (hobbyist domains, creative work, prompt engineering, etc.)
- Temporal pattern detection
- User expertise evolution over time
3. **Export-Specific Enhancements**:
- Cross-reference with project data (Claude exports):
- How many projects demonstrate similar patterns?
- Do project descriptions reinforce conversation patterns?
- Project success indicators and user satisfaction
- Message feedback analysis (ChatGPT exports):
- User feedback patterns on AI responses
- Quality improvement opportunities
**Think deeply about:**
- Are these truly distinct patterns or variations of the same workflow?
- What makes this pattern recurring vs. one-off requests?
- How do patterns evolve across the user's conversation timeline?
**Terminal Output - Domain Diversity Visualization:**
After completing pattern discovery, display an ASCII chart showing domain distribution to validate data-driven discovery:
```
📊 Domain Distribution Analysis
Business & Strategy ████████████░░░░░░░░ 12 patterns (32%)
Creative & Writing ██████████░░░░░░░░░░ 10 patterns (27%)
Image Prompting ████████░░░░░░░░░░░░ 8 patterns (22%)
Learning & Education ████░░░░░░░░░░░░░░░░ 4 patterns (11%)
Recipe & Cooking ██░░░░░░░░░░░░░░░░░░ 2 patterns (5%)
Gaming & Design █░░░░░░░░░░░░░░░░░░░ 1 pattern (3%)
✅ Domain Diversity: 6 distinct topic areas detected
✅ No predefined categorization - domains emerged from your data
```
This validates that the analysis discovered diverse patterns beyond traditional business/coding domains.
### Phase 2-4: Core Analysis
Apply the **[shared analysis methodology](../shared/analysis-methodology.md)** phases:
- **Phase 2**: Frequency & Temporal Analysis with project data cross-referencing
- **Phase 3**: Skill-Worthiness Scoring (0-50 composite scale)
- **Phase 4**: Relationship Mapping & Overlap Analysis
See [shared methodology](../shared/analysis-methodology.md) for complete details.
### Phase 5: Cross-Platform Pattern Deduplication (Export-Specific)
When processing mixed datasets (both ChatGPT and Claude exports), perform comprehensive deduplication before skill generation.
See **[shared methodology - Cross-Platform Deduplication](../shared/analysis-methodology.md#cross-platform-deduplication-export-analysis-only)** for:
- Content similarity detection
- Deduplication classification rules
- Pattern frequency recalculation
- Unified skill design preparation
- Deduplication validation
**Export-Specific Advantages:**
- Access to complete conversation history (not just recent/accessible)
- Project metadata integration (Claude)
- Message feedback data (ChatGPT)
- Temporal analysis across months/years
### Phase 6: Skill Generation & Optimization
**Use extended reasoning to optimize skill boundaries and maximize user value.**
Apply **[shared methodology - Prioritization Matrix](../shared/analysis-methodology.md#phase-5-prioritization-matrix)** and boundary optimization strategies.
**Export-Specific Enhancements:**
- Leverage project success data for impact validation
- Use message feedback for quality improvement insights
- Apply historical trend analysis for strategic pattern identification
## Output Generation Options
Ask user to choose:
**Option A: Analysis Report Only**
- Comprehensive analysis with recommendations
- No file generation
- Implementation guidance only
**Option B: Complete Implementation Package** (Recommended)
- Full analysis plus ready-to-use skills
- Proper folder structure with all supporting files
- Testing and validation guidance
**Option C: Incremental Implementation**
- Start with top 3-5 skills
- Provide complete package for priority skills
- Expansion roadmap for additional skills
**Option D: Custom Specification**
- User-defined subset of skills
- Specific modifications or requirements
- Tailored to particular use cases
## File Generation (Option B/C)
**Note**: If these directories don't exist, they will be automatically created by the analysis process.
### Create Analysis Reports
Generate timestamped reports in `reports/{TIMESTAMP}/`:
1. **`skills-analysis-log.json`** (Root directory) - Machine-readable incremental processing data
**Example structure:**
```json
{
"analysis_date": "YYYY-MM-DDTHH:MM:SSZ",
"platform_detected": "claude|chatgpt|mixed",
"total_conversations": 150,
"report_directory": "reports/2025-01-23_22-40-00",
"conversations_analyzed": [
{
"id": "conv_123",
"platform": "chatgpt|claude",
"file": "data-exports/chatgpt/conversations.json",
"message_count": 45,
"first_message_date": "2024-01-01T10:00:00Z",
"last_message_date": "2024-01-10T14:20:00Z",
"analysis_hash": "sha256:abc123...",
"topics_identified": ["coding", "documentation"],
"patterns_found": 3
}
],
"deduplication_summary": {
"cross_platform_duplicates_removed": 45,
"workflow_instances_merged": 12,
"frequency_adjustments": {
"newsletter_critique": {"before": 1225, "after": 987},
"business_communication": {"before": 709, "after": 643}
}
},
"skills_generated": [
{
"skill_name": "newsletter-critique-specialist",
"source_conversations": ["conv_123", "conv_789"],
"frequency_score": 8,
"impact_score": 9,
"platform_coverage": "both",
"generated_files": [
"generated-skills/newsletter-critique-specialist/SKILL.md",
"generated-skills/newsletter-critique-specialist/reference.md"
]
}
],
"analysis_metadata": {
"total_patterns_identified": 25,
"patterns_consolidated": 8,
"patterns_deduplicated": 6,
"final_skill_count": 5,
"processing_time_minutes": 45
}
}
```
2. **`comprehensive-skills-analysis.md`** - Complete pattern analysis with skill recommendations and prioritization visualization
3. **`implementation-guide.md`** - Actionable deployment roadmap
**Report Visualization Requirements:**
Include a Mermaid quadrant chart in `comprehensive-skills-analysis.md` showing the prioritization matrix:
```markdown
## 📊 Skill Prioritization Matrix
```mermaid
%%{init: {'theme':'base'}}%%
quadrantChart
title Skill Prioritization: Frequency vs Impact
x-axis Low Frequency --> High Frequency
y-axis Low Impact --> High Impact
quadrant-1 Strategic
quadrant-2 Quick Wins
quadrant-3 Defer
quadrant-4 Automate
[Skill Name 1]: [freq_score/10, impact_score/10]
[Skill Name 2]: [freq_score/10, impact_score/10]
[Skill Name 3]: [freq_score/10, impact_score/10]
```
\```
**Legend:**
- **Quick Wins** (top-right): High frequency, high impact - implement first
- **Strategic** (top-left): Lower frequency but high value - critical capabilities
- **Automate** (bottom-right): High frequency, simpler - nice efficiency gains
- **Defer** (bottom-left): Low priority - consider simple prompts instead
**Calculations:**
- X-axis (Frequency): Use frequency score (0-10) from skill-worthiness evaluation
- Y-axis (Impact): Average of complexity + time savings + error reduction scores (0-10)
```
### Generate Skill Packages
For each approved skill, create complete folder structure in `generated-skills/`:
```
skill-name/
├── SKILL.md (required - main skill with YAML frontmatter)
├── reference.md (detailed methodology and frameworks)
├── examples.md (additional examples and use cases)
├── templates/ (reusable templates for outputs)
│ ├── template-1.md
│ └── template-2.md
└── scripts/ (utility scripts if applicable)
└── helper-script.py
```
**Auto-creation**: The `generated-skills/` directory will be created automatically when you select Option B or C.
### SKILL.md Generation Template
```yaml
---
name: [skill-name] # Only lowercase letters, numbers, and hyphens
description: [CRITICAL: Must include BOTH what skill does AND when to use it. Written in third person. Include key trigger terms.]
---
# [Skill Name]
## Instructions
[Clear, step-by-step guidance - KEEP UNDER 500 LINES TOTAL]
1. **[Phase 1 Name]**
- [Specific instruction 1]
- [Specific instruction 2]
2. **[Apply Framework/Method]** from [reference.md](reference.md):
- [Framework element 1]
- [Framework element 2]
3. **[Use Templates]** from [templates/](templates/):
- [Template 1 description and usage]
- [Template 2 description and usage]
4. **[Quality Standards]**:
- [Standard 1]
- [Standard 2]
## Examples
### [Example Scenario 1]
**User Request**: "[Realistic user request]"
**Response using methodology**:
```
[Complete example showing proper skill usage]
```
For more examples, see [examples.md](examples.md).
For detailed methodology, see [reference.md](reference.md).
```
## Quality Standards
All quality standards follow the **[shared analysis methodology](../shared/analysis-methodology.md#quality-standards)**:
- Pattern validation requirements (frequency, consistency, evidence)
- Skill consolidation rules (max 8-12 skills, clear boundaries)
- Skill package generation standards
- Anti-patterns to avoid
**Export-Specific Enhancements:**
- Minimum frequency: 50+ occurrences OR high strategic value (with complete history available)
- Cross-platform evidence: Include examples from both platforms when available
- Project data validation: Cross-reference patterns with project success metrics
## Instructions for Execution
1. **Initialize Timestamp**: Create `TIMESTAMP=$(date +%Y-%m-%d_%H-%M-%S)`
2. **Create Reports Directory**: `mkdir -p reports/{TIMESTAMP}`
3. **Check for Previous Analysis Log**: Look for existing `skills-analysis-log.json` in root directory
4. **Scan Data Directories**: Check `data-exports/chatgpt/` and `data-exports/claude/` for available platforms
5. **Determine analysis scope** using Phase 0 if previous log exists
6. **Start with user choice** of output option (A/B/C/D)
7. **Perform complete analysis** following all phases for determined scope
8. **Execute cross-platform deduplication** if both ChatGPT and Claude data detected (Phase 5)
9. **Generate output files**:
- Update/create `skills-analysis-log.json` in root directory
- Create `reports/{TIMESTAMP}/comprehensive-skills-analysis.md`
- Create `reports/{TIMESTAMP}/implementation-guide.md`
10. **Generate skill packages** in `generated-skills/` if requested (Option B/C)
11. **Validate all content** using quality framework and analysis standards
12. **Cleanup Phase**:
- Remove temporary analysis scripts from `scripts/` directory
- Delete intermediate data processing files (*.tmp, *.cache, etc.)
- Remove empty directories created during processing
- Clean up any Python virtual environments or temporary dependencies
- Remove duplicate or staging files from skill generation process
13. **Archive Organization** (Optional):
- Compress older reports directories (keep last 3-5 runs)
- Move temporary logs to archive subdirectory
- Consolidate debug output into single log file
14. **Cleanup Validation**:
- Verify all essential outputs remain intact:
- `skills-analysis-log.json` (root)
- `reports/{TIMESTAMP}/` directory with analysis reports
- `generated-skills/` directory with skill packages
- Confirm no critical files were accidentally removed
- Display cleanup summary showing what was removed vs. retained
### Quality Focus Requirements
Apply **[shared methodology quality standards](../shared/analysis-methodology.md#quality-standards)** with export-specific validation:
- Eliminate generic patterns and focus on specific workflows
- Consolidate overlapping skills (max 8-12, recommend top 5-8)
- Validate frequency claims post-deduplication
- Prioritize by genuine impact (>30 min/week time savings)
- Platform-agnostic design for all generated skills
### For Incremental Processing
If user provides previous analysis log:
- Parse the log to understand what was previously analyzed
- Skip unchanged conversations (based on IDs and metadata)
- Focus on new or modified conversations only
- Re-run deduplication if new platform data added
- Integrate new findings with previous skill recommendations
- Update the analysis log with new data
**Data Location**: JSON files are located in `data-exports/chatgpt/` and `data-exports/claude/` subdirectories. The system will automatically detect available platform(s) and process files accordingly.

267
commands/extract-exports.md Normal file
View File

@@ -0,0 +1,267 @@
---
description: Automatically extract and organize AI conversation export zip files into proper directory structure
---
# Extract Exports Command
Automatically extract AI conversation export zip files (Claude and/or ChatGPT) and organize them into the proper directory structure for skills analysis.
## What This Command Does
1. **Detects export zip files** in your current directory
2. **Identifies platform type** (Claude vs ChatGPT) by examining contents
3. **Creates directory structure** if it doesn't exist
4. **Extracts and organizes files** into correct locations
5. **Validates file placement** and reports results
6. **Cleans up** temporary files and optionally removes original zips
## Expected Directory Structure After Extraction
```
your-project/
├── data-exports/
│ ├── claude/ # Claude export files
│ │ ├── conversations.json
│ │ ├── projects.json
│ │ └── users.json
│ └── chatgpt/ # ChatGPT export files
│ ├── conversations.json
│ ├── user.json
│ ├── shared_conversations.json
│ └── message_feedback.json
├── reports/ # Analysis reports (created when needed)
└── generated-skills/ # Generated skills (created when needed)
```
## How to Use
1. **Download your export zip files** from Claude and/or ChatGPT
2. **Place zip files in your current directory** (where you want the analysis to happen)
3. **Run this command**: The system will handle the rest automatically
## Supported Export Formats
### Claude Exports
Expected zip contents:
- `conversations.json` (required)
- `projects.json` (optional)
- `users.json` (optional)
### ChatGPT Exports
Expected zip contents:
- `conversations.json` (required)
- `user.json` (optional)
- `shared_conversations.json` (optional)
- `message_feedback.json` (optional)
- `shopping.json` (optional - will be ignored)
## Instructions for Execution
1. **Scan Current Directory**:
- Look for `*.zip` files in current directory
- Report found zip files to user for confirmation
2. **Create Directory Structure**:
- Create `data-exports/` directory if it doesn't exist
- Create `data-exports/claude/` subdirectory
- Create `data-exports/chatgpt/` subdirectory
- Create `reports/` and `generated-skills/` directories for future use
3. **Process Each Zip File**:
- Extract to temporary directory (`temp_extract_TIMESTAMP/`)
- Examine contents to identify platform type
- Look for key indicator files:
- Claude: `conversations.json` + `projects.json` present
- ChatGPT: `conversations.json` + `user.json` present
- Mixed/Unknown: Ask user to specify platform
4. **Platform Detection Logic**:
```
If contains "projects.json" → Claude export
Else if contains "user.json" → ChatGPT export
Else if only "conversations.json" → Ask user to specify
Else → Invalid export format
```
5. **File Organization**:
- **For Claude exports**: Move all JSON files to `data-exports/claude/`
- **For ChatGPT exports**: Move all JSON files to `data-exports/chatgpt/`
- Skip non-JSON files (README, etc.)
- Handle file conflicts by asking user preference (overwrite/skip/backup)
6. **Validation**:
- Verify required files (`conversations.json`) are present
- Check file sizes are reasonable (not empty, not suspiciously large)
- Validate JSON format of critical files
- Report any missing optional files
7. **Cleanup Options**:
- Remove temporary extraction directories
- Ask user about original zip files:
- **Keep**: Leave original zips in place
- **Archive**: Move to `archives/` subdirectory
- **Delete**: Remove original zips completely
8. **Final Report**:
- Summary of extracted files by platform
- Location of organized files
- Any warnings or issues encountered
- Next steps recommendation (run `/analyze-skills`)
## User Interaction Flow
```
Found the following zip files:
• claude_export_2024_01_20.zip (2.3 MB)
• chatgpt_export_jan_2024.zip (4.1 MB)
Proceed with extraction and organization? [Y/n]
✅ Creating directory structure...
✅ Extracting claude_export_2024_01_20.zip...
→ Detected: Claude export (found projects.json)
→ Moving files to data-exports/claude/
→ Files: conversations.json, projects.json, users.json
✅ Extracting chatgpt_export_jan_2024.zip...
→ Detected: ChatGPT export (found user.json)
→ Moving files to data-exports/chatgpt/
→ Files: conversations.json, user.json, shared_conversations.json
✅ Validation complete:
• Claude: 1,247 conversations in conversations.json
• ChatGPT: 892 conversations in conversations.json
What should I do with the original zip files?
[K]eep them / [A]rchive them / [D]elete them: A
✅ Original zips moved to archives/
🎉 Export organization complete!
Your files are now ready for analysis:
• Claude exports: data-exports/claude/
• ChatGPT exports: data-exports/chatgpt/
Next step: Run `/analyze-skills` to identify skill opportunities
```
## Error Handling
### Common Issues & Solutions
**No zip files found**:
- Check current directory for `*.zip` files
- Verify zip files are conversation exports (not other types)
- Provide guidance on downloading exports if needed
**Corrupted or invalid zip files**:
- Report which zip file has issues
- Suggest re-downloading from the platform
- Continue with other valid zip files
**Missing required files**:
- Report missing `conversations.json`
- Explain impact on analysis capability
- Suggest contacting platform support
**JSON parsing errors**:
- Report which file has JSON format issues
- Attempt to continue with other files
- Suggest platform support if file appears corrupted
**Directory permission issues**:
- Check write permissions for current directory
- Provide clear error message and resolution steps
- Suggest alternative directory if needed
**Disk space issues**:
- Check available disk space before extraction
- Estimate space needed based on zip file sizes
- Provide cleanup recommendations if space is low
## File Conflict Resolution
When files already exist in target directories:
**Conversations.json exists**:
```
Found existing conversations.json in data-exports/claude/
• Existing: 1,156 conversations (last modified: 2024-01-15)
• New: 1,247 conversations (from zip file)
Choose action:
[O]verwrite with new file
[B]ackup existing and use new
[S]kip extraction (keep existing)
[C]ompare and merge (advanced)
Your choice: B
✅ Existing file backed up as conversations_backup_2024-01-20.json
✅ New file extracted as conversations.json
```
## Integration with Other Commands
**Seamless workflow with existing commands**:
- After successful extraction → Suggest running `/analyze-skills`
- If directory structure missing → Automatically create (no need for `/skills-setup`)
- Before analysis → Check for proper file organization
**State validation**:
- Check if exports are already extracted before running
- Detect incremental updates (new exports vs existing data)
- Provide smart recommendations based on current state
## Quality Standards
**File Validation Requirements**:
- Verify JSON files are valid JSON format
- Check that conversations.json contains actual conversation data
- Validate file sizes are within reasonable ranges (not empty, not huge)
- Ensure required fields exist in JSON structure
**Security Considerations**:
- Only extract to controlled subdirectories
- Sanitize file names to prevent directory traversal
- Validate zip contents before extraction
- Limit extraction to reasonable file sizes
**User Experience Standards**:
- Clear progress indicators during extraction
- Descriptive error messages with resolution steps
- Confirmation prompts for destructive actions
- Helpful next-step recommendations
## Advanced Features
**Incremental Processing Support**:
- Detect if exports contain new conversations vs existing data
- Smart merge options for updated exports
- Preserve existing analysis logs and reports
**Batch Processing**:
- Handle multiple zip files from same platform
- Merge multiple ChatGPT exports if user has multiple accounts
- Consolidate multiple Claude exports from different time periods
**Cross-Platform Intelligence**:
- Detect potential duplicate conversations across platforms
- Flag cross-platform analysis opportunities
- Prepare data for unified analysis workflow
## Commands Integration
This command works seamlessly with:
- **`/skills-setup`**: No longer needed if this command is run first
- **`/analyze-skills`**: Ready to run immediately after extraction
- **`/skills-troubleshoot`**: Can diagnose extraction-related issues
**Recommended workflow**:
1. Download exports from Claude/ChatGPT
2. Run `/extract-exports` (this command)
3. Run `/analyze-skills` for pattern analysis
4. Implement recommended skills
Ready to automatically organize your conversation exports!

226
commands/skills-setup.md Normal file
View File

@@ -0,0 +1,226 @@
---
description: Guide you through setting up AI conversation exports for skills analysis
---
# Skills Analysis Setup Guide
I'll walk you through setting up your AI conversation exports for analysis and help you get the most value from the Claude Skills Analyzer.
## 📋 What You'll Need
To analyze your AI usage patterns and generate Custom Skills, you need:
1. **AI conversation exports** (Claude and/or ChatGPT)
2. **Organized directory structure** for your data
3. **At least 20+ conversations** for basic analysis (50+ recommended for robust patterns)
## 📥 How to Export Your Conversations
### For Claude Conversations:
**Step 1: Request Export**
1. Go to [claude.ai/settings](https://claude.ai/settings)
2. Click on **"Privacy"** in the left sidebar
3. Look for **"Request data export"** or similar option
4. Click the button to request your export
**Step 2: Wait for Email**
- Claude will send you an email when your export is ready
- This typically takes 24 hours (sometimes sooner)
- The email will contain a download link
**Step 3: Extract and Save**
1. Download the ZIP file from the email
2. **Option A - Automatic** (Recommended): Place the ZIP file in your project directory and run `/extract-exports` - it will automatically extract and organize everything for you
3. **Option B - Manual**: Extract all files (you'll have `conversations.json`, `projects.json`, etc.) and save them to your `data-exports/claude/` folder (we'll create this next)
**Files you should see:**
- `conversations.json` (required) - Your conversation history
- `projects.json` (optional) - Project information and metadata
- `users.json` (optional) - Account information
**⚠️ Important Note:**
Claude exports from claude.ai **DO NOT include Claude Code conversations**. Only conversations from the web interface (claude.ai) are included in the export. If you primarily use Claude Code, your export may have fewer conversations than expected.
### For ChatGPT Conversations:
**Step 1: Request Export**
1. Go to [chatgpt.com/settings/general](https://chatgpt.com/settings/general)
2. Scroll down to **"Data controls"** section
3. Click **"Export data"**
4. Select what you want to export (conversations are usually pre-selected)
5. Confirm the export request
**Step 2: Wait for Email**
- ChatGPT will send you an email when your export is ready
- This usually takes 2-4 hours
- The email will contain a download link
**Step 3: Extract and Save**
1. Download the ZIP file from the email
2. **Option A - Automatic** (Recommended): Place the ZIP file in your project directory and run `/extract-exports` - it will automatically extract and organize everything for you
3. **Option B - Manual**: Extract all files (you'll have `conversations.json`, `user.json`, etc.) and save them to your `data-exports/chatgpt/` folder (we'll create this next)
**Files you should see:**
- `conversations.json` (required) - Your conversation history
- `user.json` (optional) - Account information
- `shared_conversations.json` (optional) - Shared conversations metadata
- `message_feedback.json` (optional) - Your feedback on responses
### Troubleshooting Export:
**Can't find Settings?**
- Claude: Look for your account icon (bottom left) → Settings → Privacy & Data
- ChatGPT: Click your account name (bottom left) → Settings → scroll to Data controls
**Export not arriving?**
- Check spam/junk email folder
- Wait a bit longer (can take up to 24 hours)
- Try requesting again if it's been >24 hours
**Files look different?**
- Export formats can vary slightly between updates
- As long as you have `conversations.json`, the analysis will work
- Missing optional files is fine
---
## 🗂️ Directory Structure Setup
I can create the proper directory structure for you automatically. Here's what will be created:
```
your-project/
├── data-exports/
│ ├── claude/ # Place Claude exports here
│ └── chatgpt/ # Place ChatGPT exports here
├── reports/ # Analysis reports will appear here
└── generated-skills/ # Generated skills will appear here
```
**Ready to create these directories?**
Just confirm and I'll set up:
- ✅ `data-exports/claude/` - for your Claude conversation exports
- ✅ `data-exports/chatgpt/` - for your ChatGPT conversation exports
- ✅ `reports/` - for timestamped analysis reports
- ✅ `generated-skills/` - for your generated Custom Skills
Confirm when you're ready!
**💡 Quick Tip**: Once you have the ZIP files from Claude/ChatGPT, you can use the `/extract-exports` command to automatically extract and organize everything for you! Just place the ZIP files in your project directory and run the command.
## ⚡ Quick Start Checklist
**Setup Phase:**
- [ ] Directories created (`data-exports/`, `reports/`, `generated-skills/`)
- [ ] At least one platform export requested (Claude and/or ChatGPT)
- [ ] Waiting for export email to arrive (24 hours or less)
**Data Phase:**
- [ ] Export files downloaded and extracted
- [ ] JSON files placed in correct `data-exports/` subdirectories
- [ ] You have at least 20+ conversations (more is better for patterns)
**Analysis Phase:**
- [ ] Ready to run `/analyze-skills` when exports are ready
- [ ] Know which output option you want (A, B, C, or D)
- [ ] Have time for analysis to complete (2-5 minutes typically)
**Completion:**
- [ ] Analysis finished and reports generated
- [ ] Review skills recommendations
- [ ] Generate or implement skills as desired
## 🎯 What the Analysis Will Find
The plugin will identify patterns like:
### Business & Communication
- Email drafting templates
- Proposal writing workflows
- Client communication patterns
- Meeting preparation structures
### Development & Code
- Code review methodologies
- Documentation standards
- Debugging approaches
- Architecture decision patterns
### Content & Writing
- Blog post structures
- Newsletter formats
- Social media workflows
- Research methodologies
### Personal Productivity
- Task planning approaches
- Decision-making frameworks
- Learning note-taking systems
- Goal-setting patterns
## 📊 Analysis Options
When you run `/analyze-skills`, you'll choose from:
- **Option A**: Analysis report only (insights and recommendations)
- **Option B**: Complete implementation package (ready-to-use skills)
- **Option C**: Incremental implementation (top 3-5 skills)
- **Option D**: Custom specification (your defined requirements)
## 🔒 Privacy & Security
- **Local processing**: All analysis happens on your machine
- **No data upload**: Your conversations never leave your system
- **Anonymized output**: Generated skills remove personal information
- **Git protection**: Export files are automatically ignored by version control
## 🚀 Expected Results
After analysis, you'll get:
### Analysis Reports (`reports/timestamp/`)
- **Comprehensive analysis** with pattern evidence
- **Implementation guide** with deployment roadmap
- **Processing log** for incremental future runs
### Generated Skills (`generated-skills/skill-name/`)
- **SKILL.md** - Main skill with YAML frontmatter
- **reference.md** - Detailed methodology
- **examples.md** - Usage examples
- **templates/** - Reusable output templates
## ❓ Common Questions
**Q: How many conversations do I need?**
A: Minimum 20-30 for basic analysis, 50+ for meaningful patterns, 100+ for comprehensive insights.
**Q: Are Claude Code conversations included in exports?**
A: No. Claude exports from claude.ai only include web interface conversations. Claude Code conversations are stored separately and are not included in data exports. If you primarily use Claude Code, consider using ChatGPT exports or the web-based workflow-pattern-analyzer skill instead.
**Q: Can I analyze both Claude and ChatGPT together?**
A: Yes! The plugin performs smart cross-platform deduplication and creates unified skills.
**Q: What if I don't have many conversations?**
A: Start with what you have. The plugin supports incremental processing, so you can re-run analysis as you accumulate more conversations.
**Q: How long does analysis take?**
A: Typically 2-5 minutes for 100 conversations, longer for larger datasets or complex patterns.
## 🛠️ Next Steps
1. **Set up your directories**: Create the folder structure above (or let `/extract-exports` do it automatically)
2. **Export your data**: Follow the export guides for your platforms
3. **Organize your exports**: Run `/extract-exports` to automatically extract and organize ZIP files, or manually place JSON files in the appropriate directories
4. **Run the analysis**: Use `/analyze-skills` when ready
5. **Implement skills**: Start with the highest-impact recommendations
## 💡 Pro Tips
- **Export regularly**: Update your analysis monthly as you accumulate more conversations
- **Start small**: Begin with Option C (incremental) to test with your top skills
- **Customize skills**: Edit generated skills to match your specific needs
- **Share patterns**: Generated skills are great for team standardization
Ready to get started? Let me know if you'd like help creating the directory structure or have questions about the export process!

216
commands/skills-troubleshoot.md Normal file
View File

@@ -0,0 +1,216 @@
---
description: Troubleshoot common issues with skills analysis setup and execution
---
# Skills Analysis Troubleshooting
I'll help you diagnose and fix common issues with the Claude Skills Analyzer.
## 🔍 Quick Diagnostics
Let me check your current setup and identify any issues:
### Directory Structure Check
First, let me verify your project has the required directories:
```
Expected structure:
├── data-exports/
│ ├── claude/ # Claude export files
│ └── chatgpt/ # ChatGPT export files
├── reports/ # Analysis outputs
└── generated-skills/ # Generated skill packages
```
### Data Files Check
Looking for these required files:
**Claude exports** (`data-exports/claude/`):
- [ ] `conversations.json` - Required
- [ ] `projects.json` - Optional but helpful
- [ ] `users.json` - Optional
**ChatGPT exports** (`data-exports/chatgpt/`):
- [ ] `conversations.json` - Required
- [ ] `user.json` - Optional
- [ ] `shared_conversations.json` - Optional
## 🚨 Common Issues & Solutions
### Issue: "No conversation files detected"
**Causes:**
- Files in wrong directories
- Incorrect file names
- Empty or corrupted JSON files
**Solutions:**
1. **Check file locations**: Ensure JSON files are in correct `data-exports/` subdirectories
2. **Verify file names**: Must match exactly (case-sensitive)
3. **Validate JSON**: Open files in text editor to check they're valid JSON
4. **Check file sizes**: Empty files (0 bytes) won't work
### Issue: "Analysis produces no patterns"
**Causes:**
- Too few conversations (need 20+ minimum)
- Conversations too short or simple
- No recurring patterns in usage
**Solutions:**
1. **Accumulate more data**: Export again after more AI usage
2. **Lower thresholds**: Adjust frequency requirements in analysis
3. **Check conversation quality**: Need substantial back-and-forth interactions
4. **Try different timeframes**: Use older exports if available
### Issue: "Plugin command not found"
**Causes:**
- Plugin not properly installed
- Claude Code needs restart
- Marketplace not added correctly
**Solutions:**
1. **Verify installation**:
```shell
/plugin list
```
2. **Restart Claude Code**: Close and reopen
3. **Reinstall plugin**:
```shell
/plugin uninstall claude-skills-analyzer@hirefrank
/plugin install claude-skills-analyzer@hirefrank
```
### Issue: "JSON parsing errors"
**Causes:**
- Incomplete export downloads
- File corruption during transfer
- Unsupported export format versions
**Solutions:**
1. **Re-download exports**: Get fresh copies from AI platforms
2. **Check file integrity**: Verify files open properly in text editor
3. **Try smaller batches**: Export smaller date ranges if available
### Issue: "Skills generation fails"
**Causes:**
- Insufficient write permissions
- Conflicting files in output directories
- Pattern analysis errors
**Solutions:**
1. **Check permissions**: Ensure you can write to project directory
2. **Clear output directories**: Remove old `reports/` and `generated-skills/` content
3. **Try incremental analysis**: Start with Option A (report only)
## 🔧 Manual Diagnostics
### Check Your Export Files
```shell
# Navigate to your data directory
cd data-exports
# Check file sizes (should be >1KB)
ls -la claude/
ls -la chatgpt/
# Preview file contents (first few lines)
head -5 claude/conversations.json
head -5 chatgpt/conversations.json
```
### Validate JSON Structure
```shell
# Check if files are valid JSON (on systems with jq)
jq . claude/conversations.json > /dev/null && echo "Claude JSON valid"
jq . chatgpt/conversations.json > /dev/null && echo "ChatGPT JSON valid"
```
## 📊 Data Requirements
### Minimum Requirements
- **20+ conversations** total across platforms
- **Average 3+ exchanges** per conversation
- **Variety of topics/tasks** represented
- **JSON files >1KB** in size
### Optimal Requirements
- **50+ conversations** for meaningful patterns
- **Mix of short and long conversations**
- **Regular usage patterns** over time
- **Both platforms** represented (if you use both)
## 🎯 Quick Fixes
### Create Missing Directories
```shell
mkdir -p data-exports/claude data-exports/chatgpt reports generated-skills
```
### Test Plugin Installation
```shell
# Check if plugin is available
/help | grep analyze-skills
# List installed plugins
/plugin list | grep claude-skills-analyzer
```
### Reset and Retry
```shell
# Clear any partial outputs
rm -rf reports/* generated-skills/*
# Re-run analysis with fresh start
/analyze-skills
```
## 📞 Getting Additional Help
### For Setup Issues
- Review `/skills-setup` for complete setup guide
- Check plugin README at `plugins/claude-skills-analyzer/README.md`
- Verify you have the latest plugin version
### For Analysis Issues
- Try Option A (Analysis Report Only) first
- Review conversation export quality
- Consider smaller dataset for initial testing
### For Technical Issues
- Check [GitHub Issues](https://github.com/hirefrank/hirefrank-marketplace/issues)
- Report bugs with error messages and setup details
- Join discussions for community support
## 💡 Pro Troubleshooting Tips
1. **Start small**: Test with a small, known-good dataset first
2. **Check permissions**: Ensure you can read/write in the project directory
3. **Update regularly**: Keep the plugin updated to latest version
4. **Document patterns**: Note what types of conversations work best
5. **Incremental approach**: Use existing analysis logs for efficiency
## 🔄 Still Having Issues?
If problems persist:
1. **Gather diagnostics**:
- Plugin version (`/plugin list`)
- Error messages (exact text)
- File sizes and locations
- Claude Code version
2. **Try minimal test**:
- Create new directory
- Add just 1-2 export files
- Run analysis with Option A
3. **Get support**:
- Open GitHub issue with full details
- Include anonymized error logs
- Describe expected vs actual behavior
Let me know what specific issue you're experiencing and I'll provide targeted help!

77
plugin.lock.json Normal file
View File

@@ -0,0 +1,77 @@
{
"$schema": "internal://schemas/plugin.lock.v1.json",
"pluginId": "gh:hirefrank/hirefrank-marketplace:plugins/claude-skills-analyzer",
"normalized": {
"repo": null,
"ref": "refs/tags/v20251128.0",
"commit": "8888ff4525e6dce2c17131cb4e09428868792c02",
"treeHash": "ca7cb6a900879c91db993e512bc4ffedadcfdbc182a2ac0c542e7bcd2bf49b09",
"generatedAt": "2025-11-28T10:17:28.506228Z",
"toolVersion": "publish_plugins.py@0.2.0"
},
"origin": {
"remote": "git@github.com:zhongweili/42plugin-data.git",
"branch": "master",
"commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
"repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
},
"manifest": {
"name": "claude-skills-analyzer",
"description": "Analyze AI conversation exports to generate reusable Custom Skills",
"version": "1.2.0"
},
"content": {
"files": [
{
"path": "README.md",
"sha256": "cb3ce3bd85a622ea10972c1f4dd501d9557a38f78ead483e0599019ce3aa4b2d"
},
{
"path": ".claude-plugin/plugin.json",
"sha256": "ee9d56c3b0bb8667f2607e3686925a8caebf963cd6b641b05cc57c614324f7df"
},
{
"path": "commands/extract-exports.md",
"sha256": "e9e8c9e641c918170af566cf47c884e9bfdb48b0ca31f0ef03e588c5ad074d58"
},
{
"path": "commands/skills-troubleshoot.md",
"sha256": "5f34a28ec3348fe10db2a62ff290cfe07d997fff2db5c53ffd9c2d13138e3bc1"
},
{
"path": "commands/analyze-skills.md",
"sha256": "4f3156fe709dbae3af1d4d0a8d10faaac69c5780b5a064303e1ffa205d6c53b7"
},
{
"path": "commands/skills-setup.md",
"sha256": "49f7519bd03aad3a1d1ef24b1501d4228e25ab2bdea99a5b5321b3a4a6179273"
},
{
"path": "skills/conversation-analyzer/SKILL.md",
"sha256": "6feb00c03b6d23e2294603fb91a2cd3706e9621be6756b4a7fd0d5531df6f29e"
},
{
"path": "skills/workflow-pattern-analyzer/README.md",
"sha256": "e95029d6d55b1ada2341ada9596563802ddc9b84e5b16023b3d080c0f5b50684"
},
{
"path": "skills/workflow-pattern-analyzer/SKILL.md",
"sha256": "1eaa87c1732d398f0b2d0ff02290821ab9ea87761f531a91cfc140aa9a3c1878"
},
{
"path": "skills/workflow-pattern-analyzer-web/README.md",
"sha256": "b65cb18a049c225223e499a2afa5568c0ef977b8eb6af9f5dde3fbd9fe182184"
},
{
"path": "skills/workflow-pattern-analyzer-web/SKILL.md",
"sha256": "164808cd98d658c4b2fabcc69ba77f1a0a28015586e885a6ab321e69af7a5cdb"
}
],
"dirSha256": "ca7cb6a900879c91db993e512bc4ffedadcfdbc182a2ac0c542e7bcd2bf49b09"
},
"security": {
"scannedAt": null,
"scannerVersion": null,
"flags": []
}
}

84
skills/conversation-analyzer/SKILL.md Normal file
View File

@@ -0,0 +1,84 @@
---
name: conversation-analyzer
description: Analyzes AI conversation exports to identify recurring patterns and generate custom Claude Skills. Use when analyzing conversation data, identifying workflow patterns, or creating reusable AI skills from usage history.
---
# Conversation Analyzer
## Instructions
This skill provides specialized capability for analyzing AI conversation exports (Claude, ChatGPT) to identify recurring patterns and generate reusable Custom Skills.
1. **Data Processing & Pattern Discovery**
- Auto-detect platform format (Claude vs ChatGPT exports)
- Parse conversation histories, project data, and user information
- Extract expertise indicators and usage patterns
- Categorize patterns by domain (coding, writing, business, analysis)
- Identify task types (creation, transformation, analysis, troubleshooting)
2. **Frequency & Temporal Analysis**
- Count pattern occurrences across conversation history
- Calculate temporal distribution and frequency trends
- Cross-reference with project data for validation
- Assess business impact and time investment patterns
3. **Skill-Worthiness Evaluation** (0-10 scale scoring):
- **Frequency**: How often does this task occur?
- **Consistency**: How similar are requirements each time?
- **Complexity**: Would a skill meaningfully improve quality?
- **Time savings**: How much effort would a skill save?
- **Error reduction**: Common pitfalls a skill could prevent?
4. **Cross-Platform Deduplication** (when both platforms present):
- Detect semantic similarity across platforms
- Identify cross-platform workflows vs genuine duplicates
- Merge evidence while preserving platform preferences
- Recalculate frequencies after deduplication
5. **Skill Generation & Optimization**
- Create prioritization matrix (frequency vs. value/impact)
- Resolve overlaps and optimize skill boundaries
- Generate complete skill packages with YAML frontmatter
- Provide implementation roadmap and testing guidance
## Quality Standards
- Focus on patterns with >5% conversation frequency
- Require 70%+ consistency across pattern instances
- Target >30 min/week time savings potential
- Maximum 12 skills total (recommend prioritizing top 5-8)
- Platform-agnostic skill design
- Evidence-based recommendations with conversation excerpts
## Examples
### Analyzing Claude Export
**User Request**: "Analyze my Claude conversations to find skill opportunities"
**Response**:
```
I'll analyze your Claude conversation export to identify recurring patterns. Let me:
1. Parse your conversations.json and projects.json files
2. Identify frequent task patterns across your usage
3. Evaluate each pattern for skill-worthiness
4. Generate prioritized recommendations for Custom Skills
Please ensure your export files are in data-exports/claude/ directory.
```
### Cross-Platform Analysis
**User Request**: "I have both Claude and ChatGPT exports - analyze them together"
**Response**:
```
I'll perform cross-platform analysis to identify your workflow patterns:
1. Process both Claude and ChatGPT conversation data
2. Detect and handle cross-platform duplicates
3. Identify platform preferences for different task types
4. Create unified skills that work across AI platforms
5. Provide platform-agnostic skill recommendations
This will give you the most accurate picture of your AI usage patterns.
```

155
skills/workflow-pattern-analyzer-web/README.md Normal file
View File

@@ -0,0 +1,155 @@
# Workflow Pattern Analyzer (Web Compatible)
**Single-file, web-compatible version** of the workflow pattern analyzer skill for use in Claude.ai web interface.
## Purpose
This is a **self-contained version** of the workflow-pattern-analyzer skill designed specifically for platforms that require single-file uploads:
- ✅ **Claude.ai web interface** (upload as zip)
- ✅ **Claude API** (single skill upload)
- ✅ **Claude Code** (works but modular version is preferred)
## Differences from Modular Version
| Feature | Modular Version | Web-Compatible Version |
|---------|----------------|------------------------|
| **File structure** | References `../../shared/analysis-methodology.md` | Complete methodology embedded |
| **Maintenance** | Shared methodology, no duplication | Self-contained, fully duplicated |
| **Platform support** | Claude Code only | All platforms |
| **File size** | Smaller (references shared files) | Larger (includes everything) |
| **Updates** | Update shared file once | Must update each skill individually |
## Usage
### In Claude.ai Web Interface
1. Download `SKILL.md` from this directory
2. Create a zip file containing just `SKILL.md`
3. Upload via Settings > Features > Custom Skills
4. Use with phrases like:
- "Analyze my conversation patterns"
- "What workflows should I automate?"
- "Find skill opportunities in my recent chats"
### In Claude API
```python
# Upload the skill
with open('SKILL.md', 'r') as f:
skill_content = f.read()
response = client.skills.create(
name="workflow-pattern-analyzer-web",
content=skill_content
)
```
### In Claude Code
Place `SKILL.md` in your skills directory, though the modular version is recommended for Claude Code environments.
## Full Feature Parity
This web-compatible version includes **100% of the functionality** from the modular version:
### ✅ Complete Analysis Framework
- 7-phase methodology (data collection → skill generation)
- 5-dimensional scoring system (0-50 composite scale)
- Pattern discovery across 4 detection methods
- Statistical validation with significance thresholds
### ✅ Full Output Capabilities
- Detailed analysis reports with evidence
- Prioritization matrix (frequency vs impact)
- Complete skill package generation
- Interactive follow-up options
### ✅ Quality Standards
- Pattern validation requirements
- Skill consolidation rules
- Anti-patterns guidance
- Progressive disclosure strategy
### ✅ Examples & Usage Patterns
- Quick scan (30 conversations)
- Standard analysis (50-75 conversations)
- Deep dive (100+ conversations)
- Targeted domain searches
## Comparison with Export-Based Analysis
| Feature | Export Analysis (`/analyze-skills`) | Tool-Based Analysis (this skill) |
|---------|-------------------------------------|----------------------------------|
| **Platform** | Claude Code only | All platforms (web + CLI) |
| **Data source** | JSON export files | `recent_chats` + `conversation_search` |
| **History scope** | Complete history | Accessible recent history |
| **Cross-platform** | Claude + ChatGPT | Claude only |
| **Setup required** | Export files, directory structure | None |
| **Analysis depth** | Comprehensive (100+ conversations) | Extensive (within tool limits) |
| **Best for** | Historical analysis, large datasets | Quick insights, web users |
## When to Use This Version
**✅ Use this web-compatible version when:**
- Working in Claude.ai web interface
- Want zero-setup analysis
- Need quick pattern identification
- Prefer single-file skills
- Using Claude API with skill uploads
**🔧 Use the modular version when:**
- Working in Claude Code
- Want maintainable architecture
- Building multiple related skills
- Prefer shared methodology approach
## Technical Implementation
This version embeds the complete shared methodology directly in the SKILL.md file:
```markdown
---
name: workflow-pattern-analyzer-web
description: [Complete trigger description]
---
# Workflow Pattern Analyzer (Web Compatible)
## Instructions
[Complete 7-phase analysis framework]
### Phase 1: Data Collection Strategy
[Full methodology embedded]
### Phase 2: Pattern Discovery & Classification
[All 4 detection methods included]
### Phase 3-7: [Complete framework]
[No external references - everything included]
```
**File size**: ~15KB (vs ~3KB for modular version)
**Dependencies**: None (vs modular version's shared file dependency)
**Compatibility**: Universal (vs Claude Code only)
## Maintenance Notes
When updating methodology:
1. ✅ Update `shared/analysis-methodology.md` (affects modular version)
2. ⚠️ **Also update this file** (web-compatible version won't auto-sync)
Consider this trade-off between maintainability and compatibility when choosing which version to use.
## Installation & Testing
1. **Download**: Get `SKILL.md` from this directory
2. **Verify**: Check YAML frontmatter is valid
3. **Test**: Upload to your preferred platform
4. **Validate**: Try with "Analyze my conversation patterns"
The skill will automatically detect analysis scope and provide depth options (quick scan, standard analysis, deep dive, targeted search).
---
**Built for universal compatibility while maintaining full analytical rigor**

575
skills/workflow-pattern-analyzer-web/SKILL.md Normal file
View File

@@ -0,0 +1,575 @@
---
name: workflow-pattern-analyzer-web
description: Analyzes recent conversation history using chat tools to identify recurring workflow patterns and generate Custom Skills recommendations with statistical rigor. Use when users request workflow analysis, pattern identification, skill generation suggestions, or automation opportunities based on their AI usage patterns without requiring conversation exports.
---
# Workflow Pattern Analyzer (Web Compatible)
## Instructions
This skill provides comprehensive conversation pattern analysis using Claude's native chat history tools (`recent_chats` and `conversation_search`) to identify skill-worthy automation opportunities with statistical rigor.
**Core Capabilities:**
- Web interface compatible (no exports required)
- Statistical pattern validation and scoring
- Frequency analysis and temporal tracking
- Evidence-based skill recommendations
- Complete skill package generation
**Compatible with:** Claude.ai web interface, Claude Code, API
**How Analysis Works:**
- **No scripts or Python files**: This is a pure prompt-based analysis using Claude's native capabilities
- **Full content analysis**: Examines complete conversation content, messages, and patterns (not just titles or names)
- **Thread names**: Renaming conversations has minimal impact - analysis focuses on actual message content and patterns
- **Domain discovery**: Categories emerge from your actual usage data, not forced into predefined buckets
- **Data-driven approach**: Identifies YOUR specific patterns (recipes, image prompting, game design, etc.) rather than assuming business/coding focus
## Analysis Framework
### Phase 1: Data Collection Strategy
**Determine Analysis Scope:**
Ask user: "How deep should I analyze your conversation history?"
**Options:**
- **Quick Scan** (20-30 conversations, ~2-3 min): Recent patterns and immediate opportunities
- **Standard Analysis** (50-75 conversations, ~5-7 min): Comprehensive pattern detection
- **Deep Dive** (100+ conversations, ~10-15 min): Full workflow mapping with temporal trends
- **Targeted Search** (variable): Focus on specific topics or time periods
**Data Collection Process:**
1. **Broad Sampling**: Use `recent_chats(n=30)` multiple times with varied parameters to get diverse coverage
2. **Temporal Distribution**: Sample conversations across different time periods (recent, 1 week ago, 1 month ago)
3. **Topic Exploration**: Use `conversation_search` for domains mentioned by user or detected in initial sampling
4. **Depth vs Breadth**: Balance comprehensive coverage with processing efficiency
### Phase 2: Pattern Discovery & Classification
**Extract patterns using these detection methods:**
#### A. Explicit Pattern Markers
- **Repeated phrasing**: "format this as...", "make it more...", "apply X style"
- **Consistent request structures**: "create a [X] that does [Y]"
- **Recurring formatting instructions**: tables, bullet lists, specific structures
- **Tone/voice adjustments**: "more casual", "add enthusiasm", "formal version"
#### B. Implicit Workflow Patterns
- **Multi-turn conversation structures**: Same workflow across different topics
- **Iterative refinement sequences**: Request → feedback → revision cycles
- **Context re-explanation**: Same background info provided repeatedly
- **Problem-solving approaches**: Consistent debugging/analysis methodologies
#### C. Domain Discovery (Data-Driven)
- **Let domains emerge from the data** - Do NOT pre-categorize into standard domains
- **Topic frequency analysis**: Extract actual subject matter from conversations
- Examples of specialized domains: recipe transcription, cannabis strains, image prompting, game design, book summaries
- Examples of traditional domains: coding, business strategy, creative writing, data analysis, technical writing
- **Task type patterns**: Identify the action types that appear (creation, transformation, analysis, troubleshooting, curation, etc.)
- **Niche specialization detection**: Look specifically for narrow, specialized topics with high engagement
- **Cross-domain workflows**: Patterns that span multiple topics
- **Domain diversity scoring**: Reward finding 8-15 distinct domains vs. forcing into 3-4 buckets
**CRITICAL**: Avoid fitting patterns into predefined categories. Each user's conversation history will have unique domains based on their actual usage.
**Terminal Output - Domain Diversity Visualization:**
After completing pattern discovery, display an ASCII chart showing domain distribution:
```
📊 Domain Distribution Analysis
Business & Strategy ████████████░░░░░░░░ 12 patterns (32%)
Creative & Writing ██████████░░░░░░░░░░ 10 patterns (27%)
Image Prompting ████████░░░░░░░░░░░░ 8 patterns (22%)
Learning & Education ████░░░░░░░░░░░░░░░░ 4 patterns (11%)
Recipe & Cooking ██░░░░░░░░░░░░░░░░░░ 2 patterns (5%)
Gaming & Design █░░░░░░░░░░░░░░░░░░░ 1 pattern (3%)
✅ Domain Diversity: 6 distinct topic areas detected
✅ No predefined categorization - domains emerged from your data
```
This validates data-driven discovery of diverse patterns.
#### D. Niche & Specialized Pattern Detection
**Explicitly search for underrepresented domains:**
- **Hobbyist domains**: Recipes, cocktails, cannabis, gardening, gaming, fitness, travel planning
- **Creative domains**: Story writing, worldbuilding, character development, art direction, music composition
- **Prompt engineering**: Image generation (Midjourney, Stable Diffusion, DALL-E), video generation, AI art workflows
- **Learning & education**: Book summaries, concept explanations, study guides, teaching materials
- **Personal organization**: Resume writing, cover letters, personal branding, goal setting
- **Entertainment & media**: Game design, narrative design, content creation, video scripts
- **Wellness & lifestyle**: Meal planning, workout routines, meditation guides, habit tracking
**Detection strategy:**
- Look for concentrated clusters of 5+ conversations on the same narrow topic
- Identify specialized vocabulary/jargon (strain names, recipe terms, art styles, game mechanics)
- Find recurring templates/formats specific to that domain
- Don't dismiss low-frequency patterns if they show high consistency and complexity
- Pay special attention to patterns that appear in conversation titles or search results
- Consider that niche patterns may have lower frequency but higher value due to specialization
**Quality indicators for niche patterns:**
- Consistent terminology and domain-specific language
- Recurring output formats or structures
- User demonstrates growing expertise over time
- High engagement (longer conversations, multiple refinements)
- Clear workflow or methodology emerging
#### E. Temporal Patterns
- **Weekly/monthly recurring tasks**: Reports, summaries, check-ins
- **Event-driven patterns**: Meeting prep, post-mortems, launches
- **Seasonal trends**: Quarterly reviews, annual planning
- **Frequency trends**: Increasing/stable/decreasing over time
### Phase 3: Frequency Analysis & Validation
For each identified pattern, calculate:
#### Occurrence Metrics
- **Absolute frequency**: Total instances found in analyzed conversations
- **Relative frequency**: Percentage of conversations containing pattern
- **Temporal distribution**: First occurrence, most recent, clustering
- **Consistency score**: Similarity across pattern instances (0-100%)
#### Statistical Validation
- **Significance threshold**: Pattern must appear in >5% of conversations OR >3 absolute instances
- **Consistency requirement**: 70%+ similarity in requirements/structure across instances
- **Sample size consideration**: Adjust thresholds based on total conversations analyzed
#### Evidence Collection
- Extract 2-4 representative conversation excerpts per pattern
- Note variation types (what changes vs what stays constant)
- Document user refinement patterns (common adjustments made)
### Phase 4: Skill-Worthiness Scoring (0-10 Scale)
**Use extended reasoning to evaluate each pattern across 5 dimensions:**
#### 1. Frequency Score (0-10)
- **10**: Daily usage (20+ instances or >25% of conversations)
- **8-9**: Multiple times per week (10-20 instances or 15-25%)
- **6-7**: Weekly usage (5-9 instances or 8-15%)
- **4-5**: Bi-weekly to monthly (3-4 instances or 5-8%)
- **2-3**: Monthly or less (2 instances or 3-5%)
- **0-1**: One-off or <3% of conversations
#### 2. Consistency Score (0-10)
- **10**: Identical requirements every time (90-100% similarity)
- **8-9**: Highly consistent with minor variations (75-90%)
- **6-7**: Core structure consistent, details vary (60-75%)
- **4-5**: Recognizable pattern, significant variation (45-60%)
- **2-3**: Loosely related, different each time (30-45%)
- **0-1**: No discernible consistency (<30%)
#### 3. Complexity Score (0-10)
- **10**: Multi-step workflow with decision points, high cognitive load
- **8-9**: Complex methodology requiring expertise/frameworks
- **6-7**: Moderate complexity with structured approach
- **4-5**: Straightforward process with some nuance
- **2-3**: Simple task with minimal steps
- **0-1**: Trivial one-step operation
#### 4. Time Savings Score (0-10)
- **10**: >60 min saved per use (or >10 hours/month total)
- **8-9**: 30-60 min per use (or 5-10 hours/month)
- **6-7**: 15-30 min per use (or 2-5 hours/month)
- **4-5**: 5-15 min per use (or 1-2 hours/month)
- **2-3**: 2-5 min per use (or 30-60 min/month)
- **0-1**: <2 min per use (<30 min/month)
#### 5. Error Reduction Score (0-10)
- **10**: Critical tasks with major error consequences
- **8-9**: Common mistakes significantly impact quality
- **6-7**: Regular pitfalls that skill could prevent
- **4-5**: Occasional errors, modest quality improvement
- **2-3**: Minor inconsistencies, small quality gains
- **0-1**: No error patterns, quality already consistent
#### Composite Scoring
- **Total Score**: Sum of 5 dimensions (0-50 scale)
- **Priority Classification**:
- **Critical** (40-50): Implement immediately
- **High** (30-39): Strong candidates for skill creation
- **Medium** (20-29): Consider for skill creation
- **Low** (10-19): Defer or handle with simple prompts
- **Not Viable** (0-9): Not worth skill automation
### Phase 5: Relationship Mapping & Consolidation
#### A. Overlap Detection
- Identify shared components across patterns
- Map overlapping functionality (>40% shared steps)
- Find hierarchical relationships (high-level task composed of sub-tasks)
- Detect sequential workflows (tasks that occur in sequence)
#### B. Consolidation Strategies
**Use extended reasoning to determine:**
- **Merge** (>60% overlap): Combine into single comprehensive skill
- **Separate with cross-reference** (30-60% overlap): Distinct skills with links
- **Hierarchical**: Main skill + specialized variants → parent/child structure
- **Modular**: Extract common elements → shared templates/references
#### C. Boundary Optimization
Each skill should have:
- **Clear purpose**: Single, well-defined use case
- **Distinct triggers**: Easy to know when to use vs other skills
- **Minimal overlap**: <30% shared functionality with other skills
- **Appropriate scope**: Not too broad (generic) or narrow (over-specialized)
### Phase 6: Prioritization Matrix
Generate 2D matrix visualization:
```
VALUE/IMPACT (High to Low)
│
HIGH │ 🔥 Quick Wins ⭐ Strategic
│ [High-priority [Complex but
│ automation] critical]
│
│ ──────────────────────────────
│
LOW │ 🔧 Automate ⏸️ Defer
│ [Nice-to-have [Not worth
│ efficiency] automating]
│
└────────────────────────────────
LOW FREQUENCY HIGH
```
**Classify each pattern:**
- **X-axis**: Frequency score (0-10)
- **Y-axis**: Average of Complexity, Time Savings, Error Reduction (0-10)
- **Size indicator**: Total composite score
- **Color coding**: Implementation difficulty
**Strategic Recommendations:**
1. **Top 3-5 Quick Wins**: Highest ROI (frequency × impact)
2. **Strategic Skills**: High impact even if lower frequency
3. **Quick Automations**: High frequency, simpler to implement
4. **Defer List**: Patterns not meeting skill-worthiness thresholds
### Phase 7: Skill Package Generation
For each approved skill, create:
#### A. Skill Specification Document
```markdown
## [Skill Name]
**Pattern Evidence:**
- Frequency: [X instances in Y conversations (Z%)]
- Consistency: [X/10 score]
- Time savings: [X hours/month]
**Composite Score: [X/50]**
- Frequency: [X/10]
- Consistency: [X/10]
- Complexity: [X/10]
- Time Savings: [X/10]
- Error Reduction: [X/10]
**Example Conversations:**
1. [Date]: [Brief excerpt showing pattern]
2. [Date]: [Brief excerpt showing pattern]
3. [Date]: [Brief excerpt showing pattern]
**Pattern Components:**
- **Consistent elements**: [What stays the same]
- **Variable elements**: [What changes per instance]
- **Common refinements**: [Typical adjustments user makes]
**Proposed Skill Structure:**
SKILL.md sections:
1. Overview & trigger conditions
2. [Main workflow methodology]
3. Quality standards
4. Examples
Supporting files needed:
- reference.md: [Detailed framework/methodology]
- templates/: [Reusable output templates]
- examples.md: [Additional use cases]
```
#### B. Complete SKILL.md File
Generate production-ready skill with:
- Proper YAML frontmatter (name, description with triggers)
- Clear instructions based on pattern analysis
- Evidence-based examples from actual conversations
- Quality standards derived from user refinement patterns
- Progressive disclosure (link to references for detail)
## Output Formats
After analysis completion, present:
### Summary Report
```markdown
# Workflow Pattern Analysis Report
**Analysis Date**: [Timestamp]
**Conversations Analyzed**: [X conversations across Y time period]
**Patterns Identified**: [X patterns]
**Skills Recommended**: [Y skills]
## 📊 Skill Prioritization Matrix
```mermaid
%%{init: {'theme':'base'}}%%
quadrantChart
title Skill Prioritization: Frequency vs Impact
x-axis Low Frequency --> High Frequency
y-axis Low Impact --> High Impact
quadrant-1 Strategic
quadrant-2 Quick Wins
quadrant-3 Defer
quadrant-4 Automate
[Skill Name 1]: [freq_score/10, impact_score/10]
[Skill Name 2]: [freq_score/10, impact_score/10]
[Skill Name 3]: [freq_score/10, impact_score/10]
```
\```
**Legend:**
- **Quick Wins** (top-right): High frequency, high impact - implement first
- **Strategic** (top-left): Lower frequency but high value - critical capabilities
- **Automate** (bottom-right): High frequency, simpler - nice efficiency gains
- **Defer** (bottom-left): Low priority - consider simple prompts instead
## 🔥 HIGH-PRIORITY OPPORTUNITIES
### 1. [Skill Name]
**Score: [X/50]** (Frequency: X/10, Consistency: X/10, Complexity: X/10, Time: X/10, Error: X/10)
**Pattern Description**: [What you do repeatedly]
**Evidence**:
- Found in [X] conversations ([Y%] of analyzed sample)
- First seen: [Date], Most recent: [Date]
- Average time per instance: [X minutes]
**Example Occurrences**:
1. [Date]: "[Brief excerpt]"
2. [Date]: "[Brief excerpt]"
**Proposed Skill**: "[One-line skill description]"
**Time Savings**: [X hours/month]
---
[Repeat for top 5-8 patterns]
## 💡 MODERATE OPPORTUNITIES
[Briefer summaries of medium-priority patterns]
## 🎯 QUICK AUTOMATION CANDIDATES
[Simple, high-frequency patterns]
## ⏸️ DEFERRED PATTERNS
[Patterns that didn't meet skill-worthiness thresholds]
## 📊 ANALYSIS METADATA
- Total conversations: [X]
- Date range: [earliest] to [latest]
- Unique patterns identified: [X]
- Patterns validated: [Y]
- Cross-pattern overlaps: [Z]
- Recommended consolidations: [N]
```
### Interactive Follow-Up Options
```
What would you like to do next?
A. Generate complete SKILL.md files for [top 3-5 skills]
B. Deep dive into specific pattern: [skill name]
C. Expand analysis with more conversations
D. Focus on specific domain/topic area
E. Adjust scoring weights and recalculate priorities
```
## Quality Standards
### Pattern Validation Requirements
- **Minimum frequency**: 3 instances OR >5% of conversations
- **Consistency threshold**: 70% similarity across instances
- **Evidence requirement**: 2-3 conversation excerpts minimum
- **Time savings minimum**: >30 min/month cumulative
- **Statistical significance**: Validated against sample size
### Skill Recommendations
- **Maximum 8-10 skills**: Focus on highest ROI patterns
- **Clear differentiation**: Each skill has distinct purpose
- **Evidence-based design**: Skill structure reflects actual usage patterns
- **Practical focus**: Prioritize patterns with real time/quality impact
### Analysis Rigor
- **No generic patterns**: Avoid broad categories like "writing" or "analysis"
- **Domain diversity validated**: Patterns should span 6+ distinct topic areas (not just business/coding)
- **Niche specializations identified**: Don't dismiss specialized patterns as outliers
- **No artificial categorization**: Avoid forcing patterns into predefined domains (coding, writing, business, analysis)
- **Validated frequencies**: Ensure counts are accurate within sample
- **Temporal awareness**: Note if pattern is emerging, stable, or declining
- **User context**: Consider user's domain expertise and role
## Examples
### Example 1: Quick Scan Request
**User**: "Analyze my recent chats for automation opportunities"
**Claude**:
I'll perform a quick scan of your recent conversation history to identify skill opportunities.
[Uses recent_chats(n=30) multiple times]
📊 **Quick Scan Results** (30 conversations analyzed)
🔥 **TOP OPPORTUNITY**:
**"Email Response Composer"** - Score: 42/50
- Found in 9 conversations (30%)
- Pattern: You regularly ask me to draft professional emails with specific tone and structure requirements
- Time savings: ~90 min/month (10 min per email × 9 emails)
- Evidence: Consistent 3-paragraph structure with greeting, main content, action items
Want me to:
A. Generate complete skill package for this
B. Continue analysis for more patterns (expand to 50-75 conversations)
C. Focus on other domains
### Example 2: Targeted Domain Analysis
**User**: "Find patterns in how I use you for coding tasks"
**Claude**:
I'll analyze your coding-related conversations to identify workflow patterns.
[Uses conversation_search for coding terms + recent_chats filtering]
📊 **Coding Workflow Analysis** (18 relevant conversations)
🔥 **TOP PATTERNS**:
1. **"Code Review Checklist Generator"** - Score: 38/50
- Found in 7 code review discussions
- Pattern: You ask for language-specific review checklists before reviewing PRs
- Consistency: 85% (always includes security, performance, style sections)
2. **"API Documentation Humanizer"** - Score: 35/50
- Found in 5 documentation tasks
- Pattern: Converting technical API specs into developer-friendly guides
- Structure: Always includes quick start, common use cases, troubleshooting
Want me to build skills for these patterns?
### Example 3: Deep Dive Analysis
**User**: "Do a comprehensive analysis of my workflow over the last few months"
**Claude**:
I'll perform a deep analysis of your conversation history. This will take 10-15 minutes to ensure comprehensive coverage.
[Uses recent_chats extensively, conversation_search for discovered topics, temporal sampling]
📊 **Comprehensive Workflow Analysis**
- **Conversations analyzed**: 120
- **Date range**: [3 months]
- **Patterns identified**: 15
- **Skills recommended**: 6
🔥 **CRITICAL PRIORITY** (Score 40-50):
1. **"Weekly Status Report Generator"** - Score: 47/50
- Frequency: 12 instances (10% of conversations)
- Consistency: 95% - always same structure
- Evidence: Every Monday, you format updates in identical 5-section template
- Time savings: 240 min/month (20 min/week × 4 weeks × 3 months avg)
⭐ **HIGH PRIORITY** (Score 30-39):
2. **"Client Proposal Framework"** - Score: 36/50
3. **"Meeting Notes Structurer"** - Score: 34/50
4. **"Technical Concept Explainer"** - Score: 31/50
[Full analysis report with evidence, prioritization matrix, skill specifications]
**Recommended Implementation Path**:
1. Start with "Weekly Status Report Generator" (highest ROI)
2. Build "Client Proposal Framework" and "Meeting Notes Structurer" next (complementary workflows)
3. Evaluate remaining patterns after 2-4 weeks of usage
Generate complete skill packages now? [Y/N]
## Anti-Patterns to Avoid
**Don't recommend skills for:**
- **One-off variations**: Tasks that seem similar but are fundamentally different each time
- **Over-simplified tasks**: Things easier to just ask directly than invoke a skill
- **Better solved by tools**: When external apps/services do it better
- **Insufficient data**: Patterns with <3 instances or <5% frequency (unless strategic)
- **Generic categories**: Broad skills like "help with writing" or "analyze data"
**Red flags in patterns:**
- High frequency but no consistency (chaotic variation)
- High consistency but very low frequency (use a prompt template instead)
- Pattern is declining over time (user may have found better solution)
- Task requires real-time data or external authentication (needs MCP, not skill)
## When to Use This Skill
**✅ Use this skill when:**
- User requests analysis of their conversation patterns
- User wants to identify automation opportunities
- User asks what skills they should create
- User mentions repetitive tasks or workflows
- User wants evidence-based skill recommendations
- User is in web interface (can't use export-based analysis)
**❌ Don't use this skill when:**
- User has conversation export files available (use export-based plugin instead for more comprehensive analysis)
- User wants cross-platform ChatGPT + Claude analysis (requires exports)
- User has very few conversations (<10) making pattern detection unreliable
- User wants to build specific skill they already have in mind
- User is asking about existing skills or community skills
**⚡ Proactive Use:**
When you detect potential patterns during normal conversation, offer:
```
💭 Pattern detected: This is the [Xth] time you've asked me to [action].
Would you like me to analyze your conversation history for similar
patterns and recommend a Custom Skill? I can identify other automation
opportunities you might not have noticed.
[Yes, analyze] [Not now]
```
## Progressive Disclosure Strategy
**Keep main analysis concise by organizing information hierarchically:**
1. **Quick overview first**: Summary report with top 3-5 opportunities
2. **Details on demand**: Expand specific patterns when user shows interest
3. **Implementation when ready**: Generate complete skill packages only after user approval
4. **Iterative refinement**: Allow user to adjust scoring weights, focus areas, or analysis depth
**Load additional detail only when:**
- User requests deep dive on specific pattern
- Generating complete skill packages (not just analysis)
- User wants to understand scoring methodology in detail
- Building skills for complex domains requiring extensive examples

338
skills/workflow-pattern-analyzer/README.md Normal file
View File

@@ -0,0 +1,338 @@
# Workflow Pattern Analyzer
A web-compatible Custom Skill that brings export-quality conversation analysis to Claude's web interface. Analyzes recent conversation history using native chat tools to identify recurring patterns and generate evidence-based Custom Skills recommendations.
## Why This Skill?
**The Bridge Between Two Worlds:**
- **Export-based plugin** (`/analyze-skills`): Comprehensive but requires Claude Code + JSON exports
- **skill-idea-generator**: Web-friendly but lacks statistical rigor
- **workflow-pattern-analyzer**: Best of both - rigorous analysis accessible anywhere
## Key Features
### 🌐 Web Interface Compatible
- No conversation exports required
- Uses `recent_chats` and `conversation_search` tools
- Works in Claude.ai web interface or Claude Code
### 📊 Statistical Rigor
- **5-dimensional scoring framework** (0-10 scale each):
- Frequency analysis
- Consistency evaluation
- Complexity assessment
- Time savings calculation
- Error reduction potential
- **Composite scoring** (0-50 total) for prioritization
- **Statistical validation** with significance thresholds
### 🎯 Comprehensive Analysis
- Pattern discovery across multiple dimensions (explicit, implicit, domain, temporal)
- Relationship mapping and overlap detection
- Smart consolidation strategies
- Evidence-based recommendations with conversation excerpts
### 📦 Complete Outputs
- Detailed analysis reports with pattern evidence
- Prioritization matrix (frequency vs impact)
- Ready-to-use skill specifications
- Implementation roadmap
## When to Use
**Perfect for:**
- Web interface users who can't run `/analyze-skills`
- Quick pattern identification without export overhead
- Iterative skill discovery (start small, expand as needed)
- Users who want analysis rigor without technical setup
**Use the export plugin instead when:**
- You have Claude/ChatGPT conversation exports available
- You need cross-platform analysis (Claude + ChatGPT)
- You want comprehensive historical analysis (100+ conversations)
- You need incremental processing for large datasets
## Usage Guide
### Quick Start
Simply say:
- "Analyze my conversation patterns"
- "What workflows should I automate?"
- "Find skill opportunities in my recent chats"
- "Identify my most common requests"
### Analysis Depth Options
**1. Quick Scan (20-30 conversations, ~2-3 min)**
```
"Do a quick scan of my recent conversations"
```
Best for: Immediate insights, identifying top 1-2 patterns
**2. Standard Analysis (50-75 conversations, ~5-7 min)**
```
"Analyze my conversation history for patterns"
```
Best for: Comprehensive pattern detection, multiple skill opportunities
**3. Deep Dive (100+ conversations, ~10-15 min)**
```
"Do a comprehensive analysis of my workflows"
```
Best for: Full workflow mapping, temporal trends, strategic insights
**4. Targeted Search (variable)**
```
"Find patterns in my coding conversations"
"Analyze how I use you for writing tasks"
```
Best for: Domain-specific skill discovery
### Understanding the Output
**Score Interpretation:**
- **40-50 (Critical)**: Implement immediately - highest ROI
- **30-39 (High)**: Strong candidates for skill creation
- **20-29 (Medium)**: Consider for automation
- **10-19 (Low)**: Defer or use simple prompt templates
- **0-9 (Not Viable)**: Not worth skill automation
**Prioritization Matrix:**
```
VALUE/IMPACT
│
HIGH │ Quick Wins Strategic
│ [Immediate ROI] [Critical but complex]
│
LOW │ Automate Defer
│ [Nice-to-have] [Not worth it]
│
└─────────────────────────
LOW FREQUENCY HIGH
```
## Example Workflows
### Scenario 1: First-Time User
**User**: "I want to find out what I should automate"
**Skill Output**:
- Quick scan of 30 recent conversations
- Top 3 patterns identified with scores
- Evidence excerpts from actual conversations
- Recommendation for next steps (expand analysis or build skills)
### Scenario 2: Domain-Specific Analysis
**User**: "Find patterns in my coding work"
**Skill Output**:
- Targeted search of coding-related conversations
- Domain-specific patterns (code review, documentation, debugging)
- Frequency and consistency scores for each pattern
- Skill specifications tailored to development workflows
### Scenario 3: Comprehensive Workflow Audit
**User**: "Do a deep analysis of everything I do"
**Skill Output**:
- Analysis of 100+ conversations across 3 months
- Full pattern taxonomy (15+ patterns identified)
- Prioritization matrix with 6-8 skill recommendations
- Implementation roadmap with phased approach
- Complete skill packages ready to deploy
## What Makes This Different?
### vs. skill-idea-generator
| Feature | skill-idea-generator | workflow-pattern-analyzer |
|---------|---------------------|---------------------------|
| **Approach** | Conversational suggestions | Statistical analysis |
| **Scoring** | Qualitative | Quantitative (0-50 scale) |
| **Evidence** | Minimal | Detailed conversation excerpts |
| **Output** | Ideas + sketches | Complete skill packages |
| **Best for** | Inspiration, brainstorming | Evidence-based decisions |
### vs. Export-Based Plugin
| Feature | Export Plugin | workflow-pattern-analyzer |
|---------|---------------|---------------------------|
| **Platform** | Claude Code only | Web + Claude Code |
| **Setup** | Requires JSON exports | Zero setup |
| **Data Scope** | Complete history | Recent accessible history |
| **Cross-platform** | Claude + ChatGPT | Claude only |
| **Analysis Depth** | Comprehensive | Extensive (within tool limits) |
| **Best for** | Historical analysis | Quick insights |
## Quality Standards
**Pattern Validation:**
- Minimum 3 instances OR >5% of conversations
- 70%+ consistency across instances
- 2-3 conversation excerpts as evidence
- >30 min/month cumulative time savings
**Skill Recommendations:**
- Maximum 8-10 skills (focus on ROI)
- Clear differentiation between skills
- Evidence-based design from actual usage
- Practical focus on time/quality impact
**Analysis Rigor:**
- No generic patterns (avoid "writing", "analysis")
- Validated frequencies within sample
- Temporal awareness (emerging/stable/declining)
- User context consideration
## Advanced Usage
### Incremental Analysis
Start with quick scan, expand iteratively:
```
1. Quick scan (30 conversations) → Identify top pattern
2. Generate skill for top pattern → Deploy and test
3. Standard analysis (50-75 conversations) → Find next opportunities
4. Deep dive (100+ conversations) → Complete workflow mapping
```
### Adjusting Scoring Weights
Request custom prioritization:
```
"Analyze my patterns but prioritize time savings over frequency"
"Focus on high-complexity patterns even if they're less frequent"
```
### Domain-Focused Batches
Analyze specific workflow areas:
```
"Analyze my business communication patterns"
"Find patterns in my technical writing"
"What do I repeatedly do for project planning?"
```
## Technical Details
### Data Collection Strategy
- **Broad sampling**: Multiple `recent_chats` calls with varied parameters
- **Temporal distribution**: Sample across different time periods
- **Topic exploration**: `conversation_search` for discovered domains
- **Smart batching**: Balance coverage with efficiency
### Pattern Detection Methods
- **Explicit markers**: Repeated phrases, formatting instructions
- **Implicit workflows**: Multi-turn structures, refinement cycles
- **Domain clustering**: Topic frequency and task type analysis
- **Temporal patterns**: Recurring tasks, event-driven workflows
### Scoring Methodology
Each pattern scored 0-10 across 5 dimensions:
1. **Frequency**: Occurrence rate in conversation sample
2. **Consistency**: Similarity of requirements across instances
3. **Complexity**: Steps, decision points, cognitive load
4. **Time Savings**: Minutes saved per use × frequency
5. **Error Reduction**: Quality improvement potential
Composite score (0-50) determines priority classification.
## Limitations
**Compared to Export-Based Analysis:**
- ❌ Can't analyze ChatGPT conversations
- ❌ Limited to accessible recent history (API constraints)
- ❌ No cross-platform deduplication
- ❌ Can't process 1000+ conversation datasets efficiently
- ❌ No incremental processing log
**Inherent Constraints:**
- Requires 10+ conversations for basic analysis
- Pattern detection accuracy improves with more data
- Very old conversations may not be accessible via tools
- Analysis time scales with conversation depth
## Best Practices
**For Accurate Results:**
1. Run analysis after accumulating 30+ conversations
2. Use targeted searches for specific domains
3. Request deep dive for comprehensive insights
4. Provide feedback on detected patterns (accuracy validation)
**For Skill Generation:**
1. Start with top 3-5 highest-scoring patterns
2. Test generated skills before building more
3. Iterate based on actual usage
4. Re-run analysis monthly as patterns evolve
**For Efficiency:**
1. Use quick scans for regular check-ins
2. Save deep dive for quarterly workflow audits
3. Focus targeted searches on specific pain points
4. Combine analysis with skill building in same session
## Example Output Structure
```markdown
# Workflow Pattern Analysis Report
**Analysis Date**: 2025-01-23
**Conversations Analyzed**: 75 conversations (3 months)
**Patterns Identified**: 12 patterns
**Skills Recommended**: 5 skills
## 🔥 HIGH-PRIORITY OPPORTUNITIES
### 1. Email Response Composer
**Score: 42/50** (Frequency: 9/10, Consistency: 9/10, Complexity: 6/10, Time: 10/10, Error: 8/10)
**Pattern Description**: You regularly draft professional emails with specific tone and structure requirements
**Evidence**:
- Found in 14 conversations (18.7% of sample)
- First seen: Oct 15, Most recent: Jan 20
- Average time per instance: 15 minutes
- Total time savings potential: 210 min/month
**Example Occurrences**:
1. Jan 18: "Draft an email to client about project delay..."
2. Jan 12: "Write a professional response to vendor inquiry..."
3. Jan 5: "Compose email to team about Q1 objectives..."
**Proposed Skill**: Professional email composer with tone control, structure templates, and action item extraction
**Implementation Priority**: Immediate (Highest ROI)
---
[4 more patterns with detailed breakdowns]
## 💡 MODERATE OPPORTUNITIES
[3 patterns, briefer format]
## ⏸️ DEFERRED PATTERNS
[4 patterns that didn't meet thresholds]
## 📊 PRIORITIZATION MATRIX
[Visual classification of patterns]
## 🚀 IMPLEMENTATION ROADMAP
Week 1: Build Email Response Composer + Meeting Notes Structurer
Week 2: Test and refine initial skills
Week 3: Build Code Review Checklist + API Documentation Humanizer
Week 4: Evaluate usage, iterate, consider remaining patterns
```
## Contributing
Found a bug or have suggestions for improving the analysis methodology?
- Open an issue: [GitHub Issues](https://github.com/hirefrank/hirefrank-marketplace/issues)
- Discuss improvements: [GitHub Discussions](https://github.com/hirefrank/hirefrank-marketplace/discussions)
## License
MIT License - see repository root for details
---
**Built to bridge web accessibility with export-quality analysis rigor**

322
skills/workflow-pattern-analyzer/SKILL.md Normal file
View File

@@ -0,0 +1,322 @@
---
name: workflow-pattern-analyzer
description: Analyzes recent conversation history using chat tools to identify recurring workflow patterns and generate Custom Skills recommendations with statistical rigor. Use when users request workflow analysis, pattern identification, skill generation suggestions, or automation opportunities based on their AI usage patterns without requiring conversation exports.
---
# Workflow Pattern Analyzer
## Instructions
This skill provides comprehensive conversation pattern analysis using Claude's native chat history tools (`recent_chats` and `conversation_search`) to identify skill-worthy automation opportunities with the statistical rigor of export-based analysis.
**Core Capabilities:**
- Web interface compatible (no exports required)
- Statistical pattern validation and scoring
- Frequency analysis and temporal tracking
- Evidence-based skill recommendations
- Complete skill package generation
## Analysis Framework
This skill uses the **[shared analysis methodology](../../shared/analysis-methodology.md)** with tool-based data collection adaptations.
### Phase 1: Data Collection Strategy
**Determine Analysis Scope:**
Ask user: "How deep should I analyze your conversation history?"
**Options:**
- **Quick Scan** (20-30 conversations, ~2-3 min): Recent patterns and immediate opportunities
- **Standard Analysis** (50-75 conversations, ~5-7 min): Comprehensive pattern detection
- **Deep Dive** (100+ conversations, ~10-15 min): Full workflow mapping with temporal trends
- **Targeted Search** (variable): Focus on specific topics or time periods
**Data Collection Process:**
1. **Broad Sampling**: Use `recent_chats(n=30)` multiple times with varied parameters to get diverse coverage
2. **Temporal Distribution**: Sample conversations across different time periods (recent, 1 week ago, 1 month ago)
3. **Topic Exploration**: Use `conversation_search` for domains mentioned by user or detected in initial sampling
4. **Depth vs Breadth**: Balance comprehensive coverage with processing efficiency
### Phase 2-6: Core Analysis
Apply the **[shared analysis methodology](../../shared/analysis-methodology.md)** phases:
- **Phase 2**: Pattern Discovery & Classification (explicit, implicit, domain, temporal)
- **Phase 3**: Frequency Analysis & Validation (occurrence metrics, statistical validation)
- **Phase 4**: Skill-Worthiness Scoring (0-50 composite scale across 5 dimensions)
- **Phase 5**: Relationship Mapping & Consolidation (overlap detection, boundary optimization)
- **Phase 6**: Prioritization Matrix & Recommendations (frequency vs impact visualization)
See [shared methodology](../../shared/analysis-methodology.md) for complete scoring rubrics and quality standards.
### Phase 7: Skill Package Generation
**For each approved skill, create:**
**A. Skill Specification Document:**
```markdown
## [Skill Name]
**Pattern Evidence:**
- Frequency: [X instances in Y conversations (Z%)]
- Consistency: [X/10 score]
- Time savings: [X hours/month]
**Composite Score: [X/50]**
- Frequency: [X/10]
- Consistency: [X/10]
- Complexity: [X/10]
- Time Savings: [X/10]
- Error Reduction: [X/10]
**Example Conversations:**
1. [Date]: [Brief excerpt showing pattern]
2. [Date]: [Brief excerpt showing pattern]
3. [Date]: [Brief excerpt showing pattern]
**Pattern Components:**
- **Consistent elements**: [What stays the same]
- **Variable elements**: [What changes per instance]
- **Common refinements**: [Typical adjustments user makes]
**Proposed Skill Structure:**
SKILL.md sections:
1. Overview & trigger conditions
2. [Main workflow methodology]
3. Quality standards
4. Examples
Supporting files needed:
- reference.md: [Detailed framework/methodology]
- templates/: [Reusable output templates]
- examples.md: [Additional use cases]
```
**B. Complete SKILL.md File:**
Generate production-ready skill with:
- Proper YAML frontmatter (name, description with triggers)
- Clear instructions based on pattern analysis
- Evidence-based examples from actual conversations
- Quality standards derived from user refinement patterns
- Progressive disclosure (link to references for detail)
## Output Formats
**After analysis completion, present:**
### Summary Report
```markdown
# Workflow Pattern Analysis Report
**Analysis Date**: [Timestamp]
**Conversations Analyzed**: [X conversations across Y time period]
**Patterns Identified**: [X patterns]
**Skills Recommended**: [Y skills]
## 🔥 HIGH-PRIORITY OPPORTUNITIES
### 1. [Skill Name]
**Score: [X/50]** (Frequency: X/10, Consistency: X/10, Complexity: X/10, Time: X/10, Error: X/10)
**Pattern Description**: [What you do repeatedly]
**Evidence**:
- Found in [X] conversations ([Y%] of analyzed sample)
- First seen: [Date], Most recent: [Date]
- Average time per instance: [X minutes]
**Example Occurrences**:
1. [Date]: "[Brief excerpt]"
2. [Date]: "[Brief excerpt]"
**Proposed Skill**: "[One-line skill description]"
**Time Savings**: [X hours/month]
---
[Repeat for top 5-8 patterns]
## 💡 MODERATE OPPORTUNITIES
[Briefer summaries of medium-priority patterns]
## 🎯 QUICK AUTOMATION CANDIDATES
[Simple, high-frequency patterns]
## ⏸️ DEFERRED PATTERNS
[Patterns that didn't meet skill-worthiness thresholds]
## 📊 ANALYSIS METADATA
- Total conversations: [X]
- Date range: [earliest] to [latest]
- Unique patterns identified: [X]
- Patterns validated: [Y]
- Cross-pattern overlaps: [Z]
- Recommended consolidations: [N]
```
### Interactive Follow-Up Options
```
What would you like to do next?
A. Generate complete SKILL.md files for [top 3-5 skills]
B. Deep dive into specific pattern: [skill name]
C. Expand analysis with more conversations
D. Focus on specific domain/topic area
E. Adjust scoring weights and recalculate priorities
```
## Quality Standards
All quality standards follow the **[shared analysis methodology](../../shared/analysis-methodology.md#quality-standards)**:
- Pattern validation requirements (frequency, consistency, evidence)
- Skill consolidation rules (max 8-12 skills, clear boundaries)
- Skill package generation standards
- Anti-patterns to avoid
## Progressive Disclosure Strategy
**Keep this SKILL.md concise by referencing:**
- **Core methodology**: [shared/analysis-methodology.md](../../shared/analysis-methodology.md)
- **Detailed scoring rubrics**: See methodology Phase 4
- **Quality standards**: See methodology Quality Standards section
- **Anti-patterns**: See methodology Anti-Patterns section
**Load additional context only when:**
- User requests deep dive on specific pattern
- Generating complete skill packages (not just analysis)
- User wants to understand scoring methodology in detail
- Building reference materials for complex domains
## Examples
### Example 1: Quick Scan Request
**User**: "Analyze my recent chats for automation opportunities"
**Claude**:
I'll perform a quick scan of your recent conversation history to identify skill opportunities.
[Uses recent_chats(n=30) multiple times]
📊 **Quick Scan Results** (30 conversations analyzed)
🔥 **TOP OPPORTUNITY**:
**"Email Response Composer"** - Score: 42/50
- Found in 9 conversations (30%)
- Pattern: You regularly ask me to draft professional emails with specific tone and structure requirements
- Time savings: ~90 min/month (10 min per email × 9 emails)
- Evidence: Consistent 3-paragraph structure with greeting, main content, action items
Want me to:
A. Generate complete skill package for this
B. Continue analysis for more patterns (expand to 50-75 conversations)
C. Focus on other domains
### Example 2: Targeted Domain Analysis
**User**: "Find patterns in how I use you for coding tasks"
**Claude**:
I'll analyze your coding-related conversations to identify workflow patterns.
[Uses conversation_search for coding terms + recent_chats filtering]
📊 **Coding Workflow Analysis** (18 relevant conversations)
🔥 **TOP PATTERNS**:
1. **"Code Review Checklist Generator"** - Score: 38/50
- Found in 7 code review discussions
- Pattern: You ask for language-specific review checklists before reviewing PRs
- Consistency: 85% (always includes security, performance, style sections)
2. **"API Documentation Humanizer"** - Score: 35/50
- Found in 5 documentation tasks
- Pattern: Converting technical API specs into developer-friendly guides
- Structure: Always includes quick start, common use cases, troubleshooting
Want me to build skills for these patterns?
### Example 3: Deep Dive Analysis
**User**: "Do a comprehensive analysis of my workflow over the last few months"
**Claude**:
I'll perform a deep analysis of your conversation history. This will take 10-15 minutes to ensure comprehensive coverage.
[Uses recent_chats extensively, conversation_search for discovered topics, temporal sampling]
📊 **Comprehensive Workflow Analysis**
- **Conversations analyzed**: 120
- **Date range**: [3 months]
- **Patterns identified**: 15
- **Skills recommended**: 6
🔥 **CRITICAL PRIORITY** (Score 40-50):
1. **"Weekly Status Report Generator"** - Score: 47/50
- Frequency: 12 instances (10% of conversations)
- Consistency: 95% - always same structure
- Evidence: Every Monday, you format updates in identical 5-section template
- Time savings: 240 min/month (20 min/week × 4 weeks × 3 months avg)
⭐ **HIGH PRIORITY** (Score 30-39):
2. **"Client Proposal Framework"** - Score: 36/50
3. **"Meeting Notes Structurer"** - Score: 34/50
4. **"Technical Concept Explainer"** - Score: 31/50
[Full analysis report with evidence, prioritization matrix, skill specifications]
**Recommended Implementation Path**:
1. Start with "Weekly Status Report Generator" (highest ROI)
2. Build "Client Proposal Framework" and "Meeting Notes Structurer" next (complementary workflows)
3. Evaluate remaining patterns after 2-4 weeks of usage
Generate complete skill packages now? [Y/N]
## When to Use This Skill
**✅ Use this skill when:**
- User requests analysis of their conversation patterns
- User wants to identify automation opportunities
- User asks what skills they should create
- User mentions repetitive tasks or workflows
- User wants evidence-based skill recommendations
- User is in web interface (can't use export-based analysis)
**❌ Don't use this skill when:**
- User has conversation export files available (use export-based plugin instead for more comprehensive analysis)
- User wants cross-platform ChatGPT + Claude analysis (requires exports)
- User has very few conversations (<10) making pattern detection unreliable
- User wants to build specific skill they already have in mind
- User is asking about existing skills or community skills
**⚡ Proactive Use:**
When you detect potential patterns during normal conversation, offer:
```
💭 Pattern detected: This is the [Xth] time you've asked me to [action].
Would you like me to analyze your conversation history for similar
patterns and recommend a Custom Skill? I can identify other automation
opportunities you might not have noticed.
[Yes, analyze] [Not now]
```
## Anti-Patterns to Avoid
See **[shared methodology anti-patterns](../../shared/analysis-methodology.md#anti-patterns-to-avoid)** for complete guidance on:
- Tasks not suitable for skills
- Red flags in patterns
- When to use MCP vs skills
- Common recommendation pitfalls