メニュー
Standard work documentation skill for work instruction creation and maintenance.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/a5c-ai/babysitter --skill standard-work-documenterコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
Reference for querying the Atlas knowledge graph through its MCP tools — the SECONDARY enrichment/comparison layer that adds best-practice context to systems you have ALREADY scanned from your real sources (`az`, repos, dirs). Use when you need to look up nodes, edges, kinds, clusters, stats, or wiki pages in Atlas to compare against your real inventory. (atlas graph, query atlas, atlas mcp, search the graph, graph neighbors, atlas record, atlas kinds, enrichment layer)
Atlas turns your STATED NEED into a real systems atlas by SCANNING your actual sources (Azure via `az`, git repos, local dirs) and process/data mining them, THEN enriching against the Atlas knowledge graph. Use this skill when asked to inventory/map your real systems, scan your cloud + repos + directories, mine the real processes or data they contain, or collect their real constraints/gotchas. (atlas, scan my systems, inventory our azure account, map my repos, real systems atlas, process mining, data mining, collect nuances, system discovery)
This skill should be used when the user asks to "find skills in the wild", "assimilate popular workflows", "discover SKILL.md files in repos", "research external skills", "find workflow patterns", "survey the skill landscape", "what skills exist out there", or wants to investigate public repositories for extractable processes, babysitter plugins, and reusable procedural insights. Searches GitHub for SKILL.md files, classifies repos by archetype, and maintains structured research under docs/reference-repos/.
SKILL.md を表示中
SOC 職業分類に基づく
| 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"]} |
You are standard-work-documenter - a specialized skill for creating and maintaining standard work documentation for consistent and improvable operations.
This skill enables AI-powered standard work documentation including:
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 add_element(self, description: str, element_type: ElementType,
time: float, key_points: List[str], **kwargs):
element = WorkElement(
sequence=len(self.elements) + 1,
description=description,
element_type=element_type,
time_seconds=time,
key_points=key_points,
**kwargs
)
self.elements.append(element)
return element
def summary(self):
manual_time = sum(e.time_seconds for e in self.elements
if e.element_type == ElementType.MANUAL)
walk_time = sum(e.time_seconds for e in self.elements
if e.element_type == ElementType.WALK)
wait_time = sum(e.time_seconds for e in self.elements
if e.element_type == ElementType.WAIT)
auto_time = sum(e.time_seconds for e in self.elements
if e.element_type == ElementType.AUTO)
total_cycle_time = manual_time + walk_time + wait_time
return {
"operation": self.operation_name,
"total_elements": len(self.elements),
"manual_time": manual_time,
"walk_time": walk_time,
"wait_time": wait_time,
"auto_time": auto_time,
"cycle_time": total_cycle_time,
"takt_time": self.takt_time,
"takt_attainment": self.takt_time / total_cycle_time * 100 if total_cycle_time > 0 else 0
}
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),
"max": np.max(times),
"cv": np.std(times, ddof=1) / np.mean(times) * 100,
"ci_95": stats.t.interval(0.95, len(times)-1,
loc=np.mean(times),
scale=stats.sem(times))
}
def calculate_standard_time(self, element_name: str,
performance_rating: float = 1.0,
allowance_factor: float = 1.15):
"""
Standard Time = Normal Time x Allowance Factor
Normal Time = Observed Time x Performance Rating
"""
analysis = self.analyze_element(element_name)
if not analysis:
return None
observed_time = analysis['mean']
normal_time = observed_time * performance_rating
standard_time = normal_time * allowance_factor
return {
"element": element_name,
"observed_time": observed_time,
"performance_rating": performance_rating,
"normal_time": normal_time,
"allowance_factor": allowance_factor,
"standard_time": standard_time
}
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"]["walk"] += element.time_seconds
elif element.element_type == ElementType.WAIT:
sheet["totals"]["wait"] += element.time_seconds
elif element.element_type == ElementType.AUTO:
sheet["totals"]["auto"] += element.time_seconds
# Auto time runs parallel, others sequential
if element.element_type != ElementType.AUTO:
current_time += element.time_seconds
sheet["totals"]["cycle_time"] = current_time
return sheet
def render_combination_chart(sheet, output_format='text'):
"""
Render visual representation of combination sheet
"""
takt = sheet["header"]["takt_time"]
max_time = max(takt, sheet["totals"]["cycle_time"])
# Text-based chart
chart_width = 60
scale = chart_width / max_time
lines = []
lines.append(f"Standard Work Combination Sheet")
lines.append(f"Takt Time: {takt:.1f}s | Cycle Time: {sheet['totals']['cycle_time']:.1f}s")
lines.append("=" * (chart_width + 20))
# Draw takt line position
takt_pos = int(takt * scale)
for entry in sheet["timeline"]:
start_pos = int(entry["start_time"] * scale)
end_pos = int(entry["end_time"] * scale)
# Choose symbol based on type
symbols = {
"manual": "M",
"walk": "W",
"wait": ".",
"auto": "A"
}
symbol = symbols.get(entry["type"], "?")
bar = " " * start_pos + symbol * (end_pos - start_pos)
bar = bar[:chart_width]
# Add takt marker
if takt_pos < len(bar):
bar = bar[:takt_pos] + "|" + bar[takt_pos+1:]
lines.append(f"{entry['sequence']:2d}. {entry['description'][:15]:15s} {bar}")
return "\n".join(lines)
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["steps"].append(step)
return sheet
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"] += in_process
standard_wip["buffer"] += buffer
standard_wip["total"] = standard_wip["in_process"] + standard_wip["buffer"]
return standard_wip
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>'
if element.tools_required:
html += f'<p><strong>Tools:</strong> {", ".join(element.tools_required)}</p>'
html += "</div>"
html += "</body></html>"
return html
return None
This skill integrates with the following processes:
standard-work-development.jsline-balancing-analysis.jskaizen-event-facilitation.js{
"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"
]
}