Financial Services Task Inventory

Example: Retail Lending Hierarchy

Current: Mortgage Intake Clerk → Mortgage Processor → Underwriter → Closing Coordinator → Post-Close Auditor (5 roles, 3 layers)

Hay Analysis: Intake and Processing tasks are Bloom 1–2 with overlapping skills. Underwriting is Bloom 4 with distinct regulatory know-how. Audit is 3rd-line with different accountability. Three natural Hay clusters, not five.

Redesigned: Origination Advisor (client-facing, Bloom 4–5, 1st line) + Lending Operations Specialist (process + exception, Bloom 2–3, 1st line) + Credit Risk Reviewer (2nd/3rd line, Bloom 4–5). Three roles, two layers, each internally coherent against Hay criteria.

# Step 1: Load reference inventory import pandas as pd, json with open('task_inventory.json') as f: ref = json.load(f) ref_tasks = pd.DataFrame(ref['tasks']) print(f"Reference: {len(ref_tasks)} tasks, {ref_tasks.L1_function.nunique()} L1 functions") print(f"Schema: {list(ref_tasks.columns)}") # Validate: no nulls in key fields assert ref_tasks[['task_id','task_name','L1_function','L2_process','L3_activity']].notna().all().all() # Extract taxonomy tree for reuse taxonomy = ref_tasks[['L1_function','L2_process','L3_activity']].drop_duplicates().sort_values( ['L1_function','L2_process','L3_activity'] )

# Step 2: Load HRIS and build role-task mapping hris = pd.read_csv('hris_export.csv') # columns: employee_id, job_title, department, grade, fte_count print(f"HRIS: {hris.job_title.nunique()} unique titles, {hris.fte_count.sum()} FTEs") # Option A: Manual mapping worksheet (SME-assisted) # Export reference tasks by L1, have SMEs mark which tasks apply to each job title role_task_map = pd.read_csv('role_task_mapping.csv') # columns: job_title, task_id, effort_pct # Option B: Automated fuzzy matching (augments manual mapping) from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.metrics.pairwise import cosine_similarity # Match JD text against reference task descriptions jd_texts = load_job_descriptions() # your JD corpus ref_descs = ref_tasks['task_description'].tolist() vectorizer = TfidfVectorizer(stop_words='english', max_features=5000) tfidf = vectorizer.fit_transform(ref_descs + jd_texts) ref_vecs = tfidf[:len(ref_descs)] jd_vecs = tfidf[len(ref_descs):] similarities = cosine_similarity(jd_vecs, ref_vecs) # For each JD, get top-N matching reference tasks above threshold THRESHOLD = 0.25 for i, jd_title in enumerate(jd_titles): top_matches = similarities[i].argsort()[::-1][:20] matched = [(ref_tasks.iloc[j].task_id, similarities[i][j]) for j in top_matches if similarities[i][j] > THRESHOLD]

# Step 3: Add org-specific tasks # Use the same 18-field schema custom_tasks = [] custom_tasks.append({ 'task_id': 'CUSTOM.RB.001', # prefix with CUSTOM to distinguish 'task_name': 'Process Internal Transfer via Proprietary Platform', 'task_description': 'Execute inter-branch account transfers using [OrgSystem]...', 'L1_function': 'Retail Banking', 'L2_process': 'Deposit Products & Services', 'L3_activity': 'Transaction Processing', 'onet_soc_codes': ['43-3071.00'], 'primary_roles': ['Branch Operations Specialist'], 'importance': 3, 'frequency': 'Daily', 'cognitive_complexity': 2, # Bloom's level 'regulatory_driven': False, 'cross_functional': False, 'ai_exposure_class': None, # will be classified in Step 4 'ai_disposition': None, 'skills_required': ['Core Banking System', 'Transaction Processing'], 'defense_line': '1st', 'source': 'Internal' }) # Merge with reference all_tasks = pd.concat([ref_tasks, pd.DataFrame(custom_tasks)], ignore_index=True)

