
learnfrompast
Analyzes your shell command history, git workflows, Claude usage patterns, evaluates dependencies, and provides multi-perspective analysis for complex decisions. Identifies productivity improvements, automation opportunities, and helps make informed decisions about package adoption and strategic choices
- version
- 1.7.0
Install
/plugin install learnfrompast@princespaghetti-marketplaceRun it inside Claude Code after adding the marketplace with /plugin marketplace add princespaghetti/claude-marketplace.
Contents
Discovered from sourceSkills 4
Council Consultation Skill
Overview
This skill enables Claude to provide multi-perspective analysis for complex decisions by dynamically generating relevant expert viewpoints, consulting each perspective systematically, and synthesizing their insights into balanced recommendations.
When to Use This Skill
Use council consultation when the user is:
- Making complex decisions with multiple considerations or tradeoffs
- Seeking diverse perspectives on a question or problem
- Evaluating options where different stakeholders would have different priorities
- Facing decisions with significant ambiguity or competing values
- Asking "what should I do about..." or "how should I approach..." questions
- Explicitly requesting multiple viewpoints or perspectives
Do NOT use for:
- Simple factual questions with clear answers
- Questions requiring current information (use web_search instead)
- Technical how-to questions with established solutions
- Questions where a single expert perspective is sufficient
Methodology
Step 1: Analyze the Question
Before generating the council, understand:
- What decision or question needs addressing
- What domain(s) are involved (career, technical, personal, financial, etc.)
- What kinds of expertise or viewpoints would be most valuable
- What tensions or tradeoffs are likely present
Step 2: Generate Council Perspectives
Create 4-5 distinct expert perspectives that would provide valuable input. For each perspective, define:
- Role/Title: A clear, descriptive role (e.g., "Risk Management Specialist", "Long-term Growth Strategist", "Work-Life Balance Advocate")
- Description: One sentence describing their expertise or viewpoint
- Lens: The specific angle or priority they bring to this question
Guidelines for perspective selection:
- Ensure diversity: Include perspectives that might conflict or prioritize different values
- Be context-specific: Tailor perspectives to the actual question, not generic roles
- Balance breadth and depth: Cover major angles without being redundant
- Consider stakeholders: Include viewpoints of people affected by the decision
- Include both optimistic and cautious perspectives
Example for "Should I accept a startup job offer?":
- Financial Security Analyst: Focuses on compensation, equity value, and financial risk
- Career Growth Strategist: Emphasizes learning opportunities and career trajectory
- Work-Life Balance Advocate: Prioritizes sustainable workload and personal time
- Industry Insider: Brings market knowledge and startup ecosystem perspective
- Risk-Reward Evaluator: Weighs upside potential against downside scenarios
Step 3: Consult Each Perspective
For each council member perspective, provide a focused response (3-4 paragraphs) that:
- Stays true to their specific role and lens
- Addresses the original question directly
- Provides concrete, actionable insights where appropriate
- Acknowledges relevant tradeoffs or limitations
- Maintains the distinct voice and priorities of that perspective
Important: Each perspective should feel genuinely different. Avoid simply restating the same analysis from different angles. The perspectives should sometimes disagree or prioritize different factors.
Step 4: Synthesize Perspectives
After presenting all council member responses, provide a synthesis that:
- Highlights alignments: Where do the perspectives agree? What common themes emerge?
- Identifies key tensions: Where do perspectives conflict? What tradeoffs are at play?
- Suggests a balanced path forward: What approach honors the valid insights from multiple perspectives?
- Clarifies what matters most: What considerations should weigh most heavily in this specific decision?
The synthesis should be:
- Concise (4-5 paragraphs)
- Actionable and practical
- Honest about uncertainties or limitations
- Respectful of the user's autonomy to make their own decision
Output Format
Present the council consultation in this structure:
[Brief acknowledgment of the question]
**Council Perspectives:**
**[Role 1: Title]**
*[One sentence description]
*Lens: [Their specific angle]*
[3-4 paragraphs of their perspective]
**[Role 2: Title]**
*[One sentence description]
*Lens: [Their specific angle]*
[3-4 paragraphs of their perspective]
[... continue for all perspectives ...]
**Synthesized Recommendation:**
[4-5 paragraphs synthesizing the perspectives, highlighting alignments and tensions, and suggesting a balanced path forward]
Best Practices
Creating Effective Perspectives
- Avoid stereotypes: Don't create caricatures or overly simplistic viewpoints
- Be specific: "Tax Optimization Strategist" is better than "Financial Expert"
- Ground in reality: Base perspectives on how actual experts in these roles would think
- Allow for nuance: Perspectives can acknowledge complexity and uncertainty
Writing Perspective Responses
- Stay in character: Each perspective should reflect their unique lens consistently
- Provide substance: Go beyond platitudes; give specific considerations and insights
- Be constructive: Even cautious perspectives should be helpful, not just negative
- Vary depth: Some perspectives might go deeper on fewer points; others might survey more broadly
Synthesizing Effectively
- Don't pick winners: Avoid declaring one perspective "right"
- Acknowledge tensions: Some decisions have no perfect answer; be honest about this
- Provide clarity: Help the user understand which factors matter most for their situation
- Respect autonomy: Frame recommendations as considerations, not commands
Advanced Techniques
Adaptive Council Composition
For recurring decision types, consider standard council compositions:
- Career decisions: Financial, Growth, Balance, Risk, Industry perspectives
- Technical architecture: Security, Scalability, Maintainability, Cost, User Experience perspectives
- Investment decisions: Risk, Tax, Diversification, Growth, Liquidity perspectives
- Interpersonal situations: Empathy, Boundaries, Long-term Relationship, Communication, Self-Care perspectives
Handling Follow-up Questions
If the user asks follow-up questions about specific perspectives:
- You can "consult" that specific council member again
- Provide additional depth on their viewpoint
- Allow perspectives to respond to each other if requested
Scaling Complexity
For particularly complex decisions:
- Consider 6-7 perspectives instead of 4-5
- Allow for sub-councils on different aspects
- Structure the synthesis with clearer sections (Alignments, Tensions, Recommendations, Critical Questions)
Common Pitfalls to Avoid
- Generic perspectives: Don't create "optimist vs pessimist" councils; be domain-specific
- Redundant viewpoints: Each perspective should add unique value
- Predetermined conclusions: Let genuine tensions emerge; don't force agreement
- Over-simplification: Complex decisions deserve nuanced perspectives
- Decision-making for the user: Provide insights, not instructions
- Ignoring context: Tailor perspectives to the user's specific situation and constraints
Example Use Cases
Good fits for council consultation:
- "Should I accept this job offer at a startup versus staying at my current company?"
- "What's the right approach for implementing zero-trust security in our platform?"
- "How should I structure my investment portfolio given my goals and constraints?"
- "Should we migrate to microservices or refactor our monolith?"
- "How do I handle this difficult conversation with a colleague?"
Poor fits (use other approaches):
- "What's the capital of France?" (simple fact)
- "What happened in yesterday's election?" (use web_search)
- "How do I fix this Python error?" (technical troubleshooting)
- "Tell me about machine learning" (explanatory, not decisional)
Integration with Other Skills
Council consultation works well with:
- Web search: Use web_search to gather current information before consulting the council
- Document analysis: Analyze uploaded documents first, then consult council on implications
- Technical skills: For implementation questions, consult council on approach, then use technical skills to execute
Notes for Claude
When using this skill:
- Trigger recognition: Look for decision-oriented questions with "should I", "how do I approach", "what's the right way"
- Don't announce the skill: Just use the methodology naturally
- Adapt to context: The exact format can flex based on the question
- Be efficient: For simpler decisions, 3-4 perspectives might be enough
- Follow up naturally: If the user wants to explore one perspective deeper, you can do that
Remember: The goal is to help users think through complex decisions by exposing them to multiple valid viewpoints, not to make the decision for them.
Dependency Evaluator Skill
This skill helps evaluate whether a programming language dependency should be added to a project by analyzing multiple quality signals and risk factors.
Purpose
Making informed decisions about dependencies is critical for project health. A poorly chosen dependency can introduce security vulnerabilities, maintenance burden, and technical debt. This skill provides a systematic framework for evaluating dependencies before adoption.
When to Use
Activate this skill when users:
- Ask about whether to use a specific package/library
- Want to evaluate a dependency before adding it
- Need to compare alternative packages
- Ask "should I use X library?"
- Want to assess the health of a dependency
- Mention adding a new npm/pip/cargo/gem/etc. package
- Ask about package recommendations for a use case
Reference Files
This skill uses progressive disclosure - core framework below, detailed guidance in reference files:
| File | When to Consult |
|---|---|
| WORKFLOW.md | Detailed step-by-step evaluation process, performance tips, pitfalls |
| SCRIPT_USAGE.md | Automated data gathering script (optional efficiency tool) |
| COMMANDS.md | Ecosystem-specific commands (npm, PyPI, Cargo, Go, etc.) |
| SIGNAL_DETAILS.md | Deep guidance for scoring each of the 10 signals |
| ECOSYSTEM_GUIDES.md | Ecosystem-specific norms and considerations |
| EXAMPLES.md | Worked evaluation examples (ADOPT, AVOID, EVALUATE FURTHER) |
| ERROR_HANDLING.md | Fallback strategies when data unavailable or commands fail |
Quick navigation by ecosystem:
- npm → COMMANDS.md § Node.js + ECOSYSTEM_GUIDES.md § npm
- PyPI → COMMANDS.md § Python + ECOSYSTEM_GUIDES.md § PyPI
- Cargo → COMMANDS.md § Rust + ECOSYSTEM_GUIDES.md § Cargo
- Go → COMMANDS.md § Go + ECOSYSTEM_GUIDES.md § Go
- Other → COMMANDS.md for ecosystem-specific commands
Evaluation Framework
Evaluate dependencies using these ten key signals:
- Activity and Maintenance Patterns - Commit history, release cadence, issue responsiveness
- Security Posture - CVE history, security policies, vulnerability response time
- Community Health - Contributor diversity, PR merge rates, bus factor
- Documentation Quality - API docs, migration guides, examples
- Dependency Footprint - Transitive dependencies, bundle size
- Production Adoption - Download stats, notable users, trends
- License Compatibility - License type, transitive license obligations
- API Stability - Breaking change frequency, semver adherence
- Bus Factor and Funding - Organizational backing, sustainability
- Ecosystem Momentum - Framework alignment, technology trends
For detailed investigation guidance, see SIGNAL_DETAILS.md. For ecosystem-specific commands, see COMMANDS.md. For ecosystem considerations, see ECOSYSTEM_GUIDES.md.
Evaluation Approach
Goal: Provide evidence-based recommendations (ADOPT / EVALUATE FURTHER / AVOID) by systematically assessing 10 quality signals.
Process: Quick assessment → Data gathering → Scoring → Report generation
See WORKFLOW.md for detailed step-by-step guidance, performance tips, and workflow variants.
Automated Data Gathering (Recommended)
A Python script (scripts/dependency_evaluator.py) automates initial data gathering for supported ecosystems (npm, pypi, cargo, go). The script:
- Runs ecosystem commands automatically
- Fetches GitHub API data
- Outputs structured JSON
- Uses only Python standard library (no external dependencies)
- Saves 10-15 minutes per evaluation
Default approach: Try the script first - it provides more complete and consistent data gathering. Only fall back to manual workflow if the script is unavailable or fails.
Use the script when: Evaluating npm, PyPI, Cargo, or Go packages (most common ecosystems) Use manual workflow when: Unsupported ecosystem, Python unavailable, or script errors occur
See SCRIPT_USAGE.md for complete documentation. The skill works perfectly fine without the script using manual workflow.
Before You Evaluate: Is a Dependency Needed?
Write it yourself if: Functionality is <50 lines of straightforward code, or you only need a tiny subset of features.
Use a dependency if: Problem is complex (crypto, dates, parsing), correctness is critical, or ongoing maintenance would be significant.
See WORKFLOW.md § Pre-Evaluation for detailed decision framework.
Output Format
Structure your evaluation report as:
## Dependency Evaluation: <package-name>
### Summary
[2-3 sentence overall assessment with recommendation]
**Recommendation**: [ADOPT / EVALUATE FURTHER / AVOID]
**Risk Level**: [Low / Medium / High]
**Blockers Found**: [Yes/No]
### Blockers (if any)
[List any dealbreaker issues - these override all scores]
- ⛔ [Blocker description with specific evidence]
### Evaluation Scores
| Signal | Score | Weight | Notes |
|--------|-------|--------|-------|
| Maintenance | X/5 | [H/M/L] | [specific evidence with dates/versions] |
| Security | X/5 | [H/M/L] | [specific evidence] |
| Community | X/5 | [H/M/L] | [specific evidence] |
| Documentation | X/5 | [H/M/L] | [specific evidence] |
| Dependency Footprint | X/5 | [H/M/L] | [specific evidence] |
| Production Adoption | X/5 | [H/M/L] | [specific evidence] |
| License | X/5 | [H/M/L] | [specific evidence] |
| API Stability | X/5 | [H/M/L] | [specific evidence] |
| Funding/Sustainability | X/5 | [H/M/L] | [specific evidence] |
| Ecosystem Momentum | X/5 | [H/M/L] | [specific evidence] |
**Weighted Score**: X/50 (adjusted for dependency criticality)
### Key Findings
#### Strengths
- [Specific strength with evidence]
- [Specific strength with evidence]
#### Concerns
- [Specific concern with evidence]
- [Specific concern with evidence]
### Alternatives Considered
[If applicable, mention alternatives worth evaluating]
### Recommendation Details
[Detailed reasoning for the recommendation with specific evidence]
### If You Proceed (for ADOPT recommendations)
[Specific advice tailored to risks found]
- Version pinning strategy
- Monitoring recommendations
- Specific precautions based on identified concerns
Scoring Weights
Adjust signal weights based on dependency type:
| Signal | Critical Dep | Standard Dep | Dev Dep |
|---|---|---|---|
| Security | High | Medium | Low |
| Maintenance | High | Medium | Medium |
| Funding | High | Low | Low |
| License | High | High | Medium |
| API Stability | Medium | Medium | High |
| Documentation | Medium | Medium | Medium |
| Community | Medium | Medium | Low |
| Dependency Footprint | Medium | Low | Low |
| Production Adoption | Medium | Medium | Low |
| Ecosystem Momentum | Low | Medium | Low |
Critical Dependencies: Auth, security, data handling - require higher bar for all signals
Standard Dependencies: Utilities, formatting - balance all signals
Development Dependencies: Testing, linting - lower security concerns, focus on maintainability
Score Interpretation Rules
Blocker Override: Any blocker issue → AVOID recommendation regardless of scores
Critical Thresholds:
- Security or Maintenance score ≤ 2 → Strongly reconsider regardless of other scores
- Any High-weight signal ≤ 2 → Flag as significant concern in report
- Overall weighted score < 25 → Default to EVALUATE FURTHER or AVOID
- Overall weighted score ≥ 35 → Generally safe to ADOPT (if no blockers)
Weighting Priority: Security and Maintenance typically matter more than Documentation or Ecosystem Momentum. A well-documented but unmaintained package is riskier than a poorly-documented but actively maintained one.
Critical Red Flags (Dealbreakers)
These issues trigger automatic AVOID recommendation:
Supply Chain Risks
- ⛔ Typosquatting: Package name suspiciously similar to popular package
- ⛔ Compiled binaries without source: Binary blobs without build instructions
- ⛔ Sudden ownership transfer: Recent transfer to unknown maintainer
- ⛔ Install scripts with network calls: Postinstall scripts downloading external code
Maintainer Behavior
- ⛔ Ransom behavior: Maintainer demanding payment to fix security issues
- ⛔ Protest-ware: Code performing actions based on political/geographic conditions
- ⛔ Intentional sabotage history: Any history of deliberately breaking the package
Security Issues
- ⛔ Active exploitation: Known vulnerability being actively exploited in wild
- ⛔ Credentials in source: API keys, passwords, or secrets in repository
- ⛔ Disabled security features: Package disables security without clear reason
Legal Issues
- ⛔ License violation: Package includes code violating its stated license
- ⛔ No license: No license file means all rights reserved (legally risky)
- ⛔ License change without notice: Recent sneaky change to restrictive terms
Self-Validation Checklist
Before presenting your report, verify:
- Cited specific versions and dates for all claims?
- Ran actual commands rather than making assumptions?
- All scores supported by evidence in "Notes" column?
- If Security or Maintenance ≤ 2, flagged prominently?
- If any blocker exists, recommendation is AVOID?
- Provided at least 2 alternatives if recommending AVOID?
- "If You Proceed" section tailored to specific risks found?
- Recommendation aligns with weighted score and blocker rules?
Evaluation Principles
Be Evidence-Based: Cite specific versions, dates, and metrics. Run commands to gather data, never assume.
Be Balanced: Acknowledge strengths AND weaknesses. Single issues rarely disqualify (unless blocker).
Be Actionable: Provide clear ADOPT/EVALUATE FURTHER/AVOID with alternatives and risk mitigation.
Be Context-Aware: Auth libraries need stricter scrutiny than dev tools. Adjust for ecosystem norms (see ECOSYSTEM_GUIDES.md).
See WORKFLOW.md § Common Pitfalls and § Guidelines for detailed best practices.
Git Workflow Patterns Analysis
This skill analyzes your git history to identify patterns in your workflow and suggest improvements. It learns from your past git behavior to provide personalized recommendations for efficiency, safety, and consistency.
How to Use This Skill
When activated, analyze the user's git history to identify patterns and provide actionable insights. The analysis should be:
- Personalized: Based on actual patterns in their git history
- Actionable: Include specific commands, aliases, or workflow changes
- Evidence-based: Reference actual data from their history
- Privacy-conscious: Analyze locally, don't store raw commit messages or sensitive data
Analysis Process
1. Gather Git History Data
Run these commands to collect pattern data:
# Get comprehensive commit history
git log --all --pretty=format:"%h|%an|%ae|%ai|%s" --numstat --no-merges
# Get branch information
git for-each-ref --format='%(refname:short)|%(authorname)|%(authordate:iso8601)|%(upstream:short)' refs/heads/
# Get reflog for error recovery patterns
git reflog --pretty=format:"%h|%gd|%gs" -n 500
# Get stash list
git stash list
# Get merge/rebase patterns
git log --all --merges --pretty=format:"%h|%ai|%s"
# Get remote branch information
git branch -r
2. Identify Key Patterns
Analyze the data for:
Commit Patterns
- Message consistency: Do they follow conventional commits? Consistent format?
- Commit size: Average lines changed per commit (small/focused vs. large batches)
- Commit frequency: Time between commits (batching behavior)
- WIP/fixup commits: Frequency of temporary commits that should be squashed
- Test commits: Separate test commits vs. code+test together
Branch Patterns
- Naming conventions: Identify different formats used (feature/, feat/JIRA-, user/*)
- Branch lifespan: Average time from creation to merge
- Abandoned branches: Branches created but never merged
- Branch size: Average commits per branch
- Long-lived branches: Branches with 20+ commits (potential for splitting)
Collaboration Patterns
- Solo vs. co-authored: Frequency of pair programming
- Merge strategy: Merge commits vs. rebase preference
- Force push frequency: How often and to which branches
- PR patterns: Can infer from branch merge frequency
Error Recovery Patterns
- Reflog usage: Frequent reflog = frequent mistakes/uncertainty
- Reset/revert: Hard resets vs. reverts
- Cherry-pick: Frequency and context
- Stash accumulation: Unretrieved stashes indicate workflow issues
Workflow Efficiency
- Repeated sequences: Commands run together frequently (alias opportunities)
- Manual cleanups: Patterns suggesting missing automation
- Conflict patterns: Files that frequently conflict
- Context switching: Branch checkout frequency
3. Generate Report
Structure the report similarly to the shell history analysis:
## Git Workflow Analysis Summary
[2-3 sentence overview of their git workflow patterns]
## Commit Patterns
- Total commits analyzed: X
- Average commit size: Y lines
- Commit message format: [detected pattern or inconsistency]
- Most active hours: [time patterns]
## Top Workflow Patterns
1. [Pattern 1]: Frequency and context
2. [Pattern 2]: Frequency and context
...
## Improvement Opportunities
### High Impact
**[Issue 1]**: [Description with evidence]
- **Current state**: [What they do now]
- **Impact**: [Why it's inefficient/risky]
- **Recommendation**: [Specific fix]
- **Implementation**:
```bash
[Copy-pasteable commands/aliases]
Medium Impact
[Similar structure]
Quick Wins
- [One-liner improvement 1]
- [One-liner improvement 2]
Suggested Git Aliases & Config
# Add to ~/.gitconfig
[alias]
# [Description of what this solves]
alias-name = "command based on their patterns"
# [Another pattern-based alias]
another-alias = "..."
[merge]
# [Config to prevent common conflicts they experience]
conflictstyle = diff3
[Other recommended configs based on patterns]
Workflow Recommendations
Branch Strategy
[Recommendations based on their branching patterns]
Commit Strategy
[Recommendations based on commit patterns]
Safety Improvements
[Recommendations for preventing errors they've made]
## Common Scenarios & Examples
### Scenario 1: Rebase Anxiety
**When to activate**: User mentions rebasing, or git history shows reflog activity after rebases
**What to analyze**:
- Frequency of `git reflog` usage after rebase operations
- Reset/revert patterns following rebases
- Success rate of interactive rebases
**What to suggest**:
- Backup branch workflow before rebasing
- Git aliases for safe rebasing
- Alternative strategies if rebasing causes consistent issues
### Scenario 2: Large PRs / Long-Lived Branches
**When to activate**: User is working on a branch with 20+ commits
**What to analyze**:
- Historical PR sizes and review times
- Correlation between PR size and merge time
- Natural logical split points in commit history
**What to suggest**:
- Breaking into smaller PRs
- Stacked PR workflow
- Commit organization strategies
### Scenario 3: Inconsistent Commit Messages
**When to activate**: User commits code, or asks about git best practices
**What to analyze**:
- Commit message formats used
- Consistency over time
- Team patterns (if multiple authors)
**What to suggest**:
- Conventional commits format
- Commit message templates
- Git hooks for enforcement
### Scenario 4: Merge Conflict Patterns
**When to activate**: User mentions merge conflicts or is resolving conflicts
**What to analyze**:
- Which files conflict most frequently
- Common conflict types (dependency files, migrations, etc.)
- Their typical resolution strategy
**What to suggest**:
- Merge strategies for specific file types
- Git configuration to auto-resolve certain conflicts
- Workflow changes to reduce conflict frequency
### Scenario 5: Stash Hoarding
**When to activate**: User says "I had some changes but lost them" or has many stashes
**What to analyze**:
- Number of stashes
- How often stashes are applied vs. abandoned
- Time stashes remain unapplied
**What to suggest**:
- Using WIP branches instead of stashes
- Stash cleanup workflow
- Better branch management
### Scenario 6: Force Push Safety
**When to activate**: User is about to force push or mentions force pushing
**What to analyze**:
- Frequency of force pushes
- Branches force-pushed to (solo vs. shared)
- Historical issues caused by force pushes
**What to suggest**:
- `--force-with-lease` instead of `--force`
- Git aliases with safety checks
- Team communication protocols
## Guidelines
### Be Specific and Evidence-Based
- Always reference actual data: "You've created 23 branches in the last month"
- Show frequency: "This happens in 73% of your commits"
- Compare to best practices with context, not judgment
### Prioritize by Impact
- Focus on patterns that waste the most time
- Address safety issues (force pushes to shared branches) with urgency
- Quick wins first, then deeper workflow changes
### Provide Working Solutions
- All suggestions should include copy-pasteable commands
- Test that aliases and configs are syntactically correct
- Include both short-term fixes and long-term improvements
### Respect Privacy
- Never include actual commit messages in analysis (just patterns)
- Don't reference specific code changes
- Focus on workflow metadata, not content
- Analyze locally, don't send git history to external services
### Encourage and Highlight Strengths
- Note good patterns: "Your commit sizes are consistently small and focused"
- Frame suggestions as optimization, not criticism
- Acknowledge learning curve for git complexity
## Technical Notes
### Performance Considerations
- Limit history analysis to last 500-1000 commits for initial analysis
- Cache pattern data to avoid re-analyzing on every activation
- Use `--no-merges` and `--no-walk` flags appropriately to reduce data
### Error Handling
- Check if in a git repository before running commands
- Handle repositories with no commits gracefully
- Account for repositories with unconventional setups (multiple remotes, submodules)
### Integration with Shell History Analysis
When both skills are available, cross-reference:
- Shell history shows git commands run frequently
- Git patterns show the results of those commands
- Combined insights reveal automation opportunities
Example:
- Shell: `git add . && git commit -m "..." && git push` (typed 200x)
- Git: Commits average 3 files, 50 lines, always pushed immediately
- Combined insight: Create single alias for the entire workflow
Workflow Analyzer Skill
Purpose
This skill analyzes your Claude Code usage patterns by examining session transcripts to identify workflows you repeat frequently. It suggests specific slash commands you could create to automate these patterns, complete with time savings estimates and implementation priorities.
When to Use
Use this skill when you want to:
- Identify repeated workflows in your Claude Code sessions
- Discover automation opportunities
- Get specific recommendations for slash commands to create
- Understand your development patterns and time investment
- Optimize your Claude Code workflow efficiency
How It Works
This skill includes a pre-built Python analysis script that:
- Parses session JSONL files from
~/.claude/projects/*/ - Identifies repeated patterns in user requests across sessions
- Detects common workflows (git operations, documentation updates, testing cycles, etc.)
- Generates a comprehensive report with automation recommendations
Parameters
- days (optional): Number of days to analyze, defaults to 30
- Examples: "analyze my workflows from the last 7 days", "analyze my workflows from the last 60 days"
Analysis Criteria
The skill considers a pattern significant if it:
- Appears 3+ times in the analyzed period
- Has consistent structure across occurrences
- Represents meaningful time investment
- Could be automated as a single slash command
Patterns Detected
The skill identifies these common workflow patterns:
- Git workflows: add/commit/push sequences, branch operations, PR creation
- Version/publish sequences: version bumps, plugin/marketplace updates, releases
- Documentation updates: README changes, consistency checks, sync operations
- Implementation cycles: plan → build → test patterns, phase-based development
- Test/fix cycles: test execution, error fixing, validation loops
Usage Instructions
When the user requests workflow analysis:
-
Calculate date range:
- Use the
daysparameter if provided, otherwise default to 30 - Calculate cutoff timestamp:
date -v-{days}d +%s(macOS) ordate -d "{days} days ago" +%s(Linux)
- Use the
-
Locate session files:
find ~/.claude/projects -name "*.jsonl" -type f -mtime -{days} 2>/dev/null -
Run analysis and generate report:
find ~/.claude/projects -name "*.jsonl" -type f -mtime -{days} 2>/dev/null | \ python3 <skill-path>/scripts/workflow_analyzer.py -
Present findings:
- Display the complete markdown report to the user
- Highlight top 3 automation opportunities
- Include specific time savings estimates
- Provide concrete next steps
Report Deliverables
The generated report includes:
Analysis Summary
- Time period analyzed (date range)
- Number of sessions reviewed
- Number of user prompts examined
- Total patterns detected
High-Priority Patterns (ranked by impact)
For each pattern:
- Pattern name and description
- Frequency of occurrence
- Example user request sequences (actual prompts from sessions)
- Suggested command name (verb-noun format)
- Estimated time per occurrence and total time spent
- Potential time savings with automation
Project-Specific Insights
- Which projects show the most repeated workflows
- Project-specific automation opportunities
- Activity distribution across projects
Recommendations
- Which commands to create first (ranked by ROI)
- Estimated time savings for top suggestions
- Implementation complexity assessment
- Next steps for the user
Privacy
- All analysis is performed locally only
- No data is sent to external services
- Session transcripts never leave the user's machine
- All processing happens in-memory with no temporary files created
Success Criteria
This skill is successful if it:
- Accurately identifies patterns the user actually repeats
- Provides specific, actionable automation suggestions
- Shows clear time savings estimates
- Presents findings in a scannable, useful format
- Completes in reasonable time (< 2 minutes for 30 days of data)
Example Invocations
- "Analyze my workflows"
- "What workflows am I repeating in Claude Code?"
- "Analyze my workflows from the last 60 days"
- "Find automation opportunities in my Claude Code usage"
- "Show me what I'm doing repeatedly"
Notes
- The skill focuses on user prompts, not system messages or command outputs
- Patterns must appear 3+ times to be considered significant
- Time estimates are based on typical workflow execution times
- Suggested command names follow verb-noun convention (e.g.,
/ship-git,/publish-plugin)
Commands 1
This command provides personalized insights into your command-line habits by analyzing your zsh history to reveal patterns, inefficiencies, and opportunities for improvement.
Instructions
Read ~/.zsh_history or ~/.bash_history and analyze command patterns to generate a concise, actionable report.
Analysis Focus
Command Patterns:
- Identify top 10-15 most frequent commands
- Categorize by purpose (version control, package management, file ops, development tools, etc.)
- Find repeated command sequences that could be automated
Productivity Opportunities:
- Long/repetitive commands suitable for aliasing (prioritize by frequency × length)
- Command chains executed together frequently
- Excessive directory navigation patterns
Deliverables:
- 3-4 high-impact improvement opportunities with Impact/Effort ratings
- Ready-to-use aliases and shell functions (copy-pasteable)
- 2-3 quick wins (< 5 min to implement)
- Brief skill development suggestions
Report Structure
Keep the report focused and scannable:
- Summary: Brief overview of command patterns and workflow (2-3 sentences)
- Top Commands: List 10-15 most frequent with counts
- Improvement Opportunities: 3-4 specific recommendations with before/after examples
- Suggested Aliases & Functions: Copy-pasteable code block for ~/.zshrc
- Quick Wins: 2-3 one-liner improvements
Guidelines:
- Be concise but specific - use actual counts from history
- Prioritize by impact (frequency × time saved)
- Provide working code, not templates
- Keep encouraging tone, highlight existing strengths
Sponsors
Details
- Marketplace
- princespaghetti/claude-marketplace
- Source
- learnfrompast
- Category
- Productivity
- License
- MIT
- Keywords
- shell, history, productivity, analysis, zsh, bash, automation, git, workflow, version-control, patterns, commands, dependencies, packages, npm, pip, cargo, security, evaluation, decision-making, multi-perspective, strategy, consultation