standard-work-documenter

name	standard-work-documenter
description	Standard work documentation skill for work instruction creation and maintenance.
allowed-tools	Bash(*) Read Write Edit Glob Grep WebFetch
metadata	{"author":"babysitter-sdk","version":"1.0.0","category":"lean-manufacturing","backlog-id":"SK-IE-013"}
graph	{"domains":["domain:industrial-engineering"],"skillAreas":["skill-area:statistical-analysis","skill-area:organizational-design","skill-area:data-analysis"],"roles":["role:operations-analyst","role:research-engineer"]}

standard-work-documenter

You are standard-work-documenter - a specialized skill for creating and maintaining standard work documentation for consistent and improvable operations.

Overview

This skill enables AI-powered standard work documentation including:

• Work element breakdown
• Time observation recording
• Standard work combination sheet generation
• Standard work layout diagram creation
• Job instruction breakdown sheet formatting
• Standard WIP calculation
• Visual work instruction creation
• Multi-format output (print, digital, video)

Capabilities

1. Work Element Breakdown

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

class ElementType(Enum):
    MANUAL = "manual"  # Operator work
    WALK = "walk"  # Movement
    WAIT = "wait"  # Waiting for machine
    AUTO = "auto"  # Machine automatic time

@dataclass
class WorkElement:
    sequence: int
    description: str
    element_type: ElementType
    time_seconds: float
    key_points: List[str]
    safety_notes: str = ""
    quality_checks: List[str] = None
    tools_required: List[str] = None

class StandardWorkBreakdown:
    """
    Break down work into standardized elements
    """
    def __init__(self, operation_name: str, takt_time: float):
        self.operation_name = operation_name
        self.takt_time = takt_time
        self.elements: List[WorkElement] = []

    def ():
        element = WorkElement(
            sequence=(.elements) + ,
            description=description,
            element_type=element_type,
            time_seconds=time,
            key_points=key_points,
            **kwargs
        )
        .elements.append(element)
         element

     ():
        manual_time = (e.time_seconds  e  .elements
                         e.element_type == ElementType.MANUAL)
        walk_time = (e.time_seconds  e  .elements
                        e.element_type == ElementType.WALK)
        wait_time = (e.time_seconds  e  .elements
                        e.element_type == ElementType.WAIT)
        auto_time = (e.time_seconds  e  .elements
                        e.element_type == ElementType.AUTO)

        total_cycle_time = manual_time + walk_time + wait_time

         {
            : .operation_name,
            : (.elements),
            : manual_time,
            : walk_time,
            : wait_time,
            : auto_time,
            : total_cycle_time,
            : .takt_time,
            : .takt_time / total_cycle_time *   total_cycle_time >   
        }

2. Time Observation Recording

import numpy as np
from scipy import stats

class TimeStudyRecorder:
    """
    Record and analyze time observations
    """
    def __init__(self, operation_name: str, num_cycles: int = 10):
        self.operation_name = operation_name
        self.target_cycles = num_cycles
        self.observations = {}  # {element_name: [times]}

    def record_observation(self, element_name: str, time: float):
        if element_name not in self.observations:
            self.observations[element_name] = []
        self.observations[element_name].append(time)

    def analyze_element(self, element_name: str):
        times = self.observations.get(element_name, [])
        if not times:
            return None

        return {
            "element": element_name,
            "observations": len(times),
            "mean": np.mean(times),
            "std": np.std(times, ddof=1),
            "min": np.min(times),
            : np.(times),
            : np.std(times, ddof=) / np.mean(times) * ,
            : stats.t.interval(, (times)-,
                                      loc=np.mean(times),
                                      scale=stats.sem(times))
        }

     ():
        
        analysis = .analyze_element(element_name)
          analysis:
             

        observed_time = analysis[]
        normal_time = observed_time * performance_rating
        standard_time = normal_time * allowance_factor

         {
            : element_name,
            : observed_time,
            : performance_rating,
            : normal_time,
            : allowance_factor,
            : standard_time
        }

3. Standard Work Combination Sheet

def generate_combination_sheet(elements: List[WorkElement], takt_time: float):
    """
    Generate standard work combination sheet
    Shows manual work, walk, wait, and auto time on timeline
    """
    sheet = {
        "header": {
            "operation": "",
            "takt_time": takt_time,
            "date": "",
            "revision": ""
        },
        "timeline": [],
        "totals": {
            "manual": 0,
            "walk": 0,
            "wait": 0,
            "auto": 0,
            "cycle_time": 0
        }
    }

    current_time = 0
    for element in elements:
        entry = {
            "sequence": element.sequence,
            "description": element.description,
            "type": element.element_type.value,
            "start_time": current_time,
            "duration": element.time_seconds,
            "end_time": current_time + element.time_seconds
        }
        sheet["timeline"].append(entry)

        # Update totals
        if element.element_type == ElementType.MANUAL:
            sheet["totals"]["manual"] += element.time_seconds
        elif element.element_type == ElementType.WALK:
            sheet["totals"][] += element.time_seconds
         element.element_type == ElementType.WAIT:
            sheet[][] += element.time_seconds
         element.element_type == ElementType.AUTO:
            sheet[][] += element.time_seconds

        
         element.element_type != ElementType.AUTO:
            current_time += element.time_seconds

    sheet[][] = current_time

     sheet

 ():
    
    takt = sheet[][]
    max_time = (takt, sheet[][])

    
    chart_width = 
    scale = chart_width / max_time

    lines = []
    lines.append()
    lines.append()
    lines.append( * (chart_width + ))

    
    takt_pos = (takt * scale)

     entry  sheet[]:
        start_pos = (entry[] * scale)
        end_pos = (entry[] * scale)

        
        symbols = {
            : ,
            : ,
            : ,
            : 
        }
        symbol = symbols.get(entry[], )

        bar =  * start_pos + symbol * (end_pos - start_pos)
        bar = bar[:chart_width]

        
         takt_pos < (bar):
            bar = bar[:takt_pos] +  + bar[takt_pos+:]

        lines.append()

     .join(lines)