# Step 4: AI Exposure Scoring — Bottom-Up E0/E1/E2 Classification # References: # Eloundou et al. (2023) "GPTs are GPTs", Science 384(6702) # Felten, Raj & Seamans (2021) AIOE Index, Strategic Mgmt Journal import re, json import numpy as np import pandas as pd # ── 4a. Define keyword patterns for E0/E1/E2 classification ── E0_PATTERNS = [ # Physical, embodied, in-person tasks r'(physical|manual|hands-on|in-person|face-to-face|on-site|field)', r'(vault|cash handling|cash count|coin|currency|safe|lock|key)', r'(inspect|patrol|guard|security check|emergency response)', r'(lift|carry|move|transport|deliver|install|repair|maintain equipment)', r'(branch operations|teller|counter|window)', ] E0_STRONG = [ # High-confidence E0 signals r'(physically|manual labor|operate machinery|handle cash|count currency)', r'(vault operations|security patrol|emergency evacuation)', ] E1_PATTERNS = [ # Direct LLM tasks (50%+ time reduction with LLM alone) r'(write|draft|compose|author|prepare report|create document)', r'(summarize|synthesize|consolidate|abstract)', r'(review|proofread|edit|revise)', r'(code|script|program|develop software|debug)', r'(classify|categorize|tag|label)', r'(research|investigate|compile information|literature review)', r'(explain|describe|articulate|communicate)', r'(recommend|suggest|advise|propose)', r'(policy|procedure|guideline|standard|template)', r'(forecast|project|predict|estimate)', r'(train|educate|instruct|onboard)', ] E2_PATTERNS = [ # LLM + tools (data analysis, system integration) r'(analyze data|data analysis|statistical|regression|model)', r'(database|SQL|query|extract data|data mining)', r'(dashboard|visualization|chart|graph|report generation)', r'(monitor|track|alert|detection|surveillance)', r'(automate|workflow|process automation|RPA)', r'(reconcile|match|validate data|cross-reference)', r'(risk model|credit model|scoring model|pricing model)', r'(compliance monitoring|regulatory reporting|filing)', r'(transaction processing|settlement|clearing)', r'(due diligence|KYC|AML|screening)', ] # ── 4b. Task-level classification function ── def classify_task_e012(task_text, bloom_level): # Classify a task as E0, E1, or E2 per Eloundou rubric. # Returns (classification, confidence). text = task_text.lower() e0 = sum(1 for p in E0_PATTERNS if re.search(p, text)) e0s = sum(1 for p in E0_STRONG if re.search(p, text)) e1 = sum(1 for p in E1_PATTERNS if re.search(p, text)) e2 = sum(1 for p in E2_PATTERNS if re.search(p, text)) # Strong E0 signal overrides if e0s >= 1 and e1 == 0 and e2 == 0: return 'E0', 0.9 # Bloom's modulates: higher-order thinking = more LLM-amenable bloom_boost = max(0, (bloom_level - 2) * 0.1) if bloom_level else 0 total = max(e0 + e1 + e2, 1) scores = { 'E0': (e0 / total) * (1 - bloom_boost), 'E1': (e1 / total) + bloom_boost * 0.6, 'E2': (e2 / total) + bloom_boost * 0.4, } best = max(scores, key=scores.get) if best == 'E0' and e0 == 0: best = 'E1' # default to E1 if no E0 signals return best, min(0.9, scores[best]) # ── 4c. Disposition assignment (based on E-class, Bloom's, and regulatory status) ── def assign_disposition(e_class, bloom, regulatory): # Assign Automate/Augment/Restructure/No_Change using E-class + task attributes. # E0 tasks: no LLM exposure if e_class == 'E0': return 'No_Change' if bloom >= 5 else 'Restructure' # E1 tasks: direct LLM exposure if e_class == 'E1': if bloom <= 2: return 'Automate' # routine tasks the LLM can handle directly elif bloom <= 4: return 'Augment' if regulatory else 'Automate' else: return 'Augment' # high-order tasks: human + LLM together # E2 tasks: LLM + tools if e_class == 'E2': if bloom <= 2: return 'Automate' # tool pipelines can handle routine E2 tasks elif bloom <= 3: return 'Restructure' # may require workflow redesign for tooling else: return 'Augment' # complex tasks benefit from AI-augmented workflows return 'Augment' # ── 4d. Apply to all tasks ── for idx, row in all_tasks.iterrows(): text = f"{row['task_name']} {row['task_description']}" bloom = row['cognitive_complexity'] e_class, conf = classify_task_e012(text, bloom) all_tasks.at[idx, 'ai_exposure_class'] = e_class all_tasks.at[idx, 'ai_disposition'] = assign_disposition( e_class, bloom, row['regulatory_driven'] ) print(f"Classification: {all_tasks.ai_exposure_class.value_counts().to_dict()}") # ── 4e. Compute Eloundou beta at occupation level ── # beta = [E1 + 0.5 * E2] / total tasks for each occupation e_map = {'E0': 0, 'E1': 1, 'E2': 0.5} all_tasks['e_weight'] = all_tasks['ai_exposure_class'].map(e_map) occ_beta = (all_tasks.explode('onet_soc_codes') .groupby('onet_soc_codes') .agg(beta=('e_weight', 'mean'), task_count=('task_id', 'count')) .reset_index()) occ_beta.columns = ['soc', 'beta', 'task_count'] print(f" Occupation-level beta:") print(f" Mean beta: {occ_beta.beta.mean():.3f}") print(f" Range: {occ_beta.beta.min():.3f} - {occ_beta.beta.max():.3f}") # ── 4f. CROSS-VALIDATE against published AIOE (Felten et al. 2021) ── # Download AIOE data: github.com/AIOE-Data/AIOE # The AIOE is an occupation-level z-score index (not task-level). # We compare our occupation-level beta against AIOE for directional alignment. aioe_df = pd.read_excel('AIOE_DataAppendix.xlsx', sheet_name='Appendix A') aioe_map = dict(zip(aioe_df['O*NET-SOC Code'], aioe_df['AIOE'])) occ_beta['aioe'] = occ_beta['soc'].map(aioe_map) occ_valid = occ_beta.dropna(subset=['aioe']) # Spearman rank correlation (appropriate for comparing ordinal/z-score vs proportion) from scipy.stats import spearmanr rho, p_val = spearmanr(occ_valid['beta'], occ_valid['aioe']) print(f" VALIDATION: Spearman rho = {rho:.3f} (p = {p_val:.4f})") print(f"Matched {len(occ_valid)} occupations") print(f"Note: AIOE is an occupation-level z-score; beta is a task-derived proportion.") print(f"Directional agreement (both ranking occupations similarly) is the goal.")

