用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/a5c-ai/babysitter --skill time-study-analyzer命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 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/.
基于 SOC 职业分类
正在显示 SKILL.md
| name | time-study-analyzer |
| description | Time study analysis skill with stopwatch methods, performance rating, and standard time calculation. |
| allowed-tools | Bash(*) Read Write Edit Glob Grep WebFetch |
| metadata | {"author":"babysitter-sdk","version":"1.0.0","category":"work-measurement","backlog-id":"SK-IE-034"} |
| 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 time-study-analyzer - a specialized skill for time study analysis including stopwatch methods, performance rating, and standard time calculation.
This skill enables AI-powered time study analysis including:
numpy np
pandas pd
scipy stats
():
results = {}
element observations[].unique():
element_data = observations[observations[] == element]
times = element_data[].values
ratings = element_data[].values
q1, q3 = np.percentile(times, [, ])
iqr = q3 - q1
lower_bound = q1 - * iqr
upper_bound = q3 + * iqr
valid_mask = (times >= lower_bound) & (times <= upper_bound)
valid_times = times[valid_mask]
valid_ratings = ratings[valid_mask]
observed_time = np.mean(valid_times)
avg_rating = np.mean(valid_ratings) /
normal_time = observed_time * avg_rating
results[element] = {
: (times),
: (times) - (valid_times),
: (observed_time, ),
: (np.std(valid_times), ),
: (avg_rating * , ),
: (normal_time, )
}
{
: results,
: (e[] e results.values())
}
def apply_performance_rating(observed_time: float, rating_method: str,
rating_factors: dict = None):
"""
Apply performance rating to observed time
rating_method: 'pace', 'westinghouse', 'synthetic', 'objective'
rating_factors: method-specific factors
"""
if rating_method == 'pace':
# Simple pace rating (100 = normal)
rating = rating_factors.get('pace', 100) / 100
normal_time = observed_time * rating
elif rating_method == 'westinghouse':
# Westinghouse system with four factors
skill = rating_factors.get('skill', 0) # -0.22 to +0.15
effort = rating_factors.get('effort', 0) # -0.17 to +0.13
conditions = rating_factors.get('conditions', 0) # -0.07 to +0.06
consistency = rating_factors.get('consistency', 0) # -0.04 to +0.04
total_adjustment = skill + effort + conditions + consistency
rating = 1 + total_adjustment
normal_time = observed_time * rating
elif rating_method == 'synthetic':
# Based on predetermined time comparison
benchmark_time = rating_factors.get('benchmark_time', observed_time)
rating = benchmark_time / observed_time
normal_time = benchmark_time # Use benchmark as normal
elif rating_method == 'objective':
# Based on pace and difficulty
pace = rating_factors.get('pace', 100) / 100
difficulty = rating_factors.get('difficulty', 1.0)
rating = pace * difficulty
normal_time = observed_time * rating
else:
rating = 1.0
normal_time = observed_time
return {
"method": rating_method,
"observed_time": observed_time,
"rating": round(rating * 100, 1),
"normal_time": round(normal_time, 3),
"factors_applied": rating_factors
}
def westinghouse_lookup():
"""Return Westinghouse rating tables"""
return {
"skill": {
"A1 - Superskill": 0.15, "A2 - Superskill": 0.13,
"B1 - Excellent": 0.11, "B2 - Excellent": 0.08,
"C1 - Good": 0.06, "C2 - Good": 0.03,
"D - Average": 0.00,
"E1 - Fair": -0.05, "E2 - Fair": -0.10,
"F1 - Poor": -0.16, "F2 - Poor": -0.22
},
"effort": {
"A1 - Excessive": 0.13, "A2 - Excessive": 0.12,
"B1 - Excellent": 0.10, "B2 - Excellent": 0.08,
"C1 - Good": 0.05, "C2 - Good": 0.02,
"D - Average": 0.00,
"E1 - Fair": -0.04, "E2 - Fair": -0.08,
"F1 - Poor": -0.12, "F2 - Poor": -0.17
},
"conditions": {
"A - Ideal": 0.06, "B - Excellent": 0.04,
"C - Good": 0.02, "D - Average": 0.00,
"E - Fair": -0.03, "F - Poor": -0.07
},
"consistency": {
"A - Perfect": 0.04, "B - Excellent": 0.03,
"C - Good": 0.01, "D - Average": 0.00,
"E - Fair": -0.02, "F - Poor": -0.04
}
}
def calculate_allowances(normal_time: float, allowance_factors: dict):
"""
Calculate allowances and standard time
allowance_factors:
- personal: percentage (typically 5%)
- fatigue: percentage (varies by job)
- delay: percentage (unavoidable delays)
- special: any special allowances
"""
personal = allowance_factors.get('personal', 5)
fatigue = allowance_factors.get('fatigue', 4)
delay = allowance_factors.get('delay', 5)
special = allowance_factors.get('special', 0)
# Total allowance percentage
total_allowance_pct = personal + fatigue + delay + special
# Calculate standard time
# Method 1: Add to normal time
allowance_time = normal_time * (total_allowance_pct / 100)
standard_time_add = normal_time + allowance_time
# Method 2: Divide by (1 - allowance factor) - more common
pfd_factor = total_allowance_pct / 100
standard_time_mult = normal_time / (1 - pfd_factor) if pfd_factor < 1 else normal_time * 2
return {
"normal_time": round(normal_time, 3),
"allowances": {
"personal": personal,
"fatigue": fatigue,
"delay": delay,
"special": special,
"total_percent": total_allowance_pct
},
"standard_time": round(standard_time_mult, 3),
"method": "multiplicative",
"pieces_per_hour": round(60 / standard_time_mult, 1) if standard_time_mult > 0 else 0
}
def determine_sample_size(pilot_data: list, confidence: float = 0.95,
accuracy: float = 0.05):
"""
Determine required sample size for time study
pilot_data: initial observations
confidence: confidence level (0.95 or 0.99 typical)
accuracy: desired accuracy as proportion of mean (e.g., 0.05 = ±5%)
"""
n_pilot = len(pilot_data)
mean = np.mean(pilot_data)
std_dev = np.std(pilot_data, ddof=1)
cv = std_dev / mean # Coefficient of variation
# Z-score for confidence level
z = stats.norm.ppf(1 - (1 - confidence) / 2)
# Required sample size
# n = (z * s / (A * x̄))²
# where A is desired accuracy proportion
required_n = (z * std_dev / (accuracy * mean)) ** 2
# Adjust for small samples using t-distribution
if required_n < 30:
t_value = stats.t.ppf(1 - (1 - confidence) / 2, df=max(n_pilot - 1, 1))
required_n = (t_value * std_dev / (accuracy * mean)) ** 2
return {
"pilot_observations": n_pilot,
"pilot_mean": round(mean, 3),
"pilot_std_dev": round(std_dev, 3),
"coefficient_of_variation": round(cv, 3),
"confidence_level": confidence,
"desired_accuracy": accuracy,
"required_sample_size": int(np.ceil(required_n)),
"additional_observations_needed": max(0, int(np.ceil(required_n)) - n_pilot)
}
def create_element_breakdown(task_description: str, elements: list):
"""
Document element breakdown for time study
elements: list of {'name': str, 'description': str, 'type': str, 'breakpoint': str}
"""
breakdown = []
for i, elem in enumerate(elements):
breakdown.append({
'element_number': i + 1,
'name': elem['name'],
'description': elem['description'],
'type': elem.get('type', 'regular'), # regular, occasional, foreign
'breakpoint': elem.get('breakpoint', ''), # endpoint description
'machine_controlled': elem.get('machine_controlled', False),
'frequency': elem.get('frequency', 1.0) # times per cycle
})
return {
"task": task_description,
"element_count": len(breakdown),
"elements": breakdown,
"element_types": {
"regular": sum(1 for e in breakdown if e['type'] == 'regular'),
"occasional": sum(1 for e in breakdown if e['type'] == 'occasional'),
"foreign": sum(1 for e in breakdown if e['type'] == 'foreign')
}
}
def create_standard_time_summary(elements: list, allowances: dict,
frequency_adjustments: dict = None):
"""
Create comprehensive standard time summary
"""
total_normal_time = 0
element_details = []
for elem in elements:
frequency = frequency_adjustments.get(elem['name'], 1.0) if frequency_adjustments else 1.0
adjusted_time = elem['normal_time'] * frequency
element_details.append({
'element': elem['name'],
'normal_time': elem['normal_time'],
'frequency': frequency,
'adjusted_time': round(adjusted_time, 3)
})
total_normal_time += adjusted_time
# Apply allowances
allowance_result = calculate_allowances(total_normal_time, allowances)
return {
"elements": element_details,
"total_normal_time": round(total_normal_time, 3),
"standard_time": allowance_result['standard_time'],
"allowances": allowance_result['allowances'],
"production_standards": {
"pieces_per_hour": round(60 / allowance_result['standard_time'], 1),
"pieces_per_shift_8hr": round(480 / allowance_result['standard_time'], 0),
"hours_per_100": round(100 * allowance_result['standard_time'] / 60, 2)
}
}
This skill integrates with the following processes:
work-measurement-analysis.jsstandard-work-development.jslabor-cost-estimation.js{
"time_study": {
"task": "Assembly Operation A",
"elements": [
{"element": "Get parts", "observed": 0.15, "rating": 95, "normal": 0.143},
{"element": "Position", "observed": 0.22, "rating": 100, "normal": 0.220}
],
"total_normal_time": 1.45
},
"standard_time": {
"normal_time": 1.45,
"allowance_percent": 15,
"standard_time": 1.71
},
"production_standards": {
"pieces_per_hour": 35.1,
"hours_per_100": 2.85
},
"sample_analysis": {
"required_observations": 25,
"confidence": 95,
"accuracy": "±5%"
}
}