{
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.13.0"
    },
    "blog_metadata": {
      "topic": "Burnout, AI, and the Reality Gap: What Enterprise Leaders Need to Hear Before the Next Copilot Rollout",
      "slug": "burnout-ai-and-the-reality-gap-what-enterprise-leaders-need-",
      "generated_by": "LinkedIn Post Generator + Azure OpenAI",
      "generated_at": "2026-08-05T19:14:00.089Z"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Burnout, AI, and the Reality Gap: What Enterprise Leaders Need to Hear Before the Next Copilot Rollout\n",
        "\n",
        "This notebook turns the blog post into a hands-on validation workbook. It focuses on the core claim: AI rollout success should be measured by reduced friction, lower rework, and improved human capacity—not by licenses assigned or prompt volume.\n",
        "\n",
        "You'll walk through simple simulations for burnout risk, rework-adjusted productivity, readiness checks, task routing, and KPI evaluation to test whether a Copilot rollout is actually improving work."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "%pip install pandas matplotlib seaborn"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from statistics import mean\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "sns.set_theme(style='whitegrid')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Rollout risk nobody sees in the demo\n",
        "\n",
        "The blog argues that the real failure mode is not lack of access, but lack of workflow redesign. The diagram below is represented as plain text so the logic can be reviewed directly in the notebook.\n",
        "\n",
        "**Flow:** Executive mandate to deploy fast → tool rollout → if no work redesign, context switching rises → shadow prompts and duplicate work → burnout risk increases → adoption stalls and trust drops. If redesign is included, the path shifts toward guardrails, training, metrics, and lower friction."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "rollout_paths = {\n",
        "    'without_redesign': [\n",
        "        'Executive mandate: deploy Copilot fast',\n",
        "        'Tool rollout',\n",
        "        'Context switching rises',\n",
        "        'Shadow prompts and duplicate work',\n",
        "        'Burnout risk increases',\n",
        "        'Adoption stalls and trust drops'\n",
        "    ],\n",
        "    'with_redesign': [\n",
        "        'Executive mandate: deploy Copilot fast',\n",
        "        'Tool rollout',\n",
        "        'Task inventory and workflow redesign',\n",
        "        'Guardrails, training, and metrics',\n",
        "        'Measured productivity and lower friction'\n",
        "    ]\n",
        "}\n",
        "\n",
        "for path_name, steps in rollout_paths.items():\n",
        "    print(f'\\n{path_name.upper()}')\n",
        "    for i, step in enumerate(steps, start=1):\n",
        "        print(f'{i}. {step}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Burnout risk scoring from simple team telemetry\n",
        "\n",
        "This example converts the blog's warning about overload into a basic scoring model. It uses after-hours messages, meetings per day, and tool hops as rough indicators of cognitive load and burnout risk."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Burnout risk scoring from simple team telemetry\n",
        "from statistics import mean\n",
        "\n",
        "team = [\n",
        "    {\"name\": \"Ava\", \"after_hours_msgs\": 18, \"meetings_per_day\": 7, \"tool_hops\": 14},\n",
        "    {\"name\": \"Noah\", \"after_hours_msgs\": 5, \"meetings_per_day\": 4, \"tool_hops\": 8},\n",
        "    {\"name\": \"Mia\", \"after_hours_msgs\": 11, \"meetings_per_day\": 6, \"tool_hops\": 12},\n",
        "]\n",
        "\n",
        "def burnout_risk(person: dict) -> float:\n",
        "    score = (\n",
        "        person[\"after_hours_msgs\"] * 0.4\n",
        "        + person[\"meetings_per_day\"] * 1.2\n",
        "        + person[\"tool_hops\"] * 0.6\n",
        "    )\n",
        "    return round(score, 1)\n",
        "\n",
        "scores = {p[\"name\"]: burnout_risk(p) for p in team}\n",
        "print(scores)\n",
        "print(\"team_avg_risk =\", round(mean(scores.values()), 1))\n",
        "\n",
        "risk_df = pd.DataFrame(team)\n",
        "risk_df['burnout_risk'] = risk_df.apply(burnout_risk, axis=1)\n",
        "display(risk_df)\n",
        "\n",
        "plt.figure(figsize=(7, 4))\n",
        "sns.barplot(data=risk_df, x='name', y='burnout_risk', palette='Reds')\n",
        "plt.title('Burnout Risk by Team Member')\n",
        "plt.ylabel('Risk Score')\n",
        "plt.xlabel('Employee')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Compare AI time saved against rework\n",
        "\n",
        "A central point in the post is that demo gains are not workflow gains. This example measures net value by subtracting rework minutes from minutes saved."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Compare AI time saved against rework to expose the reality gap\n",
        "tasks = [\n",
        "    {\"task\": \"draft_email\", \"minutes_saved\": 12, \"rework_minutes\": 3},\n",
        "    {\"task\": \"status_summary\", \"minutes_saved\": 20, \"rework_minutes\": 14},\n",
        "    {\"task\": \"meeting_notes\", \"minutes_saved\": 15, \"rework_minutes\": 2},\n",
        "]\n",
        "\n",
        "for item in tasks:\n",
        "    net = item[\"minutes_saved\"] - item[\"rework_minutes\"]\n",
        "    verdict = \"real gain\" if net > 5 else \"thin gain\" if net >= 0 else \"negative\"\n",
        "    print(f\"{item['task']}: net={net} min -> {verdict}\")\n",
        "\n",
        "rework_df = pd.DataFrame(tasks)\n",
        "rework_df['net_minutes'] = rework_df['minutes_saved'] - rework_df['rework_minutes']\n",
        "rework_df['verdict'] = rework_df['net_minutes'].apply(lambda net: 'real gain' if net > 5 else ('thin gain' if net >= 0 else 'negative'))\n",
        "display(rework_df)\n",
        "\n",
        "plt.figure(figsize=(8, 4))\n",
        "plot_df = rework_df.melt(id_vars='task', value_vars=['minutes_saved', 'rework_minutes', 'net_minutes'], var_name='metric', value_name='minutes')\n",
        "sns.barplot(data=plot_df, x='task', y='minutes', hue='metric')\n",
        "plt.title('AI Time Saved vs Rework vs Net Minutes')\n",
        "plt.ylabel('Minutes')\n",
        "plt.xlabel('Task')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Readiness audit before expansion\n",
        "\n",
        "The original post includes a PowerShell readiness check. Here it is translated into Python so you can validate the same logic in this notebook: if training or success metrics are missing, expansion is premature."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Audit Copilot readiness by checking policy, training, and workflow ownership\n",
        "readiness = {\n",
        "    'DataClassificationPolicy': True,\n",
        "    'PromptTrainingCompleted': False,\n",
        "    'WorkflowOwnerAssigned': True,\n",
        "    'SuccessMetricsDefined': False,\n",
        "}\n",
        "\n",
        "checks = [\n",
        "    {'Check': key, 'Status': 'Ready' if value else 'Gap'}\n",
        "    for key, value in readiness.items()\n",
        "]\n",
        "\n",
        "checks_df = pd.DataFrame(checks)\n",
        "display(checks_df)\n",
        "\n",
        "ready_count = (checks_df['Status'] == 'Ready').sum()\n",
        "gap_count = (checks_df['Status'] == 'Gap').sum()\n",
        "print(f'Ready checks: {ready_count}')\n",
        "print(f'Gap checks: {gap_count}')\n",
        "print('Expansion recommendation:', 'Hold expansion' if gap_count > 0 else 'Eligible to expand')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Sequence of a failed versus corrected rollout\n",
        "\n",
        "This sequence from the blog shows how a top-down rollout can create extra work for employees before leaders realize the workflow itself must be redesigned. The code below represents the sequence as ordered events."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "sequence_events = [\n",
        "    ('Executive Sponsor', 'IT Admin', 'Roll out Copilot this quarter'),\n",
        "    ('IT Admin', 'Team Manager', 'Enable licenses and controls'),\n",
        "    ('Team Manager', 'Employee', 'Use AI to move faster'),\n",
        "    ('Employee', 'Employee', 'Add prompting to existing workload'),\n",
        "    ('Employee', 'Team Manager', 'More output, but more rework/context switching'),\n",
        "    ('Team Manager', 'Executive Sponsor', 'Adoption is uneven; fatigue is rising'),\n",
        "    ('Executive Sponsor', 'Team Manager', 'Redesign workflows and success metrics')\n",
        "]\n",
        "\n",
        "for sender, receiver, message in sequence_events:\n",
        "    arrow = '->' if sender != receiver else '>>'\n",
        "    print(f'{sender} {arrow} {receiver}: {message}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Route work to AI only when the task is low-risk and well-bounded\n",
        "\n",
        "The post argues that not every process pain deserves an agent or AI assist. This example creates a simple decision rule: use AI only for low-risk, bounded tasks without sensitive data and with low ambiguity."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Route work to AI only when the task is low-risk and well-bounded\n",
        "def should_use_ai(task_type: str, contains_sensitive_data: bool, ambiguity: int) -> bool:\n",
        "    low_risk_tasks = {\"summarize\", \"rewrite\", \"extract_actions\", \"draft_outline\"}\n",
        "    if contains_sensitive_data:\n",
        "        return False\n",
        "    if task_type not in low_risk_tasks:\n",
        "        return False\n",
        "    return ambiguity <= 3\n",
        "\n",
        "samples = [\n",
        "    (\"summarize\", False, 2),\n",
        "    (\"performance_review\", True, 4),\n",
        "    (\"rewrite\", False, 5),\n",
        "]\n",
        "\n",
        "for task_type, sensitive, ambiguity in samples:\n",
        "    print(task_type, \"=>\", should_use_ai(task_type, sensitive, ambiguity))\n",
        "\n",
        "routing_df = pd.DataFrame(samples, columns=['task_type', 'contains_sensitive_data', 'ambiguity'])\n",
        "routing_df['use_ai'] = routing_df.apply(lambda row: should_use_ai(row['task_type'], row['contains_sensitive_data'], row['ambiguity']), axis=1)\n",
        "display(routing_df)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Measure meeting overload before and after rollout\n",
        "\n",
        "One practical recommendation in the post is to check ugly but useful indicators like meeting count before and after rollout. This Python version mirrors the PowerShell example and helps detect whether AI is actually reducing load."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Measure meeting overload before and after an AI rollout\n",
        "before = [6, 7, 5, 8, 6]\n",
        "after = [7, 8, 6, 8, 7]\n",
        "\n",
        "def get_average(values):\n",
        "    return round(sum(values) / len(values), 2)\n",
        "\n",
        "avg_before = get_average(before)\n",
        "avg_after = get_average(after)\n",
        "delta = round(avg_after - avg_before, 2)\n",
        "\n",
        "meeting_change = {\n",
        "    'AvgMeetingsBefore': avg_before,\n",
        "    'AvgMeetingsAfter': avg_after,\n",
        "    'Change': delta\n",
        "}\n",
        "\n",
        "print(meeting_change)\n",
        "\n",
        "meeting_df = pd.DataFrame({\n",
        "    'period': ['before', 'after'],\n",
        "    'avg_meetings': [avg_before, avg_after]\n",
        "})\n",
        "display(meeting_df)\n",
        "\n",
        "plt.figure(figsize=(6, 4))\n",
        "sns.barplot(data=meeting_df, x='period', y='avg_meetings', palette='Blues')\n",
        "plt.title('Average Meetings Before vs After Rollout')\n",
        "plt.ylabel('Average Meetings')\n",
        "plt.xlabel('Period')\n",
        "plt.show()\n",
        "\n",
        "print('Interpretation:', 'Overload increased' if delta > 0 else 'Overload decreased or stayed flat')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Balanced KPI view: productivity plus human cost\n",
        "\n",
        "The blog stresses that adoption alone is not enough. A rollout should only be considered healthy when productivity improves without rising rework or after-hours burden."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Build a simple KPI view that balances productivity with human cost\n",
        "metrics = {\n",
        "    \"adoption_rate\": 0.74,\n",
        "    \"minutes_saved_per_user\": 18,\n",
        "    \"rework_rate\": 0.31,\n",
        "    \"after_hours_change\": 0.22,\n",
        "}\n",
        "\n",
        "healthy_rollout = (\n",
        "    metrics[\"adoption_rate\"] >= 0.7\n",
        "    and metrics[\"minutes_saved_per_user\"] >= 15\n",
        "    and metrics[\"rework_rate\"] <= 0.2\n",
        "    and metrics[\"after_hours_change\"] <= 0.05\n",
        ")\n",
        "\n",
        "print(\"healthy_rollout =\", healthy_rollout)\n",
        "print(\"focus:\", \"redesign work\" if not healthy_rollout else \"scale carefully\")\n",
        "\n",
        "kpi_df = pd.DataFrame(list(metrics.items()), columns=['metric', 'value'])\n",
        "display(kpi_df)\n",
        "\n",
        "thresholds = {\n",
        "    'adoption_rate': 0.7,\n",
        "    'minutes_saved_per_user': 15,\n",
        "    'rework_rate': 0.2,\n",
        "    'after_hours_change': 0.05\n",
        "}\n",
        "\n",
        "kpi_df['threshold'] = kpi_df['metric'].map(thresholds)\n",
        "kpi_df['meets_target'] = kpi_df.apply(\n",
        "    lambda row: row['value'] >= row['threshold'] if row['metric'] in ['adoption_rate', 'minutes_saved_per_user'] else row['value'] <= row['threshold'],\n",
        "    axis=1\n",
        ")\n",
        "display(kpi_df)\n",
        "\n",
        "plt.figure(figsize=(8, 4))\n",
        "sns.barplot(data=kpi_df, x='metric', y='value', hue='meets_target', dodge=False)\n",
        "plt.title('Rollout KPI Check')\n",
        "plt.ylabel('Observed Value')\n",
        "plt.xlabel('Metric')\n",
        "plt.xticks(rotation=20)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## KPI review decision path\n",
        "\n",
        "The final diagram in the post says that if only output volume improves, leaders must check rework and after-hours load before scaling. The code below turns that logic into a small decision helper."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "def kpi_review_decision(output_volume_improved: bool, quality_improved: bool, human_cost_rising: bool) -> str:\n",
        "    if output_volume_improved and not quality_improved:\n",
        "        if human_cost_rising:\n",
        "            return 'Pause expansion and redesign workflow'\n",
        "        return 'Refine prompts and training'\n",
        "    if output_volume_improved and quality_improved:\n",
        "        return 'Validate sustainability and scale to adjacent use cases'\n",
        "    return 'Reassess workflow design and success metrics'\n",
        "\n",
        "scenarios = [\n",
        "    {'output_volume_improved': True, 'quality_improved': False, 'human_cost_rising': True},\n",
        "    {'output_volume_improved': True, 'quality_improved': False, 'human_cost_rising': False},\n",
        "    {'output_volume_improved': True, 'quality_improved': True, 'human_cost_rising': False},\n",
        "    {'output_volume_improved': False, 'quality_improved': False, 'human_cost_rising': True},\n",
        "]\n",
        "\n",
        "scenario_df = pd.DataFrame(scenarios)\n",
        "scenario_df['decision'] = scenario_df.apply(\n",
        "    lambda row: kpi_review_decision(row['output_volume_improved'], row['quality_improved'], row['human_cost_rising']),\n",
        "    axis=1\n",
        ")\n",
        "display(scenario_df)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Summary\n",
        "\n",
        "This notebook validates the blog's main argument: AI rollout quality depends on workflow redesign, readiness, governance, and human-capacity metrics—not just access or visible usage. The examples show how to test for burnout risk, rework drag, readiness gaps, poor task selection, overload, and misleading KPI stacks.\n",
        "\n",
        "## Next Steps\n",
        "\n",
        "1. Replace the sample data with metrics from one real pilot team.\n",
        "2. Add workflow-specific measures such as cycle time, escalation rate, and review burden.\n",
        "3. Define explicit thresholds for expansion versus pause.\n",
        "4. Review whether each sponsor can name the workflow that will stop, not just the tool that will ship.\n",
        "5. Use the notebook as a recurring rollout review template before broader Copilot expansion."
      ]
    }
  ]
}