# Step 5: Role-Level Aggregation & Hay Method Factor Computation merged = role_task_map.merge(all_tasks, on='task_id') merged = merged.merge( hris[['job_title','fte_count','grade','direct_reports', 'indirect_reports','levels_from_ceo','approval_limit', 'budget_responsibility','l1_functions_in_scope']].drop_duplicates(), on='job_title' ) # NOTE: If your HRIS doesn't have all columns, fill with defaults: # merged['direct_reports'] = merged.get('direct_reports', 0) # merged['approval_limit'] = merged.get('approval_limit', 10000) # merged['levels_from_ceo'] = merged.get('levels_from_ceo', 6) # ── 5a. Basic role aggregation (Layer 1: Task-Derived) ── role_profiles = merged.groupby('job_title').agg( task_count=('task_id', 'count'), fte_count=('fte_count', 'first'), current_grade=('grade', 'first'), unique_skills=('skills_required', lambda x: len(set(s for sl in x for s in sl))), max_bloom=('cognitive_complexity', 'max'), mean_bloom=('cognitive_complexity', 'mean'), bloom_std=('cognitive_complexity', 'std'), l2_breadth=('L2_process', 'nunique'), l3_breadth=('L3_activity', 'nunique'), pct_cross_functional=('cross_functional', 'mean'), primary_defense_line=('defense_line', lambda x: x.mode().iloc[0]), mean_importance=('importance', 'mean'), pct_regulatory=('regulatory_driven', 'mean'), beta=('ai_exposure_class', lambda x: (sum(1 for v in x if v=='E1') + 0.5*sum(1 for v in x if v=='E2')) / len(x)), pct_e0=('ai_exposure_class', lambda x: (x == 'E0').mean()), pct_e1=('ai_exposure_class', lambda x: (x == 'E1').mean()), pct_e2=('ai_exposure_class', lambda x: (x == 'E2').mean()), pct_automate=('ai_disposition', lambda x: (x == 'Automate').mean()), pct_augment=('ai_disposition', lambda x: (x == 'Augment').mean()), ).round(3) # ── 5b. Hay Factor 1: KNOW-HOW ── # Technical Depth: cognitive complexity * skill breadth # Managerial Breadth: proportion of supervisory/strategic tasks # Human Relations: proportion of interpersonal/advisory tasks MGMT_KW = ['direct','supervise','manage','lead','plan','coordinate', 'delegate','oversee','strategic','governance','budget'] HR_KW = ['advise','counsel','coach','mentor','negotiate','present', 'relationship','communicate','client','stakeholder','mediate'] def compute_know_how(role_tasks): n = len(role_tasks) # Technical Depth (0-100): avg bloom * unique skill count, normalized avg_bloom = role_tasks['cognitive_complexity'].mean() skills = set(s for sl in role_tasks['skills_required'] for s in sl) tech_depth = min(100, avg_bloom * len(skills) / 2) # Managerial Breadth (0-100): % of tasks with mgmt keywords mgmt_count = sum(1 for _, t in role_tasks.iterrows() if any(kw in (t['task_name'] + ' ' + t['task_description']).lower() for kw in MGMT_KW)) mgmt_breadth = (mgmt_count / n) * 100 # Human Relations (0-100): % of tasks with HR keywords hr_count = sum(1 for _, t in role_tasks.iterrows() if any(kw in (t['task_name'] + ' ' + t['task_description']).lower() for kw in HR_KW)) human_rel = (hr_count / n) * 100 # Composite: weighted sum (Hay weights tech depth highest) return round(tech_depth * 0.50 + mgmt_breadth * 0.25 + human_rel * 0.25, 1) # ── 5c. Hay Factor 2: PROBLEM SOLVING ── # Thinking Environment: derived from E-class distribution (more E0 = more novel) # Thinking Challenge: Bloom's level distribution def compute_problem_solving(role_tasks): n = len(role_tasks) # Thinking Environment (0-100): based on E-class distribution # E0 tasks = fully human, novel problems. E1/E2 = more structured. e_weights = {'E0': 100, 'E1': 30, 'E2': 50} # E0=hardest, E2=mid, E1=most structured think_env = role_tasks['ai_exposure_class'].map(e_weights).mean() # Thinking Challenge (0-100): weighted by high Bloom's tasks bloom_dist = role_tasks['cognitive_complexity'].value_counts(normalize=True) # Weight: Bloom 5-6 tasks count 3x, Bloom 3-4 count 1x, Bloom 1-2 count 0.3x challenge = sum( pct * {1:10, 2:20, 3:40, 4:60, 5:80, 6:100}.get(level, 40) for level, pct in bloom_dist.items() ) # Composite (Hay: PS expressed as % of Know-How) return round(think_env * 0.40 + challenge * 0.60, 1) # ── 5d. Hay Factor 3: ACCOUNTABILITY ── # Freedom to Act: inverse of regulatory constraint # Scope/Magnitude: importance * frequency * L1 materiality # Impact: defense line + proportion of direct-impact tasks LOD_WEIGHT = {'1st': 1.0, '2nd': 0.7, '3rd': 0.5, 'NA': 0.3} def compute_accountability(role_tasks): n = len(role_tasks) # Freedom to Act (0-100): 100 - (% regulatory-driven * 100) freedom = (1 - role_tasks['regulatory_driven'].mean()) * 100 # Scope/Magnitude (0-100): mean importance (1-5) normalized to 0-100 scope = role_tasks['importance'].mean() * 20 # 5 -> 100 # Impact (0-100): defense line weight * importance lod_weights = role_tasks['defense_line'].map(LOD_WEIGHT).fillna(0.3) impact = (lod_weights * role_tasks['importance'] / 5 * 100).mean() return round(freedom * 0.30 + scope * 0.35 + impact * 0.35, 1) # ── 5e. Layer 2: Job-Level Organizational Context ── # These variables come from HRIS, not from task attributes. # They modulate the task-derived Hay scores to reflect organizational # position — the "amplifier" that distinguishes an analyst from a VP # doing similar analytical work. import math def span_of_control_multiplier(direct_reports, indirect_reports=0): # Hay managerial breadth scale based on total reports total = (direct_reports or 0) + (indirect_reports or 0) if total == 0: return 1.0 # Individual contributor elif total <= 5: return 1.15 # Team lead elif total <= 20: return 1.30 # Manager elif total <= 100: return 1.50 # Senior manager / Director else: return 1.70 # VP / Executive def decision_authority_score(approval_limit): # Map financial approval authority to Hay freedom-to-act scale (0-100) # Based on Hay Guide Chart A progression if approval_limit is None: return 30 # default: controlled limit = float(approval_limit) if limit < 10_000: return 15 # Prescribed elif limit < 100_000: return 30 # Controlled elif limit < 1_000_000: return 50 # Standardized elif limit < 50_000_000: return 70 # Generally regulated elif limit < 500_000_000: return 85 # Broadly defined else: return 95 # Strategic direction def budget_magnitude_score(budget): # Hay uses geometric (log) scale for magnitude # Normalized to 0-100 using ln(budget) / ln(max_expected) if budget is None or budget <= 0: return 20 return min(100, round(math.log(budget) / math.log(10_000_000_000) * 100)) def reporting_level_score(levels_from_ceo): # Fewer levels from CEO = more abstract thinking environment # Hay thinking environment scale level_map = {1: 95, 2: 80, 3: 65, 4: 50, 5: 40, 6: 30} return level_map.get(levels_from_ceo, max(15, 95 - levels_from_ceo * 12)) def cross_functional_breadth(l1_count): # Number of L1 functions in scope if l1_count is None or l1_count <= 1: return 1.0 elif l1_count <= 3: return 1.15 else: return 1.30 # ── 5f. Compute combined Hay scores (Layer 1 + Layer 2) ── hay_scores = {} for title in role_profiles.index: role_tasks = merged[merged.job_title == title] row = role_profiles.loc[title] # Layer 1: Task-derived base scores kh_base = compute_know_how(role_tasks) ps_base = compute_problem_solving(role_tasks) ac_base = compute_accountability(role_tasks) # Layer 2: Job-level organizational context modulation span_mult = span_of_control_multiplier( row.get('direct_reports', 0), row.get('indirect_reports', 0)) xfunc_mult = cross_functional_breadth( row.get('l1_functions_in_scope', 1)) da_score = decision_authority_score( row.get('approval_limit', None)) bm_score = budget_magnitude_score( row.get('budget_responsibility', None)) rl_score = reporting_level_score( row.get('levels_from_ceo', 6)) # Combine: Layer 1 base * Layer 2 modulation # Know-How: span of control amplifies managerial breadth, # cross-functional scope amplifies overall breadth kh_final = min(100, kh_base * span_mult * xfunc_mult) # Problem Solving: reporting level modulates thinking environment # (closer to CEO = more abstract/strategic thinking required) ps_final = min(100, ps_base * 0.60 + rl_score * 0.40) # Accountability: decision authority and budget replace the # task-derived freedom/scope estimates with actual org data ac_final = min(100, ac_base * 0.30 + # Task-derived impact da_score * 0.35 + # Decision authority (HRIS) bm_score * 0.35) # Budget magnitude (HRIS) hay_scores[title] = { 'know_how': round(kh_final, 1), 'problem_solving': round(ps_final, 1), 'accountability': round(ac_final, 1), # Keep Layer 1 scores for comparison 'kh_task_only': round(kh_base, 1), 'ps_task_only': round(ps_base, 1), 'ac_task_only': round(ac_base, 1), # Layer 2 context values 'span_multiplier': span_mult, 'decision_authority': da_score, 'budget_magnitude': bm_score, 'reporting_level': rl_score, } hay_df = pd.DataFrame(hay_scores).T hay_df['hay_composite'] = ( hay_df['know_how'] * 0.40 + hay_df['problem_solving'] * 0.30 + hay_df['accountability'] * 0.30 ).round(1) # Also compute task-only composite for Layer 1 vs combined comparison hay_df['hay_task_only'] = ( hay_df['kh_task_only'] * 0.40 + hay_df['ps_task_only'] * 0.30 + hay_df['ac_task_only'] * 0.30 ).round(1) role_profiles = role_profiles.join(hay_df) # ── 5g. Derive job levels from composite Hay score ── # Using Hay's ~15% geometric step progression across levels def hay_to_level(composite): if composite >= 80: return 'Executive / SVP' elif composite >= 68: return 'Director / VP' elif composite >= 56: return 'Senior Manager / Lead' elif composite >= 44: return 'Manager / Senior Specialist' elif composite >= 32: return 'Analyst / Specialist' else: return 'Associate / Coordinator' role_profiles['suggested_level'] = role_profiles.hay_composite.apply(hay_to_level) # ── 5h. Compare and identify misalignment ── print(" === HAY EVALUATION SUMMARY ===") print(f"{'Role':<40} {'KH':>5} {'PS':>5} {'AC':>5} {'Comp':>5} " f"{'Task-Only':>9} {'Δ':>4} {'Level'}") print("─" * 100) for title, p in role_profiles.iterrows(): delta = p.hay_composite - p.hay_task_only flag = '⬆' if delta > 10 else ('⬇' if delta < -5 else '') print(f"{title[:40]:<40} {p.know_how:>5.0f} {p.problem_solving:>5.0f} " f"{p.accountability:>5.0f} {p.hay_composite:>5.0f} " f"{p.hay_task_only:>9.0f} {delta:>+4.0f} {p.suggested_level} {flag}") # Show where Layer 2 context makes the biggest difference print(f" Largest Layer 2 impact (org context vs task-only):") role_profiles['layer2_delta'] = role_profiles.hay_composite - role_profiles.hay_task_only top_delta = role_profiles.nlargest(10, 'layer2_delta') for title, p in top_delta.iterrows(): print(f" {title[:45]:<45} +{p.layer2_delta:.0f} pts " f"(span={p.span_multiplier:.2f}x, auth={p.decision_authority:.0f}, " f"budget={p.budget_magnitude:.0f})") # ── 5i. Future-state modeling: remove automated tasks ── # Layer 1 (task composition) changes; Layer 2 (org context) held constant future_tasks = merged[merged.ai_disposition != 'Automate'] print(f" Future-state: {len(future_tasks)} tasks remain after automation") print(f"Removed: {len(merged) - len(future_tasks)} tasks " f"({(len(merged)-len(future_tasks))/len(merged)*100:.1f}%)") # Recompute Layer 1 for future state, keep Layer 2 constant for title in role_profiles.index: ft = future_tasks[future_tasks.job_title == title] if len(ft) > 0: # Layer 1 recalculated from remaining tasks kh_base = compute_know_how(ft) ps_base = compute_problem_solving(ft) ac_base = compute_accountability(ft) # Layer 2 held constant (org context doesn't change) p = role_profiles.loc[title] kh_f = min(100, kh_base * p.span_multiplier * cross_functional_breadth(p.get('l1_functions_in_scope', 1))) ps_f = min(100, ps_base * 0.60 + p.reporting_level * 0.40) ac_f = min(100, ac_base * 0.30 + p.decision_authority * 0.35 + p.budget_magnitude * 0.35) role_profiles.at[title, 'future_hay'] = round( kh_f * 0.4 + ps_f * 0.3 + ac_f * 0.3, 1) else: role_profiles.at[title, 'future_hay'] = 0 # role eliminated # Identify roles that shift levels role_profiles['future_level'] = role_profiles.future_hay.apply(hay_to_level) shifted = role_profiles[role_profiles.suggested_level != role_profiles.future_level] print(f" {len(shifted)} roles shift job levels in future state") # Show which way they shift for title, p in shifted.iterrows(): direction = '↓ DOWNGRADE' if p.future_hay < p.hay_composite else '↑ UPGRADE' print(f" {title[:40]:<40} {p.suggested_level} → {p.future_level} " f"({p.hay_composite:.0f} → {p.future_hay:.0f}) {direction}")

