| name | analysis |
| description | Comprehensive analysis operations for code, skills, processes, data, and patterns. Task-based operations with pattern recognition, metrics calculation, trend identification, and actionable insights generation. Use when analyzing code quality, reviewing skill effectiveness, identifying process improvements, extracting patterns, or generating insights from data. |
| allowed-tools | Read, Write, Edit, Glob, Grep, Bash, WebSearch, WebFetch |
Analysis
Overview
analysis provides systematic analytical operations for understanding code, skills, processes, data, and patterns. It helps extract insights, identify improvements, recognize patterns, and make data-driven decisions.
Purpose: Transform raw information into actionable insights through systematic analysis
The 5 Analysis Operations:
- Code Analysis - Quality, complexity, patterns, technical debt
- Skill Analysis - Effectiveness, usage patterns, improvement opportunities
- Process Analysis - Efficiency, bottlenecks, optimization opportunities
- Data Analysis - Metrics, trends, statistical insights
- Pattern Recognition - Cross-artifact patterns, recurring themes, systemic insights
Key Benefits:
- Data-Driven Decisions: Base improvements on evidence, not assumptions
- Pattern Discovery: Identify recurring themes across multiple artifacts
- Quality Insights: Understand code/skill quality objectively
- Process Optimization: Find bottlenecks and inefficiencies
- Trend Identification: Spot improving/degrading patterns over time
When to Use
Use analysis when:
- Understanding Code Quality - Analyze codebase for patterns, complexity, technical debt
- Evaluating Skill Effectiveness - Assess which skills work well, which need improvement
- Optimizing Processes - Identify bottlenecks, inefficiencies in workflows
- Making Data-Driven Decisions - Use metrics and trends to guide improvements
- Discovering Patterns - Find recurring themes across code, skills, or processes
- Measuring Progress - Track improvements over time quantitatively
- Identifying Opportunities - Discover improvement and optimization opportunities
- Post-Review Analysis - After reviews, analyze findings for systemic insights
- Continuous Improvement - Feed insights back into development process
Operations
Operation 1: Code Analysis
Purpose: Analyze code for quality, complexity, patterns, and technical debt
When to Use This Operation:
- Assessing codebase quality
- Identifying refactoring opportunities
- Understanding code complexity
- Detecting code smells
- Planning technical debt reduction
Process:
-
Define Analysis Scope
- Which code to analyze? (files, modules, entire codebase)
- What aspects? (quality, complexity, patterns, debt)
- What questions to answer?
-
Gather Code Metrics
- Lines of code (LOC)
- Function/class count
- Cyclomatic complexity
- Duplication levels
- Comment density
-
Identify Patterns
- Common code patterns used
- Recurring structures
- Naming conventions
- Architecture patterns
- Design patterns applied
-
Detect Code Smells
- Long functions (>50 lines)
- Deep nesting (>3 levels)
- Duplicated code
- Complex conditionals
- Poor naming
-
Generate Insights
- Overall quality assessment
- Complexity hotspots
- Refactoring priorities
- Pattern recommendations
- Technical debt inventory
Validation Checklist:
Outputs:
- Code quality assessment
- Complexity metrics
- Identified patterns
- Code smells list
- Refactoring recommendations
- Technical debt inventory
Time Estimate: 30-90 minutes (varies by scope)
Example:
Code Analysis: Authentication Module
=====================================
Scope: auth/ directory (15 files, 3,200 LOC)
Metrics:
- Total LOC: 3,200
- Functions: 85
- Classes: 12
- Average function length: 25 lines (good)
- Cyclomatic complexity: Average 4.2 (acceptable)
Patterns Identified:
1. Decorator pattern for authentication checks (used 12x)
2. Strategy pattern for auth methods (OAuth, JWT, API key)
3. Factory pattern for token generation
Code Smells Detected:
❌ 3 functions >100 lines (validate_token, process_oauth, refresh_session)
❌ 2 files with >15% code duplication
⚠️ 5 functions with complexity >10
⚠️ Inconsistent error handling (some raise, some return None)
Quality Assessment: 7/10 (Good with improvements needed)
Recommendations:
1. [High] Refactor 3 long functions into smaller units
2. [High] Extract duplicated code to shared utilities
3. [Medium] Standardize error handling (use exceptions consistently)
4. [Low] Add docstrings to 8 functions missing them
Technical Debt Estimate: 8-12 hours to address all issues
Operation 2: Skill Analysis
Purpose: Analyze skill effectiveness, usage patterns, and identify improvement opportunities
When to Use This Operation:
- Evaluating skill ecosystem health
- Understanding which skills are most valuable
- Identifying underutilized skills
- Planning skill improvements
- Measuring skill development efficiency
Process:
-
Collect Skill Metrics
- Number of skills in ecosystem
- Lines of code per skill
- Build time per skill
- Pattern distribution (workflow/task/reference)
- Quality scores (from review-multi)
-
Analyze Usage Patterns
- Which skills used most frequently?
- Which skills rarely used?
- Skill dependencies (which skills require others?)
- Integration patterns (how skills compose)
-
Assess Effectiveness
- Do skills achieve stated purposes?
- User satisfaction with skills
- Time savings delivered
- Quality improvements enabled
-
Identify Improvement Opportunities
- Skills with low quality scores
- Skills with usability issues
- Missing functionality gaps
- Integration opportunities
-
Generate Recommendations
- Skills to improve (with specific changes)
- Skills to deprecate (if any)
- New skills to build (gaps identified)
- Integration opportunities
Validation Checklist:
Outputs:
- Skill ecosystem metrics
- Usage pattern analysis
- Effectiveness assessment
- Improvement opportunities list
- Prioritized recommendations
Time Estimate: 45-90 minutes
Example:
Skill Ecosystem Analysis
========================
Skills in Ecosystem: 8
Total LOC: ~25,000 lines
Average Build Time: 6.8 hours/skill
Efficiency Gain: 70.6% faster than baseline
Pattern Distribution:
- Workflow: 5 skills (63%)
- Task: 3 skills (38%)
Quality Scores (Structure):
- All 8 skills: 5/5 (Grade A)
- 100% structural excellence
Usage Patterns (Inferred):
- Most Used: development-workflow (used to build skills 8-9)
- High Value: planning-architect, task-development, todo-management (used in every skill)
- Recently Added: review-multi, context-engineering (usage TBD)
Effectiveness Assessment:
✅ Bootstrap strategy working (efficiency compounding)
✅ All skills achieve stated purposes
✅ Quality maintained through rapid building
✅ Progressive disclosure effective (token optimization)
Improvement Opportunities:
1. Add Quick Reference to 3 early skills → DONE ✅
2. Refine vague validation in 3 skills → Low priority
3. Build remaining Layer 2 skills → IN PROGRESS
Recommendations:
1. [High] Complete Layer 2 (3 skills remaining)
2. [Medium] Conduct comprehensive reviews on planning-architect, development-workflow
3. [Low] Refine script detection accuracy (pattern detection)
Insights:
- Skills built faster over time (compound efficiency)
- Standards evolved (Quick Reference added during skill 4-5)
- Continuous improvement cycle working (review → improve → validate)
Operation 3: Process Analysis
Purpose: Analyze workflow efficiency, identify bottlenecks, and discover optimization opportunities
When to Use This Operation:
- Optimizing development workflows
- Identifying process inefficiencies
- Reducing cycle times
- Improving team productivity
- Streamlining operations
Process:
-
Map Current Process
- Document process steps
- Identify decision points
- Note hand-offs and dependencies
- Measure duration of each step
-
Collect Process Metrics
- Cycle time (start to finish)
- Wait time (delays, blockers)
- Active time (actual work)
- Rework time (fixes, iterations)
- Throughput (completions per time period)
-
Identify Bottlenecks
- Steps with longest duration
- Steps with most wait time
- Steps with highest rework rate
- Resource constraints
- Dependency blockages
-
Analyze Efficiency
- Time utilization (active vs wait)
- Automation opportunities
- Parallelization potential
- Waste identification (unnecessary steps)
-
Generate Optimization Recommendations
- Bottleneck elimination strategies
- Automation opportunities
- Process simplification
- Parallel work enablement
- Waste reduction
Validation Checklist:
Outputs:
- Process map (visual or textual)
- Process metrics
- Bottleneck analysis
- Efficiency assessment
- Optimization recommendations with estimated impact
Time Estimate: 60-120 minutes
Example:
Process Analysis: Skill Development Workflow
============================================
Current Process (Before development-workflow):
1. Research (ad-hoc): 2-4 hours
2. Planning (informal): 1-2 hours
3. Implementation: 12-20 hours
4. Testing: 2-3 hours
Total Cycle Time: 17-29 hours per skill
Bottlenecks Identified:
❌ Research phase: No systematic approach → wide time variance
❌ Planning: Informal → often incomplete, causes rework
❌ Implementation: No task breakdown → often get lost
Process Efficiency:
- Active time: 60-70% (actual work)
- Wait time: 10-15% (thinking, decisions)
- Rework: 20-25% (fixing incomplete plans)
After development-workflow Implementation:
1. Research (skill-researcher): 1 hour (systematic)
2. Planning (planning-architect): 1.5 hours (comprehensive)
3. Tasks (task-development): 45 min (clear breakdown)
4. Implementation: 8-15 hours (guided by prompts)
5. Validation: 30-60 min
Total Cycle Time: 12-18 hours per skill
Improvements:
✅ Research: 50-60% faster (systematic approach)
✅ Planning: More thorough but faster (structured process)
✅ Implementation: 30-40% faster (clear tasks, good prompts)
✅ Rework: Reduced to 5-10% (better planning)
Overall Improvement: 35-40% cycle time reduction
Quality Impact: Improved (more systematic, better planning)
Optimization Recommendations:
1. [Applied] Use development-workflow for all skills ✅
2. [Future] Automate research aggregation
3. [Future] Template-based planning for common patterns
4. [Future] Continuous validation during development (not just end)
Operation 4: Data Analysis
Purpose: Analyze metrics, trends, and statistical patterns in data
When to Use This Operation:
- Understanding quantitative data
- Identifying trends over time
- Making evidence-based decisions
- Measuring improvements
- Validating hypotheses
Process:
-
Define Analysis Questions
- What questions need answering?
- What decisions depend on this analysis?
- What hypotheses to test?
-
Collect Data
- Gather relevant metrics
- Ensure data quality and completeness
- Document data sources
- Note collection methodology
-
Calculate Metrics
- Basic statistics (mean, median, min, max)
- Distributions (variance, standard deviation)
- Rates and percentages
- Trends over time
- Correlations (if applicable)
-
Identify Trends
- Improving trends (getting better)
- Degrading trends (getting worse)
- Stable patterns (consistent)
- Anomalies (outliers, unusual data points)
-
Generate Insights
- What does the data show?
- What are the implications?
- What actions should be taken?
- What should be monitored going forward?
Validation Checklist:
Outputs:
- Calculated metrics
- Trend analysis
- Data visualizations (tables, charts if helpful)
- Statistical insights
- Evidence-based recommendations
Time Estimate: 45-90 minutes
Example:
Data Analysis: Skill Build Efficiency
======================================
Question: Is build efficiency actually improving over time?
Data Collected (8 skills):
| Skill # | Name | Build Time | Efficiency vs Baseline |
|---------|------|------------|----------------------|
| 1 | planning-architect | 20.0h | 0% (baseline) |
| 2 | task-development | 5.0h | 75% faster |
| 3 | todo-management | 3.5h | 82.5% faster |
| 4 | prompt-builder | 3.0h | 85% faster |
| 5 | skill-researcher | 2.5h | 87.5% faster |
| 6 | workflow-skill-creator | 2.5h | 87.5% faster |
| 8 | development-workflow | 5.5h | 72.5% faster |
| 9 | review-multi | 13.0h | 35% faster |
Metrics:
- Mean build time (skills 2-9): 5.6 hours
- Median build time: 4.25 hours
- Range: 2.5h to 13h
- Average efficiency gain: 70.6% faster than baseline
Trends Identified:
✅ Improving: Skills 2-6 show increasing efficiency (75% → 87.5%)
⚠️ Plateau: Skills 6 efficiency plateaus at 87.5%
⚠️ Outliers: Skill 8 (5.5h) and Skill 9 (13h) break trend
Outlier Analysis:
- Skill 8 (development-workflow): 5.5h (slower than trend)
Reason: First workflow composition, new pattern learning
Acceptable: Still 72.5% faster than baseline
- Skill 9 (review-multi): 13h (much slower)
Reason: High complexity (13 files, 4 scripts, detailed rubrics)
Acceptable: Still 35% faster than baseline 20h
Insights:
1. Efficiency compounds skills 2-6 (each faster than previous)
2. Efficiency plateaus around 85-90% (cannot get faster than certain minimums)
3. Complex skills (review-multi) still benefit from workflow (35% faster)
4. New patterns (workflow composition) add learning time but still faster
Conclusion: ✅ Hypothesis CONFIRMED
- Build efficiency IS improving
- Compound gains through skill 6
- Plateau at 85-90% for simple skills
- Complex skills still benefit (35%+ faster)
Recommendations:
1. Continue using development-workflow (proven effective)
2. Expect 85-90% efficiency for simple/medium skills
3. Expect 30-50% efficiency for complex/novel patterns
4. Track actual vs estimated times for better prediction
Operation 5: Pattern Recognition
Purpose: Identify recurring patterns, themes, and systemic insights across multiple artifacts
When to Use This Operation:
- Analyzing multiple reviews/analyses
- Identifying systemic issues
- Discovering best practices from evidence
- Understanding ecosystem trends
- Extracting learnings for future work
Process:
-
Collect Artifacts
- Gather all relevant data (reviews, analyses, metrics, feedback)
- Ensure sufficient sample size (3+ instances minimum)
- Document artifact sources and dates
-
Identify Recurring Themes
- Issues appearing in multiple artifacts
- Practices working consistently well
- Common failure modes
- Repeated patterns (good or bad)
-
Categorize Patterns
- Structural patterns (organization, naming)
- Content patterns (documentation styles)
- Quality patterns (anti-patterns, best practices)
- Process patterns (workflow effectiveness)
- Temporal patterns (evolution over time)
-
Assess Pattern Significance
- Frequency (how often appears?)
- Impact (how much does it matter?)
- Consistency (always true or sometimes?)
- Causation (what causes this pattern?)
-
Extract Insights and Recommendations
- Document discovered patterns
- Explain significance and impact
- Provide actionable recommendations
- Update guidelines/templates with learnings
Validation Checklist:
Outputs:
- Identified patterns (with evidence)
- Pattern significance assessment
- Systemic insights
- Updated guidelines/templates
- Recommendations for future work
Time Estimate: 60-120 minutes
Example:
Pattern Recognition: Skill Review Findings (7 Skills)
=====================================================
Artifacts Analyzed: 7 structure reviews + 7 pattern analyses
Recurring Patterns Identified:
PATTERN 1: Quick Reference Evolution
- Frequency: 3 of 7 skills (43%)
- Observation: Skills 1-3 lack Quick Reference, skills 4-8 have it
- Significance: Standard evolved during development
- Impact: User experience (medium)
- Causation: Learned importance during skill 4-5 development
- Recommendation: Add to early skills retroactively → DONE ✅
PATTERN 2: Progressive Disclosure Compliance
- Frequency: 7 of 7 skills (100%)
- Observation: All skills maintain SKILL.md + references/ structure
- Significance: Fundamental design principle
- Impact: Context optimization (high)
- Recommendation: Continue applying in all future skills
PATTERN 3: Validation Specificity Improvement
- Frequency: Evolved over skills 1-8
- Observation: Earlier skills have some vague validation, later skills more specific
- Significance: Quality improvement over time
- Impact: Validation reliability (medium)
- Recommendation: Refine vague criteria in early skills (low priority)
PATTERN 4: Complexity vs Build Time
- Frequency: 8 data points
- Observation: Complex skills take longer even with workflow (review-multi 13h vs others 2.5-5.5h)
- Significance: Complexity matters more than experience
- Impact: Estimation accuracy (high)
- Recommendation: Adjust estimates based on complexity, not just efficiency gains
PATTERN 5: Best Practices Adoption
- Frequency: 7 of 7 skills (100%)
- Observation: All skills have validation checklists, examples, error documentation
- Significance: Strong quality foundation
- Impact: Quality consistency (high)
- Recommendation: Document these as mandatory standards
Systemic Insights:
1. Standards evolve through building (Quick Reference example)
2. Continuous improvement works (retroactive improvements possible)
3. Complexity dominates build time (more than experience level)
4. Best practices highly adopted (100% consistency)
5. Structural excellence across board (all 5/5)
Recommendations for Future:
1. Document evolved standards in common-patterns.md ✅
2. Apply retroactive improvements systematically ✅
3. Adjust time estimates based on complexity tiers
4. Continue tracking patterns for continuous learning
5. Update skill-builder-generic with discovered patterns
Best Practices
1. Define Clear Questions
Practice: Start analysis with specific questions to answer
Rationale: Clear questions focus analysis, prevent meandering exploration
Application: Write 2-5 specific questions before beginning analysis
2. Collect Sufficient Data
Practice: Ensure adequate sample size for reliable patterns
Rationale: Small samples (n=1-2) can be misleading, n≥3 shows patterns
Application: Analyze at least 3 instances before claiming pattern
3. Quantify When Possible
Practice: Use metrics and numbers, not just qualitative assessment
Rationale: Quantitative data enables objective comparison and trend tracking
Application: Count, measure, calculate - then interpret
4. Separate Observation from Interpretation
Practice: Clearly distinguish what you observe from what you conclude
Rationale: Prevents bias, enables others to validate conclusions
Application: "Observation: X. Interpretation: This suggests Y because Z."
5. Prioritize Insights
Practice: Not all insights are equally important - prioritize by impact
Rationale: Focus on high-impact findings, don't get lost in details
Application: Tag insights as Critical/High/Medium/Low impact
6. Make Recommendations Actionable
Practice: Every insight should lead to specific, actionable recommendation
Rationale: Analysis without action is academic - need practical application
Application: For each insight, specify: "Recommendation: Do X to achieve Y"
7. Document and Share
Practice: Record analysis findings for future reference
Rationale: Learnings compound when captured and shared
Application: Create analysis reports, update guidelines with patterns
8. Validate Conclusions
Practice: Test conclusions with additional data or expert review
Rationale: Prevents false patterns, ensures reliability
Application: When possible, validate findings with second analyst or additional data
Common Mistakes
Mistake 1: Analysis Paralysis
Symptom: Endless analysis without decisions or actions
Cause: Perfect information seeking, fear of deciding
Fix: Set time box (e.g., 2 hours max), make decision with available data
Prevention: Define analysis questions and stopping criteria upfront
Mistake 2: Small Sample Size
Symptom: Claiming patterns from 1-2 instances
Cause: Insufficient data collection
Fix: Gather more data (minimum n=3), acknowledge limitations if small sample
Prevention: Check sample size before concluding patterns
Mistake 3: Confirmation Bias
Symptom: Finding only evidence supporting preconceived ideas
Cause: Looking for confirmation, not truth
Fix: Actively seek disconfirming evidence, consider alternative explanations
Prevention: Define questions objectively, analyze all data (not cherry-pick)
Mistake 4: Confusing Correlation with Causation
Symptom: Assuming A causes B because they occur together
Cause: Logical fallacy
Fix: Identify plausible causal mechanisms, test with additional evidence
Prevention: Use careful language: "correlated with" not "causes"
Mistake 5: No Actionable Recommendations
Symptom: Interesting findings but unclear what to do
Cause: Analysis without application thinking
Fix: For each finding, ask "So what? What should we do?"
Prevention: Require actionable recommendation for each insight
Mistake 6: Ignoring Context
Symptom: Misinterpreting data due to missing context
Cause: Analyzing data without understanding circumstances
Fix: Gather context (why data collected, what was happening, any special circumstances)
Prevention: Document context alongside data
Quick Reference
The 5 Analysis Operations
| Operation | Focus | When to Use | Time | Key Output |
|---|
| Code Analysis | Quality, complexity, patterns | Assessing codebase, refactoring | 30-90m | Quality assessment, refactoring priorities |
| Skill Analysis | Effectiveness, usage, improvements | Evaluating skill ecosystem | 45-90m | Effectiveness assessment, improvement opportunities |
| Process Analysis | Efficiency, bottlenecks, optimization | Optimizing workflows | 60-120m | Bottleneck analysis, process optimization |
| Data Analysis | Metrics, trends, statistics | Evidence-based decisions | 45-90m | Metrics, trends, insights |
| Pattern Recognition | Cross-artifact patterns, systemic insights | Continuous improvement | 60-120m | Identified patterns, systemic recommendations |
Analysis Types
| Type | Input | Output | Methods |
|---|
| Quantitative | Numbers, metrics | Statistics, trends | Calculate, compare, trend analysis |
| Qualitative | Text, observations | Themes, patterns | Categorize, synthesize, interpret |
| Comparative | Multiple artifacts | Similarities, differences | Side-by-side comparison, contrast |
| Temporal | Data over time | Trends, changes | Time-series analysis, before/after |
| Root Cause | Problems | Underlying causes | 5 Whys, fishbone, causal analysis |
Key Metrics for Skills
Build Efficiency:
- Build time per skill
- Efficiency vs baseline (%)
- Time savings (hours)
Quality:
- Review scores (1-5 scale)
- Anti-pattern count
- Best practice adherence (%)
Usage:
- Skills used (frequency)
- Integration patterns
- User satisfaction
Ecosystem:
- Total skills
- Pattern distribution
- Dependency graph
- Completion percentage
Analysis Checklist Template
Analysis: [Topic]
==================
Questions:
1. [Question 1]
2. [Question 2]
Data Collected:
- [Source 1]: [Data]
- [Source 2]: [Data]
Metrics Calculated:
- [Metric 1]: [Value]
- [Metric 2]: [Value]
Patterns/Trends Identified:
1. [Pattern 1]: [Evidence]
2. [Pattern 2]: [Evidence]
Insights:
- [Insight 1]
- [Insight 2]
Recommendations:
1. [Priority] [Recommendation 1]
2. [Priority] [Recommendation 2]
For More Information
- Code analysis techniques: references/code-analysis-guide.md
- Skill metrics: references/skill-metrics-guide.md
- Pattern recognition: references/pattern-recognition-guide.md
analysis transforms data into insights, enabling evidence-based improvement of code, skills, and processes throughout the development ecosystem.
