smed-analyzer

name	smed-analyzer
description	Single Minute Exchange of Die analysis skill for changeover time reduction.
allowed-tools	Bash(*) Read Write Edit Glob Grep WebFetch
metadata	{"author":"babysitter-sdk","version":"1.0.0","category":"lean-manufacturing","backlog-id":"SK-IE-011"}

smed-analyzer

You are smed-analyzer - a specialized skill for analyzing and reducing changeover times using the Single Minute Exchange of Die (SMED) methodology.

Overview

This skill enables AI-powered SMED analysis including:

• Changeover video analysis
• Internal vs external activity separation
• Activity timing and sequencing
• Conversion opportunity identification
• Parallel work assignment
• Quick-release mechanism suggestions
• Before/after comparison reports
• Standard changeover documentation

Prerequisites

• Video recording capability
• Stopwatch or timing software
• Understanding of changeover process

Capabilities

1. Changeover Activity Recording

from dataclasses import dataclass
from enum import Enum
from typing import List, Optional
import datetime

class ActivityType(Enum):
    INTERNAL = "internal"  # Machine must be stopped
    EXTERNAL = "external"  # Can be done while running

@dataclass
class ChangeoverActivity:
    id: int
    description: str
    start_time: float  # seconds from changeover start
    end_time: float
    activity_type: ActivityType
    operator: str
    tools_required: List[str]
    notes: Optional[str] = None

    @property
    def duration(self):
        return self.end_time - self.start_time

class ChangeoverAnalysis:
    """
    Record and analyze changeover activities
    """
    def __init__(self, machine_name: str, from_product: str, to_product: str):
        self.machine_name = machine_name
        self.from_product = from_product
        self.to_product = to_product
        self.activities: List[ChangeoverActivity] = []
        self.timestamp = datetime.datetime.now()

    def add_activity(self, description, start, end, activity_type,
                    operator, tools=None, notes=None):
        activity = ChangeoverActivity(
            id=len(self.activities) + 1,
            description=description,
            start_time=start,
            end_time=end,
            activity_type=activity_type,
            operator=operator,
            tools_required=tools or [],
            notes=notes
        )
        self.activities.append(activity)
        return activity

    def summary(self):
        internal = [a for a in self.activities if a.activity_type == ActivityType.INTERNAL]
        external = [a for a in self.activities if a.activity_type == ActivityType.EXTERNAL]

        return {
            "total_changeover_time": max(a.end_time for a in self.activities),
            "internal_time": sum(a.duration for a in internal),
            "external_time": sum(a.duration for a in external),
            "num_activities": len(self.activities),
            "num_internal": len(internal),
            "num_external": len(external)
        }

2. Internal/External Separation Analysis

def analyze_internal_external(activities):
    """
    Identify activities that could be converted from internal to external
    """
    conversion_opportunities = []

    for activity in activities:
        if activity.activity_type == ActivityType.INTERNAL:
            # Check for conversion potential
            potential = assess_conversion_potential(activity)
            if potential['can_convert']:
                conversion_opportunities.append({
                    "activity_id": activity.id,
                    "description": activity.description,
                    "current_duration": activity.duration,
                    "conversion_method": potential['method'],
                    "estimated_savings": potential['savings'],
                    "investment_required": potential['investment']
                })

    return conversion_opportunities

def assess_conversion_potential(activity):
    """
    Assess if internal activity can become external
    """
    # Keywords indicating conversion potential
    prep_keywords = ['get', 'find', 'look for', 'search', 'locate', 'bring']
    adjustment_keywords = ['adjust', 'set', 'calibrate', 'tune']
    removal_keywords = ['remove', 'take off', 'disconnect']

    desc_lower = activity.description.lower()

    # Preparation activities can often be done externally
     (kw  desc_lower  kw  prep_keywords):
         {
            : ,
            : ,
            : activity.duration * ,  
            : 
        }

    
     (kw  desc_lower  kw  adjustment_keywords):
         {
            : ,
            : ,
            : activity.duration * ,
            : 
        }

     {: }

3. Parallel Work Analysis

def analyze_parallel_opportunities(activities, available_operators):
    """
    Identify activities that can be done in parallel
    """
    # Group activities by time window
    timeline = []

    for activity in activities:
        timeline.append({
            'time': activity.start_time,
            'type': 'start',
            'activity': activity
        })
        timeline.append({
            'time': activity.end_time,
            'type': 'end',
            'activity': activity
        })

    timeline.sort(key=lambda x: x['time'])

    # Analyze operator utilization
    parallel_opportunities = []
    current_activities = []

    for event in timeline:
        if event['type'] == 'start':
            current_activities.append(event['activity'])
        else:
            current_activities.remove(event['activity'])

        # Check if operators are idle
        active_operators = len(set(a.operator for a in current_activities))
        idle_operators = available_operators - active_operators

        if idle_operators > 0 and len(current_activities) > 0:
            parallel_opportunities.append({
                'time': event['time'],
                'idle_operators': idle_operators,
                'active_activities': [a.description  a  current_activities]
            })

     parallel_opportunities

 ():
    
    
    assignments = {i: []  i  (available_operators)}
    operator_end_times = [] * available_operators

    
    sorted_activities = (activities, key= a: a.start_time)

     activity  sorted_activities:
        
        earliest_op = ((available_operators),
                         key= i: operator_end_times[i])

        
        new_start = (activity.start_time, operator_end_times[earliest_op])
        new_end = new_start + activity.duration

        assignments[earliest_op].append({
            : activity.description,
            : activity.start_time,
            : new_start,
            : new_end
        })

        operator_end_times[earliest_op] = new_end

    new_total_time = (operator_end_times)
    original_total_time = (a.end_time  a  activities)

     {
        : assignments,
        : original_total_time,
        : new_total_time,
        : original_total_time - new_total_time,
        : ( - new_total_time/original_total_time) * 
    }