# Step 6: Analytical outputs # ── A. Skill gap matrix ── current_skills = load_lms_data() # your LMS export required_skills = (merged.explode('skills_required') .groupby(['job_title','skills_required']).size() .unstack(fill_value=0)) gap_matrix = required_skills.subtract(current_skills, fill_value=0) # ── B. Role consolidation candidates ── from itertools import combinations from sklearn.metrics.pairwise import cosine_similarity # Build task vectors per role (binary: does role include task?) role_task_matrix = (merged.groupby(['job_title','task_id']).size() .unstack(fill_value=0)) sim = cosine_similarity(role_task_matrix) sim_df = pd.DataFrame(sim, index=role_task_matrix.index, columns=role_task_matrix.index) # Identify roles with >60% task overlap for r1, r2 in combinations(role_profiles.index, 2): if sim_df.loc[r1, r2] > 0.6: fte = role_profiles.loc[[r1,r2], 'fte_count'].sum() print(f"Consolidate: {r1} + {r2} " f"(similarity: {sim_df.loc[r1,r2]:.0%}, FTEs: {fte})") # ── C. Hay evaluation report ── print(" === HAY EVALUATION REPORT ===") for title, p in role_profiles.iterrows(): print(f" {'='*60}") print(f"ROLE: {title}") print(f"Current Grade: {p.current_grade} | Suggested Level: {p.suggested_level}") print(f"{'─'*60}") print(f"KNOW-HOW: {p.know_how:>6.1f}") print(f" Technical Depth: {p.unique_skills} skills, " f"Bloom avg={p.mean_bloom:.1f}, max={p.max_bloom}") print(f" Mgmt Breadth: {p.l2_breadth} L2 processes, " f"{p.l3_breadth} L3 activities") print(f"PROBLEM SOLVING: {p.problem_solving:>6.1f}") print(f" Thinking Env: beta={p.beta:.3f} " f"(lower=more novel, E0-heavy)") print(f" Challenge: Bloom std={p.bloom_std:.1f}, " f"{p.pct_cross_functional:.0%} cross-functional") print(f"ACCOUNTABILITY: {p.accountability:>6.1f}") print(f" Freedom to Act: {(1-p.pct_regulatory)*100:.0f}% non-regulatory") print(f" Defense Line: {p.primary_defense_line}") print(f" Importance: {p.mean_importance:.1f}/5") print(f"{'─'*60}") print(f"HAY COMPOSITE: {p.hay_composite:>6.1f} → {p.suggested_level}") if hasattr(p, 'future_hay') and p.future_hay != p.hay_composite: print(f"FUTURE STATE: {p.future_hay:>6.1f} → {p.future_level}") # ── D. SWP scenario model with Hay impact ── def model_scenario(roles_df, merged_df, automate_threshold): # Model headcount and Hay-level shifts at different automation thresholds. at_risk = roles_df[roles_df.pct_automate > automate_threshold] fte_impact = at_risk.fte_count.sum() * at_risk.pct_automate.mean() level_shifts = (at_risk.suggested_level != at_risk.future_level).sum() return { 'roles_affected': len(at_risk), 'fte_impact': round(fte_impact), 'level_shifts': level_shifts, 'skills_at_risk': merged_df[ merged_df.job_title.isin(at_risk.index) & (merged_df.ai_disposition == 'Automate') ].explode('skills_required')['skills_required'].value_counts().head(10) } scenarios = { 'Conservative (>50% auto)': model_scenario(role_profiles, merged, 0.5), 'Balanced (>30% auto)': model_scenario(role_profiles, merged, 0.3), 'Aggressive (>15% auto)': model_scenario(role_profiles, merged, 0.15), } for name, s in scenarios.items(): print(f" {name}: {s['roles_affected']} roles, ~{s['fte_impact']} FTEs, " f"{s['level_shifts']} level shifts") print(f" Top skills at risk: {', '.join(s['skills_at_risk'].index[:5])}") # ── E. Export role profiles for Hay Guide Chart input ── export_cols = ['task_count','fte_count','current_grade', # Layer 1 (task-derived) 'kh_task_only','ps_task_only','ac_task_only','hay_task_only', # Layer 2 context 'span_multiplier','decision_authority','budget_magnitude','reporting_level', # Combined Hay scores 'know_how','problem_solving','accountability','hay_composite', 'suggested_level','layer2_delta', # Future state 'future_hay','future_level', # AI exposure 'beta','pct_automate','pct_e0','pct_e1','pct_e2'] export_df = role_profiles[[c for c in export_cols if c in role_profiles.columns]] export_df.to_csv('hay_evaluation_export.csv') print(f" Exported {len(export_df)} role evaluations to hay_evaluation_export.csv") print(f"Columns: {list(export_df.columns)}")