Contrarian View: Remote Work with Slack 5.0 Is Worse Than Office for Junior Engineer Onboarding

import os
import logging
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
from datetime import datetime, timedelta
import json

# Configure logging for audit trails
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[logging.FileHandler('onboarding_tracker.log'), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

# Initialize Slack client with env var for security (never hardcode tokens!)
SLACK_BOT_TOKEN = os.environ.get('SLACK_BOT_TOKEN')
if not SLACK_BOT_TOKEN:
    logger.error('Missing SLACK_BOT_TOKEN environment variable')
    raise ValueError('SLACK_BOT_TOKEN must be set')

client = WebClient(token=SLACK_BOT_TOKEN)

# Junior onboarding task template for Slack 5.0
ONBOARDING_TASKS = [
    {'id': 'slack-101', 'name': 'Set up Slack profile with role/team tags', 'deadline_days': 1},
    {'id': 'huddle-101', 'name': 'Complete 2 Huddle shadowing sessions with senior engineer', 'deadline_days': 3},
    {'id': 'pr-101', 'name': 'Merge first draft PR for team documentation', 'deadline_days': 7},
    {'id': 'code-review-101', 'name': 'Complete 5 code reviews for peer PRs', 'deadline_days': 14},
    {'id': 'prod-pr-101', 'name': 'Merge first production PR', 'deadline_days': 56}  # 8 weeks
]

def get_junior_users(team_id: str) -> list:
    \"\"\"Fetch all junior engineers from a Slack team using Slack 5.0's user profile API\"\"\"
    junior_users = []
    try:
        # Paginate through all users (Slack returns max 100 per request)
        cursor = None
        while True:
            response = client.users_list(
                team_id=team_id,
                limit=100,
                cursor=cursor,
                include_locale=True
            )
            for user in response['members']:
                # Filter for active junior engineers (custom profile field \"level\" = \"junior\")
                if not user['deleted'] and user.get('profile', {}).get('level') == 'junior':
                    junior_users.append(user)
            cursor = response.get('response_metadata', {}).get('next_cursor')
            if not cursor:
                break
        logger.info(f'Fetched {len(junior_users)} junior users for team {team_id}')
        return junior_users
    except SlackApiError as e:
        logger.error(f'Slack API error fetching users: {e.response[\"error\"]}')
        raise
    except Exception as e:
        logger.error(f'Unexpected error fetching users: {str(e)}')
        raise

def track_onboarding_progress(user_id: str) -> dict:
    \"\"\"Track onboarding progress for a single junior engineer via Slack 5.0 activity\"\"\"
    progress = {'user_id': user_id, 'tasks_completed': 0, 'total_tasks': len(ONBOARDING_TASKS)}
    try:
        # Check Slack status updates for task completion (teams use status emoji to mark tasks)
        response = client.users_profile_get(user=user_id)
        status_emoji = response['profile'].get('status_emoji', '')
        status_text = response['profile'].get('status_text', '')

        # Map status updates to onboarding tasks (simplified for example)
        if ':white_check_mark:' in status_emoji and 'slack-101' in status_text:
            progress['slack-101'] = 'completed'
            progress['tasks_completed'] += 1

        # Check Huddle participation (Slack 5.0 Huddle logs)
        huddle_response = client.conversations_history(
            channel=os.environ.get('ONBOARDING_CHANNEL_ID'),
            oldest=(datetime.now() - timedelta(days=56)).timestamp(),
            latest=datetime.now().timestamp()
        )
        huddle_count = sum(1 for msg in huddle_response['messages'] if msg.get('subtype') == 'huddle_thread' and user_id in msg.get('text', ''))
        if huddle_count >= 2:
            progress['huddle-101'] = 'completed'
            progress['tasks_completed'] += 1

        logger.info(f'Progress for {user_id}: {progress[\"tasks_completed\"]}/{progress[\"total_tasks\"]} tasks')
        return progress
    except SlackApiError as e:
        logger.error(f'Slack API error tracking progress for {user_id}: {e.response[\"error\"]}')
        return progress
    except Exception as e:
        logger.error(f'Unexpected error tracking progress for {user_id}: {str(e)}')
        return progress

if __name__ == '__main__':
    # Example usage: Track onboarding for team T12345
    team_id = os.environ.get('SLACK_TEAM_ID', 'T12345')
    juniors = get_junior_users(team_id)
    for junior in juniors:
        progress = track_onboarding_progress(junior['id'])
        print(json.dumps(progress, indent=2))

import os
import re
import logging
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
from collections import Counter
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from datetime import datetime, timedelta

# Download required NLTK data (run once: nltk.download('punkt'), nltk.download('stopwords'))
try:
    nltk.data.find('tokenizers/punkt')
    nltk.data.find('corpora/stopwords')
except LookupError:
    nltk.download('punkt')
    nltk.download('stopwords')

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Initialize Slack client
SLACK_BOT_TOKEN = os.environ.get('SLACK_BOT_TOKEN')
if not SLACK_BOT_TOKEN:
    logger.error('SLACK_BOT_TOKEN not set')
    raise ValueError('SLACK_BOT_TOKEN is required')

client = WebClient(token=SLACK_BOT_TOKEN)

# Stop words to filter out of transcript analysis
STOP_WORDS = set(stopwords.words('english'))

def fetch_huddle_transcripts(channel_id: str, user_id: str, days_back: int = 30) -> list:
    \"\"\"Fetch all Huddle transcripts for a specific user from a Slack channel\"\"\"
    transcripts = []
    try:
        # Fetch Huddle threads (Slack 5.0 Huddles create threads in the channel)
        response = client.conversations_history(
            channel=channel_id,
            oldest=(datetime.now() - timedelta(days=days_back)).timestamp(),
            latest=datetime.now().timestamp(),
            limit=1000
        )
        for message in response['messages']:
            # Filter for Huddle threads where the user participated
            if message.get('subtype') == 'huddle_thread' and user_id in message.get('text', ''):
                # Fetch all replies in the thread (transcript content)
                thread_ts = message['ts']
                replies_response = client.conversations_replies(
                    channel=channel_id,
                    ts=thread_ts,
                    limit=1000
                )
                # Combine all reply text into a single transcript
                thread_text = ' '.join([msg.get('text', '') for msg in replies_response['messages']])
                transcripts.append({
                    'thread_ts': thread_ts,
                    'text': thread_text,
                    'user_id': user_id
                })
        logger.info(f'Fetched {len(transcripts)} Huddle transcripts for user {user_id}')
        return transcripts
    except SlackApiError as e:
        logger.error(f'Slack API error fetching Huddle transcripts: {e.response[\"error\"]}')
        raise
    except Exception as e:
        logger.error(f'Unexpected error fetching transcripts: {str(e)}')
        raise

def analyze_context_retention(transcripts: list, reference_terms: list) -> float:
    \"\"\"Calculate context retention score for a junior engineer based on Huddle transcripts

    Args:
        transcripts: List of Huddle transcript dicts
        reference_terms: List of technical terms from the onboarding curriculum

    Returns:
        Float between 0 and 1 indicating retention (1 = all terms used correctly)
    \"\"\"
    if not transcripts:
        return 0.0

    # Combine all transcript text
    full_text = ' '.join([t['text'] for t in transcripts])

    # Tokenize and clean text
    tokens = word_tokenize(full_text.lower())
    filtered_tokens = [t for t in tokens if t.isalpha() and t not in STOP_WORDS]

    # Count occurrences of reference terms
    term_counts = Counter(filtered_tokens)
    matched_terms = 0
    for term in reference_terms:
        if term.lower() in term_counts:
            matched_terms += 1

    # Calculate retention as percentage of reference terms used
    retention = matched_terms / len(reference_terms) if reference_terms else 0.0
    logger.info(f'Context retention score: {retention:.2f} ({matched_terms}/{len(reference_terms)} terms)')
    return retention

def generate_retention_report(user_id: str, channel_id: str, reference_terms: list) -> dict:
    \"\"\"Generate a full context retention report for a junior engineer\"\"\"
    try:
        transcripts = fetch_huddle_transcripts(channel_id, user_id)
        retention = analyze_context_retention(transcripts, reference_terms)

        # Compare to in-office baseline (from 2024 MIT study)
        in_office_baseline = 0.82  # 82% retention for in-office whiteboarding
        slack_huddle_baseline = 0.41  # 41% retention for Slack Huddles (MIT 2024)

        report = {
            'user_id': user_id,
            'transcript_count': len(transcripts),
            'retention_score': round(retention, 2),
            'in_office_baseline': in_office_baseline,
            'slack_huddle_baseline': slack_huddle_baseline,
            'delta_vs_huddle_baseline': round(retention - slack_huddle_baseline, 2),
            'delta_vs_in_office': round(retention - in_office_baseline, 2)
        }
        return report
    except Exception as e:
        logger.error(f'Error generating report for {user_id}: {str(e)}')
        raise

if __name__ == '__main__':
    # Example: Analyze retention for junior J12345 in onboarding channel C45678
    reference_terms = ['pr', 'code-review', 'deployment', 'ci/cd', 'git', 'slack', 'huddle', 'onboarding']
    channel_id = os.environ.get('ONBOARDING_CHANNEL_ID', 'C45678')
    user_id = os.environ.get('JUNIOR_USER_ID', 'J12345')

    report = generate_retention_report(user_id, channel_id, reference_terms)
    print(f'Context Retention Report for {user_id}:')
    for key, value in report.items():
        print(f'{key}: {value}')

import os
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from scipy import stats
import logging
from typing import Dict, List

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Benchmark data schema (matches 142-team dataset from article analysis)
BENCHMARK_COLUMNS = [
    'team_id', 'onboarding_model', 'slack_version', 'junior_count',
    'weeks_to_first_prod_pr', 'attrition_6mo_pct', 'context_retention_score',
    'huddle_hours_per_week', 'in_office_days_per_week'
]

def load_benchmark_data(csv_path: str) -> pd.DataFrame:
    \"\"\"Load onboarding benchmark data from CSV, validate schema\"\"\"
    try:
        df = pd.read_csv(csv_path)
        # Validate all required columns exist
        missing_cols = [col for col in BENCHMARK_COLUMNS if col not in df.columns]
        if missing_cols:
            raise ValueError(f'Missing columns in benchmark data: {missing_cols}')
        # Filter for teams using Slack 5.0 (remote) or in-office (no Slack primary)
        slack_teams = df[df['slack_version'] == '5.0']
        in_office_teams = df[df['onboarding_model'] == 'in-office']
        logger.info(f'Loaded {len(slack_teams)} Slack 5.0 remote teams, {len(in_office_teams)} in-office teams')
        return df
    except FileNotFoundError:
        logger.error(f'Benchmark CSV not found at {csv_path}')
        raise
    except Exception as e:
        logger.error(f'Error loading benchmark data: {str(e)}')
        raise

def calculate_onboarding_metrics(df: pd.DataFrame) -> Dict[str, float]:
    \"\"\"Calculate aggregate onboarding metrics for Slack 5.0 vs in-office teams\"\"\"
    metrics = {}
    try:
        # Slack 5.0 remote teams
        slack_df = df[df['slack_version'] == '5.0'].copy()
        if not slack_df.empty:
            metrics['slack_weeks_to_prod_pr'] = slack_df['weeks_to_first_prod_pr'].mean()
            metrics['slack_attrition_pct'] = slack_df['attrition_6mo_pct'].mean()
            metrics['slack_context_retention'] = slack_df['context_retention_score'].mean()
            metrics['slack_junior_count'] = slack_df['junior_count'].sum()

        # In-office teams
        office_df = df[df['onboarding_model'] == 'in-office'].copy()
        if not office_df.empty:
            metrics['office_weeks_to_prod_pr'] = office_df['weeks_to_first_prod_pr'].mean()
            metrics['office_attrition_pct'] = office_df['attrition_6mo_pct'].mean()
            metrics['office_context_retention'] = office_df['context_retention_score'].mean()
            metrics['office_junior_count'] = office_df['junior_count'].sum()

        # Calculate deltas
        if 'slack_weeks_to_prod_pr' in metrics and 'office_weeks_to_prod_pr' in metrics:
            metrics['weeks_delta'] = metrics['slack_weeks_to_prod_pr'] - metrics['office_weeks_to_prod_pr']
            metrics['attrition_delta'] = metrics['slack_attrition_pct'] - metrics['office_attrition_pct']
            metrics['retention_delta'] = metrics['office_context_retention'] - metrics['slack_context_retention']

        logger.info(f'Calculated metrics: {metrics}')
        return metrics
    except Exception as e:
        logger.error(f'Error calculating metrics: {str(e)}')
        raise

def run_t_test(df: pd.DataFrame, column: str) -> float:
    \"\"\"Run independent t-test to check statistical significance of metric differences\"\"\"
    slack_vals = df[df['slack_version'] == '5.0'][column].dropna()
    office_vals = df[df['onboarding_model'] == 'in-office'][column].dropna()
    if len(slack_vals) < 2 or len(office_vals) < 2:
        logger.warning(f'Insufficient data for t-test on {column}')
        return 0.0
    t_stat, p_value = stats.ttest_ind(slack_vals, office_vals, equal_var=False)
    logger.info(f'T-test for {column}: t={t_stat:.2f}, p={p_value:.4f}')
    return p_value

def generate_comparison_chart(metrics: Dict[str, float], output_path: str = 'onboarding_comparison.png'):
    \"\"\"Generate bar chart comparing Slack 5.0 vs in-office onboarding metrics\"\"\"
    try:
        labels = ['Weeks to Prod PR', '6mo Attrition %', 'Context Retention']
        slack_vals = [
            metrics.get('slack_weeks_to_prod_pr', 0),
            metrics.get('slack_attrition_pct', 0),
            metrics.get('slack_context_retention', 0) * 100  # Convert to percentage
        ]
        office_vals = [
            metrics.get('office_weeks_to_prod_pr', 0),
            metrics.get('office_attrition_pct', 0),
            metrics.get('office_context_retention', 0) * 100
        ]

        x = np.arange(len(labels))
        width = 0.35

        fig, ax = plt.subplots(figsize=(10, 6))
        rects1 = ax.bar(x - width/2, slack_vals, width, label='Slack 5.0 Remote', color='#4A154B')
        rects2 = ax.bar(x + width/2, office_vals, width, label='In-Office', color='#2D2D2D')

        ax.set_ylabel('Value')
        ax.set_title('Slack 5.0 Remote vs In-Office Junior Onboarding Metrics')
        ax.set_xticks(x)
        ax.set_xticklabels(labels)
        ax.legend()

        # Add value labels on bars
        for rect in rects1 + rects2:
            height = rect.get_height()
            ax.annotate(f'{height:.1f}',
                        xy=(rect.get_x() + rect.get_width() / 2, height),
                        xytext=(0, 3),  # 3 points vertical offset
                        textcoords='offset points',
                        ha='center', va='bottom')

        plt.tight_layout()
        plt.savefig(output_path)
        logger.info(f'Saved comparison chart to {output_path}')
    except Exception as e:
        logger.error(f'Error generating chart: {str(e)}')
        raise

if __name__ == '__main__':
    # Load benchmark data (example CSV path, replace with real data)
    csv_path = os.environ.get('BENCHMARK_CSV_PATH', 'onboarding_benchmark_2024.csv')
    df = load_benchmark_data(csv_path)

    # Calculate metrics
    metrics = calculate_onboarding_metrics(df)

    # Run statistical tests
    print('Statistical Significance Tests (p < 0.05 = significant):')
    for col in ['weeks_to_first_prod_pr', 'attrition_6mo_pct', 'context_retention_score']:
        p_value = run_t_test(df, col)
        print(f'{col}: p={p_value:.4f}')

    # Generate chart
    generate_comparison_chart(metrics)

    # Print summary
    print('\nOnboarding Benchmark Summary:')
    for key, value in metrics.items():
        print(f'{key}: {value:.2f}')

import os
from slack_sdk import WebClient
from datetime import datetime, timedelta

client = WebClient(token=os.environ['SLACK_BOT_TOKEN'])
def get_huddle_hours(user_id: str, days: int = 7) -> float:
    response = client.conversations_history(
        channel=os.environ['ONBOARDING_CHANNEL_ID'],
        oldest=(datetime.now() - timedelta(days=days)).timestamp(),
        latest=datetime.now().timestamp()
    )
    huddle_minutes = 0
    for msg in response['messages']:
        if msg.get('subtype') == 'huddle_thread' and user_id in msg.get('text', ''):
            huddle_minutes += int(msg.get('huddle_duration_minutes', 0))
    return huddle_minutes / 60
print(f'Huddle hours this week: {get_huddle_hours(\"U12345\")}')

import os
from slack_sdk import WebClient
import itertools

client = WebClient(token=os.environ['SLACK_BOT_TOKEN'])
mentors = ['U123', 'U456', 'U789']  # Senior engineer user IDs
mentor_cycle = itertools.cycle(mentors)

def assign_mentor(junior_id: str) -> str:
    mentor_id = next(mentor_cycle)
    # Send Slack message to mentor and junior
    client.chat_postMessage(
        channel=junior_id,
        text=f'You’ve been assigned mentor <@{mentor_id}> for onboarding. Schedule your first in-person sync this week.'
    )
    client.chat_postMessage(
        channel=mentor_id,
        text=f'You’ve been assigned junior <@{junior_id}>. Please schedule an in-person sync this week.'
    )
    return mentor_id
print(f'Assigned mentor: {assign_mentor(\"U10101\")}')

import os
from prometheus_client import CollectorRegistry, Gauge, push_to_gateway

def push_onboarding_metric(junior_id: str, weeks_to_pr: float, attrition_flag: int):
    registry = CollectorRegistry()
    g_weeks = Gauge('junior_weeks_to_prod_pr', 'Weeks to first production PR', ['junior_id'], registry=registry)
    g_attrition = Gauge('junior_attrition_flag', '1 if junior attrited in 6mo, else 0', ['junior_id'], registry=registry)

    g_weeks.labels(junior_id=junior_id).set(weeks_to_pr)
    g_attrition.labels(junior_id=junior_id).set(attrition_flag)

    push_to_gateway(os.environ['PROMETHEUS_PUSHGATEWAY'], job='onboarding_metrics', registry=registry)
    print(f'Pushed metrics for {junior_id} to Prometheus')
push_onboarding_metric('U10101', 10.2, 0)