Imported from natea/ExoMind (skills/detecting-patterns/SKILL.md). Install upstream with npx skills add natea/ExoMind --skill detecting-patterns. Copyright stays with the author.

Pattern Detection Skill

Overview

Detect and analyze patterns in your productivity, habits, energy levels, and behaviors to generate actionable insights for optimization and improvement.

Trigger

• Monthly during life assessment
• Weekly during weekly review
• On-demand when seeking insights
• After significant life changes

Inputs

• Daily logs from memory/daily/
• Weekly reviews from memory/weekly/
• Monthly reviews from memory/monthly/
• Calendar events and meeting data
• Task completion records
• Energy and mood tracking data
• Goal progress metrics

Pattern Types

1. Productivity Patterns

What to detect:

• Peak productivity hours (morning/afternoon/evening)
• High-performance days of the week
• Task completion velocity patterns
• Deep work session duration patterns
• Context switching frequency

Analysis approach:

FOR each time_of_day in [morning, afternoon, evening]:
  CALCULATE average_tasks_completed
  CALCULATE average_quality_score
  CALCULATE average_energy_level

FOR each day_of_week:
  CALCULATE completion_rate
  CALCULATE focus_duration
  IDENTIFY recurring_blockers

2. Task Completion Patterns

What to detect:

• Tasks that consistently get done vs. delayed
• Task types that flow easily vs. create resistance
• Completion patterns by context (location, time, people)
• Procrastination triggers
• Task batching effectiveness

Analysis approach:

GROUP tasks BY [type, priority, context]
FOR each group:
  CALCULATE completion_rate
  CALCULATE average_delay
  IDENTIFY success_factors
  DETECT resistance_patterns

3. Meeting Patterns

What to detect:

• Productive vs. draining meeting types
• Optimal meeting times
• Meeting frequency impact on productivity
• Pre/post-meeting energy patterns
• Meeting preparation effectiveness

Analysis approach:

FOR each meeting:
  MEASURE pre_energy vs post_energy
  TRACK post_meeting_productivity
  CATEGORIZE by [type, duration, participants]
  CALCULATE roi_score

4. Habit Consistency Patterns

What to detect:

• Streak lengths and break patterns
• Trigger effectiveness
• Context dependencies
• Seasonal variations
• Recovery patterns after breaks

Analysis approach:

FOR each habit:
  CALCULATE streak_length
  IDENTIFY break_triggers
  DETECT optimal_contexts
  MEASURE recovery_time
  TRACK consistency_score

5. Goal Progress Patterns

What to detect:

• Sprint vs. steady progress patterns
• Momentum building factors
• Plateau triggers and durations
• Breakthrough moments
• Support system correlation

Analysis approach:

FOR each goal:
  PLOT progress_over_time
  IDENTIFY acceleration_points
  DETECT plateau_patterns
  CORRELATE with external_factors
  MEASURE milestone_velocity

6. Energy Drain Patterns

What to detect:

• Activities that consistently drain energy
• People or contexts that affect energy
• Recovery time requirements
• Energy management effectiveness
• Warning signs of burnout

Analysis approach:

FOR each activity:
  MEASURE energy_cost
  TRACK recovery_duration
  IDENTIFY draining_factors
  DETECT early_warning_signs
  CORRELATE with sleep_quality

Data Sources Configuration

Daily Log Structure

date: YYYY-MM-DD
energy_levels:
  morning: 1-10
  afternoon: 1-10
  evening: 1-10
tasks_completed:
  - id: task_id
    type: [deep_work, admin, creative, social]
    duration: minutes
    quality: 1-10
    context: location
meetings:
  - type: [1-on-1, team, client, internal]
    duration: minutes
    energy_before: 1-10
    energy_after: 1-10
    productivity_rating: 1-10
habits:
  - name: habit_name
    completed: boolean
    context: description
mood: [energized, focused, anxious, calm, drained]
notes: free_text

Weekly Review Structure

week_ending: YYYY-MM-DD
wins:
  - description
  - impact_level: 1-10
challenges:
  - description
  - energy_cost: 1-10
patterns_noticed:
  - observation
goal_progress:
  - goal_id
  - progress_percentage
  - momentum: [building, steady, stalled]
energy_assessment:
  overall: 1-10
  work_life_balance: 1-10

Monthly Review Structure

month: YYYY-MM
achievements:
  - milestone
  - satisfaction: 1-10
trends_identified:
  - pattern_description
areas_for_improvement:
  - area
  - priority: 1-10
habit_tracking:
  - habit_name
  - consistency_percentage
  - longest_streak