4. Quick-Release Mechanism Suggestions

def suggest_quick_release_mechanisms(activities):
    """
    Suggest engineering improvements for faster changeovers
    """
    suggestions = []

    for activity in activities:
        desc_lower = activity.description.lower()

        # Fastener improvements
        if any(word in desc_lower for word in ['bolt', 'screw', 'nut', 'fasten']):
            suggestions.append({
                'activity': activity.description,
                'current_method': 'Threaded fasteners',
                'improvement': 'Quick-release clamps, cam locks, or quarter-turn fasteners',
                'typical_reduction': '70-90%',
                'investment_level': 'Medium'
            })

        # Tool changes
        if 'tool' in desc_lower and 'change' in desc_lower:
            suggestions.append({
                'activity': activity.description,
                'current_method': 'Manual tool change',
                'improvement': 'Quick-change tool holders with preset tooling',
                'typical_reduction': '80-95%',
                'investment_level': 'Medium-High'
            })

        # Positioning/alignment
        if (word  desc_lower  word  [, , ]):
            suggestions.append({
                : activity.description,
                : ,
                : ,
                : ,
                : 
            })

        
         (word  desc_lower  word  [, , ]):
            suggestions.append({
                : activity.description,
                : ,
                : ,
                : ,
                : 
            })

     suggestions

5. Before/After Comparison

def generate_comparison_report(before_analysis, after_analysis):
    """
    Generate before/after SMED comparison report
    """
    before_summary = before_analysis.summary()
    after_summary = after_analysis.summary()

    return {
        'changeover': {
            'machine': before_analysis.machine_name,
            'product_change': f"{before_analysis.from_product} -> {before_analysis.to_product}"
        },
        'time_comparison': {
            'before': {
                'total_minutes': before_summary['total_changeover_time'] / 60,
                'internal_minutes': before_summary['internal_time'] / 60,
                'external_minutes': before_summary['external_time'] / 60
            },
            'after': {
                'total_minutes': after_summary['total_changeover_time'] / 60,
                'internal_minutes': after_summary['internal_time'] / 60,
                'external_minutes': after_summary['external_time'] / 60
            }
        },
        'improvement': {
            'time_reduction_minutes': (before_summary['total_changeover_time'] -
                                       after_summary['total_changeover_time']) / 60,
            'percent_reduction': (1 - after_summary['total_changeover_time'] /
                                 before_summary[]) * ,
            : ( - after_summary[] /
                                          before_summary[]) * 
        },
        : {
            : before_summary[],
            : after_summary[],
            : before_summary[] - after_summary[]
        }
    }

6. Standard Changeover Documentation

def generate_standard_changeover(optimized_analysis):
    """
    Create standard work document for changeover
    """
    document = {
        'title': f"Standard Changeover: {optimized_analysis.machine_name}",
        'revision': '1.0',
        'date': datetime.datetime.now().isoformat(),
        'target_time_minutes': optimized_analysis.summary()['total_changeover_time'] / 60,
        'preparation_phase': {
            'description': 'Activities to complete BEFORE stopping machine',
            'activities': []
        },
        'changeover_phase': {
            'description': 'Activities performed while machine is stopped',
            'activities': []
        },
        'startup_phase': {
            'description': 'Activities to complete after starting machine',
            'activities': []
        }
    }

    for activity in optimized_analysis.activities:
        entry = {
            'step': activity.id,
            'description': activity.description,
            'time_seconds': activity.duration,
            'operator': activity.operator,
            'tools': activity.tools_required,
            'notes': activity.notes
        }

        if activity.activity_type == ActivityType.EXTERNAL:
            if activity.start_time < 0:  # Prep phase
                document['preparation_phase'][].append(entry)
            :
                document[][].append(entry)
        :
            document[][].append(entry)

     document

Process Integration

This skill integrates with the following processes:

• setup-time-reduction-smed.js
• kaizen-event-facilitation.js
• oee-improvement.js

Output Format

{
  "current_state": {
    "total_changeover_minutes": 45,
    "internal_minutes": 38,
    "external_minutes": 7
  },
  "opportunities": {
    "convert_to_external": 5,
    "parallel_execution": 3,
    "quick_release": 4,
    "eliminate": 2
  },
  "projected_future_state": {
    "total_changeover_minutes": 12,
    "reduction_percent": 73
  },
  "implementation_plan": {
    "phase_1": "Convert preparation to external",
    "phase_2" 
     
  

Best Practices

1. Video record changeovers - Capture actual process
2. Involve operators - They know the details
3. Separate internal/external first - Quick wins
4. Standardize before optimizing - Consistent baseline
5. Measure before and after - Validate improvements
6. Document standard work - Sustain the gains

Constraints

• Safety cannot be compromised for speed
• Validate quality after changeover
• Consider operator ergonomics
• Document all standard procedures