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:
- Analysis scope clearly defined
- Key metrics collected
- Patterns identified (at least 2-3)
- Code smells detected (if any)
- Quality assessment completed
- Actionable insights generated
- Recommendations prioritized
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 issuesOperation 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:
- Skill metrics collected for all skills
- Usage patterns analyzed
- Effectiveness assessed (evidence-based)
- Improvement opportunities identified
- Recommendations prioritized
- Actionable insights generated
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:
- Process mapped completely
- Metrics collected for all steps
- Bottlenecks identified (at least 1-2)
- Efficiency analysis completed
- Optimization opportunities found
- Recommendations prioritized by impact
- Estimated improvement quantified
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:
- Analysis questions clearly defined
- Data collected completely
- Metrics calculated correctly
- Trends identified (improving/degrading/stable)
- Insights generated (what data shows)
- Recommendations actionable
- Conclusions evidence-based
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 predictionOperation 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:
- Multiple artifacts analyzed (3+ minimum)
- Recurring themes identified (2+ patterns)
- Patterns categorized by type
- Significance assessed (frequency, impact)
- Insights evidence-based (not speculation)
- Recommendations actionable
- Learnings documented for future use
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 patternsBest 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.