goal_status:
  - goal_id
  - progress
  - on_track: boolean

Analysis Methods

1. Time-of-Day Analysis

Purpose: Identify optimal times for different work types

Method:

def analyze_time_of_day(daily_logs):
    time_blocks = {
        'morning': (6, 12),
        'afternoon': (12, 18),
        'evening': (18, 24)
    }

    results = {}
    for block_name, (start, end) in time_blocks.items():
        results[block_name] = {
            'average_energy': calculate_avg_energy(logs, start, end),
            'tasks_completed': count_tasks(logs, start, end),
            'deep_work_duration': sum_deep_work(logs, start, end),
            'quality_score': avg_quality(logs, start, end)
        }

    return identify_peaks(results)

Output:

• Best time for deep work
• Optimal meeting times
• Low-energy periods for routine tasks
• Creative work windows

2. Day-of-Week Patterns

Purpose: Optimize weekly schedule structure

Method:

def analyze_weekly_patterns(data):
    days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']

    patterns = {}
    for day in days:
        day_data = filter_by_day(data, day)
        patterns[day] = {
            'productivity_score': calculate_productivity(day_data),
            'energy_level': avg_energy(day_data),
            'completion_rate': task_completion_rate(day_data),
            'focus_duration': avg_focus_time(day_data),
            'interruptions': count_interruptions(day_data)
        }

    return generate_day_recommendations(patterns)

Output:

• Best days for strategic work
• Meeting-heavy vs. focus-heavy days
• Energy recovery patterns
• Weekend spillover effects

3. Context Correlation Analysis

Purpose: Understand environmental and situational impacts

Method:

def analyze_context_correlation(tasks, contexts):
    correlations = {}

    for context in ['location', 'people', 'time', 'tools']:
        correlations[context] = {
            'success_rate': completion_rate_by_context(tasks, context),
            'energy_impact': avg_energy_by_context(tasks, context),
            'quality_score': avg_quality_by_context(tasks, context),
            'flow_state_frequency': flow_count_by_context(tasks, context)
        }

    return identify_optimal_contexts(correlations)

Output:

• Best working locations
• Productive collaborator patterns
• Tool effectiveness
• Environment optimization tips

4. Energy Level Tracking

Purpose: Optimize energy management and recovery

Method:

def analyze_energy_patterns(daily_logs):
    energy_data = extract_energy_levels(daily_logs)

    analysis = {
        'daily_curve': plot_average_energy_curve(energy_data),
        'recovery_patterns': identify_recovery_activities(energy_data),
        'drain_sources': detect_energy_drains(energy_data),
        'recharge_activities': find_recharge_patterns(energy_data),
        'burnout_indicators': check_burnout_signals(energy_data)
    }

    return generate_energy_recommendations(analysis)

Output:

• Energy peaks and valleys
• Effective recovery activities
• Warning signs to monitor
• Sustainable pace guidelines

5. Mood Correlation

Purpose: Link emotional states to performance and decisions

Method:

def analyze_mood_correlation(logs):
    mood_impacts = {}

    for mood in ['energized', 'focused', 'anxious', 'calm', 'drained']:
        mood_impacts[mood] = {
            'task_quality': avg_quality_by_mood(logs, mood),
            'completion_rate': completion_by_mood(logs, mood),
            'decision_quality': decision_outcomes_by_mood(logs, mood),
            'creativity_score': creativity_by_mood(logs, mood),
            'triggers': identify_mood_triggers(logs, mood)
        }

    return generate_mood_management_tips(mood_impacts)

Output:

• Mood-task matching guidelines
• Emotional trigger awareness
• Decision-making timing
• State management strategies

6. Success Factor Identification

Purpose: Replicate winning conditions

Method:

def identify_success_factors(achievements):
    factors = {
        'contextual': [],
        'behavioral': [],
        'environmental': [],
        'social': []
    }

    for achievement in high_quality_outcomes(achievements):
        factors['contextual'].extend(extract_context(achievement))
        factors['behavioral'].extend(extract_behaviors(achievement))
        factors['environmental'].extend(extract_environment(achievement))
        factors['social'].extend(extract_social_factors(achievement))

    return prioritize_factors_by_impact(factors)

Output:

• Repeatable success patterns
• Critical success factors
• Winning combinations
• Conditions to replicate

Insights Generation

1. Optimal Work Times

Template:

Your peak productivity windows:
- Deep Work: {time_range} on {days}
  - Average energy: {score}/10
  - Average quality: {score}/10
  - Success rate: {percentage}%

- Creative Work: {time_range} on {days}
  - Flow state frequency: {count} times/week
  - Breakthrough moments: most common at {time}