4. Job Instruction Breakdown Sheet

def generate_job_instruction_sheet(elements: List[WorkElement]):
    """
    Create Training Within Industry (TWI) style job instruction sheet
    """
    sheet = {
        "operation": "",
        "equipment": "",
        "materials": [],
        "safety_ppe": [],
        "steps": []
    }

    for element in elements:
        step = {
            "important_step": element.description,
            "key_points": element.key_points,
            "reasons": []
        }

        # Generate reasons for key points
        for kp in element.key_points:
            if "safety" in kp.lower():
                step["reasons"].append("Prevents injury")
            elif "quality" in kp.lower():
                step["reasons"].append("Ensures quality")
            elif any(word in kp.lower() for word in ["easy", "efficient"]):
                step["reasons"].append("Makes work easier")
            else:
                step["reasons"].append("Required for proper operation")

        if element.safety_notes:
            step["safety_highlight"] = element.safety_notes

        sheet[].append(step)

     sheet

5. Standard WIP Calculation

def calculate_standard_wip(processes: List[dict], takt_time: float):
    """
    Calculate standard work-in-process inventory

    Standard WIP = Sum of:
    - In-process WIP (parts being worked on)
    - Buffer WIP (between processes if needed)
    """
    standard_wip = {
        "in_process": 0,
        "buffer": 0,
        "total": 0,
        "by_process": []
    }

    for i, process in enumerate(processes):
        # In-process WIP: 1 part per machine/operator
        in_process = process.get('num_machines', 1)

        # Buffer WIP: needed if cycle time > takt time or machine unreliability
        buffer = 0
        cycle_time = process.get('cycle_time', 0)
        uptime = process.get('uptime', 100) / 100

        if cycle_time > takt_time or uptime < 0.95:
            # Calculate buffer based on replenishment time
            buffer = max(1, int((cycle_time / takt_time) * (1 / uptime - 1)))

        standard_wip["by_process"].append({
            "process": process.get('name', f'Process {i+1}'),
            "in_process_wip": in_process,
            "buffer_wip": buffer
        })

        standard_wip[] += in_process
        standard_wip[] += buffer

    standard_wip[] = standard_wip[] + standard_wip[]

     standard_wip

6. Visual Work Instruction Generation

def generate_visual_instruction(elements: List[WorkElement], output_format='html'):
    """
    Generate visual work instructions with step-by-step guidance
    """
    if output_format == 'html':
        html = """
        <html>
        <head>
            <style>
                .step { margin: 20px; padding: 15px; border: 1px solid #ccc; }
                .step-number { font-size: 24px; font-weight: bold; color: #007bff; }
                .key-point { background-color: #fff3cd; padding: 5px; margin: 5px 0; }
                .safety { background-color: #f8d7da; padding: 5px; margin: 5px 0; }
                .quality { background-color: #d4edda; padding: 5px; margin: 5px 0; }
                .time { color: #6c757d; font-size: 12px; }
            </style>
        </head>
        <body>
            <h1>Visual Work Instructions</h1>
        """

        for element in elements:
            html += f"""
            <div class="step">
                <span class="step-number">{element.sequence}</span>
                <h3>{element.description}</h3>
                <p class="time">Target Time: {element.time_seconds:.1f} seconds</p>

                <h4>Key Points:</h4>
            """

            for kp in element.key_points:
                css_class = "key-point"
                if "safety" in kp.lower():
                    css_class = "safety"
                elif "quality" in kp.lower():
                    css_class = "quality"
                html += f'<div class="{css_class}">{kp}</div>'

            if element.safety_notes:
                html += f'<div class="safety"><strong>SAFETY:</strong> {element.safety_notes}</div>'

             element.tools_required:
                html += 

            html += 

        html += 
         html

     

Process Integration

This skill integrates with the following processes:

• standard-work-development.js
• line-balancing-analysis.js
• kaizen-event-facilitation.js

Output Format

{
  "operation": "Assembly Station 3",
  "elements": 8,
  "cycle_time_seconds": 52.5,
  "takt_time_seconds": 60.0,
  "takt_attainment_percent": 114.3,
  "breakdown": {
    "manual_time": 38.0,
    "walk_time": 6.5,
    "wait_time": 8.0
  },
  "standard_wip": 3,
  "documents_generated": [
    "combination_sheet.pdf",
    "job_instruction.pdf",
    "visual_instructions.html"
  ]
}

Best Practices

1. Observe multiple cycles - Get representative times
2. Include all elements - Don't skip small tasks
3. Document key points - Capture the "how"
4. Keep it visual - Pictures > words
5. Version control - Track revisions
6. Involve operators - They know best

Constraints

• Standard work must be achievable
• Safety is non-negotiable
• Update when process changes
• Train to the standard