- Routine Tasks: {time_range} on {days}
  - Best for low-energy periods
  - Batch processing recommended

Recommendation: Schedule according to energy patterns, not arbitrary times.

2. Energy Drain Detection

Template:

Activities draining your energy:
1. {activity_type}
   - Energy cost: {score}/10
   - Recovery time: {duration}
   - Frequency: {times}/week
   - Total impact: {cumulative_cost}
   - Alternatives: {suggestions}

Warning signs detected:
- {pattern_1}: observed {frequency}
- {pattern_2}: trending {direction}

Recovery optimization:
- Current recovery time: {current}
- Optimal recovery time: {optimal}
- Gap: {difference} - {recommendation}

3. Productivity Blocker Analysis

Template:

Top productivity blockers:
1. {blocker_name}
   - Frequency: {times}/week
   - Impact: {lost_hours} hours lost
   - Pattern: {when_it_occurs}
   - Mitigation: {specific_action}

2. {blocker_name}
   - Context: {situation}
   - Trigger: {what_causes_it}
   - Prevention: {preventive_measure}

Quick wins:
- {easy_fix_1}: saves {time}/week
- {easy_fix_2}: reduces {blocker} by {percentage}%

4. Success Pattern Recognition

Template:

Your winning patterns:
1. {pattern_name}
   - Observed: {frequency} times
   - Success rate: {percentage}%
   - Key factors:
     * {factor_1}
     * {factor_2}
     * {factor_3}
   - How to replicate: {steps}

2. {pattern_name}
   - Context: {when_where}
   - Trigger: {what_starts_it}
   - Sustain: {how_to_maintain}

Breakthrough moments:
- Most common: {time/context}
- Prerequisites: {conditions}
- How to create more: {actionable_steps}

5. Habit Streak Analysis

Template:

Habit consistency insights:
{habit_name}:
- Current streak: {days} days
- Longest streak: {days} days
- Consistency: {percentage}% over {timeframe}
- Break patterns: most common on {days/contexts}
- Recovery: average {days} to restart
- Optimal conditions: {context_description}

Recommendations:
- Protect your streak by: {specific_actions}
- Warning signs: {early_indicators}
- Recovery plan: {if_break_occurs}

Recommendations Engine

1. Schedule Optimization

Algorithm:

def optimize_schedule(patterns):
    recommendations = []

    # Deep work blocks
    peak_times = patterns['productivity']['peak_hours']
    recommendations.append({
        'type': 'deep_work',
        'schedule': peak_times,
        'duration': patterns['optimal_session_length'],
        'protect': 'Block calendar, disable notifications'
    })

    # Meeting placement
    meeting_windows = patterns['meetings']['optimal_times']
    recommendations.append({
        'type': 'meetings',
        'schedule': meeting_windows,
        'max_per_day': patterns['meetings']['sustainable_count'],
        'buffer': 'Add 15-min recovery after'
    })

    # Routine tasks
    low_energy_times = patterns['energy']['valleys']
    recommendations.append({
        'type': 'routine',
        'schedule': low_energy_times,
        'batch': 'Group similar tasks',
        'automate': 'Consider automation for {repetitive_tasks}'
    })

    return recommendations

2. Task Type Allocation

Algorithm:

def allocate_task_types(patterns):
    allocations = {}

    # Match task types to optimal conditions
    for task_type in ['deep_work', 'creative', 'admin', 'social', 'strategic']:
        optimal_conditions = patterns[task_type]['success_factors']

        allocations[task_type] = {
            'best_time': optimal_conditions['time'],
            'best_day': optimal_conditions['day'],
            'best_location': optimal_conditions['location'],
            'best_duration': optimal_conditions['session_length'],
            'prerequisites': optimal_conditions['setup_needed'],
            'avoid': optimal_conditions['anti_patterns']
        }

    return allocations

3. Meeting Time Adjustments

Algorithm:

def adjust_meeting_times(patterns):
    adjustments = []

    # Analyze current meetings
    current_meetings = patterns['meetings']['current']
    impact_analysis = patterns['meetings']['impact']

    for meeting in current_meetings:
        if meeting['energy_drain'] > 7:
            adjustments.append({
                'meeting': meeting['type'],
                'current_time': meeting['time'],
                'issue': 'High energy drain',
                'suggested_time': find_better_time(meeting, patterns),
                'alternative': consider_async(meeting),
                'frequency': optimize_frequency(meeting, patterns)
            })

    return prioritize_adjustments(adjustments)

4. Habit Trigger Suggestions

Algorithm:

def suggest_habit_triggers(patterns):
    suggestions = []

    for habit in patterns['habits']:
        success_contexts = habit['successful_completions']

        # Implementation intention
        trigger = {
            'habit': habit['name'],
            'trigger_type': identify_best_trigger_type(success_contexts),
            'specific_trigger': create_if_then_plan(success_contexts),
            'location': success_contexts['most_common_location'],
            'time': success_contexts['most_common_time'],
            'preceding_action': success_contexts['common_previous_activity'],
            'accountability': suggest_accountability_mechanism(habit)
        }

        suggestions.append(trigger)

    return suggestions

5. Environment Change Recommendations

Algorithm:

def recommend_environment_changes(patterns):
    changes = []

    # Physical environment
    workspace_impact = patterns['context']['location_performance']
    changes.append({
        'category': 'workspace',
        'current_performance': workspace_impact['home']['score'],
        'improvements': identify_workspace_gaps(workspace_impact),
        'quick_wins': ['Noise reduction', 'Lighting optimization', 'Ergonomics'],
        'investment': prioritize_by_roi(improvements)
    })

    # Digital environment
    tool_effectiveness = patterns['context']['tool_usage']
    changes.append({
        'category': 'digital',
        'bottlenecks': identify_tool_bottlenecks(tool_effectiveness),
        'additions': suggest_tools(patterns['gaps']),
        'removals': identify_unused_tools(tool_effectiveness),
        'integrations': suggest_automation(patterns['repetitive_tasks'])
    })

    # Social environment
    collaboration_patterns = patterns['context']['people']
    changes.append({
        'category': 'social',
        'productive_collaborations': collaboration_patterns['high_impact'],
        'draining_interactions': collaboration_patterns['low_impact'],
        'boundary_suggestions': create_boundary_plan(collaboration_patterns),
        'collaboration_times': optimize_social_schedule(collaboration_patterns)
    })

    return changes

Output Format

Monthly Pattern Report

# Pattern Detection Report: {Month YYYY}

## Executive Summary
- Data analyzed: {number} days of logs
- Patterns detected: {count}
- Confidence level: {percentage}%
- Key insight: {most_significant_finding}

## Productivity Patterns
{time_of_day_analysis}
{day_of_week_patterns}
{peak_performance_windows}

## Energy Management
{energy_curve_visualization}
{drain_sources}
{recovery_effectiveness}
{optimization_opportunities}

## Task Completion
{completion_rate_trends}
{resistance_patterns}
{success_factors}

## Meeting Analysis
{meeting_effectiveness}
{time_recommendations}
{format_suggestions}

## Habit Tracking
{consistency_scores}
{streak_analysis}
{trigger_optimization}

## Goal Progress
{velocity_trends}
{momentum_indicators}
{adjustment_recommendations}

## Action Items
1. {high_priority_change}
2. {medium_priority_change}
3. {low_hanging_fruit}

## Experiments to Try
- {hypothesis_1}
- {hypothesis_2}
- {hypothesis_3}

## Next Review
Schedule: {date}
Focus areas: {areas_to_monitor}

Integration with Other Skills

With Life Assessment

• Provide data-driven insights for annual assessment
• Track year-over-year pattern evolution
• Identify seasonal variations

With Weekly Review

• Auto-generate pattern observations
• Highlight anomalies for reflection
• Track pattern consistency week-over-week

With Goal Setting

• Inform realistic goal timelines based on patterns
• Suggest optimal approaches based on success patterns
• Identify blockers to address

With Daily Planning

• Optimize daily schedule based on patterns
• Suggest task types for each time block
• Predict energy levels for planning

Implementation Checklist

• Set up data collection in daily logs
• Configure weekly review to capture patterns
• Create monthly review pattern section
• Define minimum data requirements (4+ weeks)
• Implement analysis scripts
• Create visualization templates
• Build recommendation engine
• Test with historical data
• Schedule first pattern detection session
• Integrate with other Life OS skills

Success Metrics

• Pattern detection accuracy: >80%
• Actionable insights per report: >5
• Implemented recommendations: >50%
• Measured improvement in areas addressed: >20%
• User satisfaction with insights: >8/10

Continuous Improvement

Monthly

• Refine pattern detection algorithms
• Add new pattern types based on discoveries
• Improve recommendation accuracy

Quarterly

• Validate pattern predictions against outcomes
• Update analysis methods
• Expand data sources

Annually

• Major algorithm updates
• Add machine learning models
• Comprehensive effectiveness review

This skill helps you understand yourself better through data, leading to more intentional and optimized life design.