{
  "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": "How AI Is Changing the Classroom and What That Means for Enterprise Training",
      "slug": "how-ai-is-changing-the-classroom-and-what-that-means-for-ent",
      "generated_by": "LinkedIn Post Generator + Azure OpenAI",
      "generated_at": "2026-07-09T20:05:28.527Z"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# How AI Is Changing the Classroom and What That Means for Enterprise Training\n",
        "\n",
        "This notebook turns the article's ideas into hands-on validation exercises. It focuses on a practical enterprise question: how to move from simple AI access to a repeatable operating model with literacy, governance, role-based training, and quality measurement.\n",
        "\n",
        "The classroom analogy matters because learning environments expose AI misuse quickly. The same issues show up in enterprises too, but with higher cost, more risk, and more governance pressure."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "%pip install pandas matplotlib seaborn"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from collections import defaultdict\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": [
        "## From classroom AI habits to enterprise training redesign\n",
        "\n",
        "The article argues that classroom failures are an early warning system for enterprise AI adoption. This simple flow shows how weak prompting, overreliance, policy confusion, and poor assessment design translate into the need for role-based learning, governance, and measurement."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "flow_edges = [\n",
        "    ('Classroom AI habits', 'Workplace expectations'),\n",
        "    ('Workplace expectations', 'Enterprise training redesign'),\n",
        "    ('Enterprise training redesign', 'Role-based learning paths'),\n",
        "    ('Enterprise training redesign', 'Governance and policy'),\n",
        "    ('Enterprise training redesign', 'Measurement and analytics'),\n",
        "    ('Role-based learning paths', 'Higher adoption quality'),\n",
        "    ('Governance and policy', 'Safer AI usage'),\n",
        "    ('Measurement and analytics', 'Continuous improvement'),\n",
        "]\n",
        "\n",
        "flow_df = pd.DataFrame(flow_edges, columns=['from', 'to'])\n",
        "print(flow_df.to_string(index=False))\n",
        "\n",
        "summary = flow_df.groupby('from').size().reset_index(name='outgoing_links')\n",
        "print('\\nNode influence summary:')\n",
        "print(summary.to_string(index=False))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Track AI training completion by role\n",
        "\n",
        "A core point in the article is that adoption is uneven by role and manager. This example calculates completion rates by role so you can see why blanket rollout metrics are often misleading."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from collections import defaultdict\n",
        "\n",
        "records = [\n",
        "    {'employee': 'Ava', 'role': 'Sales', 'completed': True},\n",
        "    {'employee': 'Noah', 'role': 'Sales', 'completed': False},\n",
        "    {'employee': 'Mia', 'role': 'HR', 'completed': True},\n",
        "    {'employee': 'Liam', 'role': 'HR', 'completed': True},\n",
        "]\n",
        "\n",
        "totals = defaultdict(int)\n",
        "done = defaultdict(int)\n",
        "\n",
        "for r in records:\n",
        "    totals[r['role']] += 1\n",
        "    done[r['role']] += int(r['completed'])\n",
        "\n",
        "for role in totals:\n",
        "    rate = done[role] / totals[role]\n",
        "    print(f\"{role}: completion_rate={rate:.0%} ({done[role]}/{totals[role]})\")\n",
        "\n",
        "completion_df = pd.DataFrame([\n",
        "    {'role': role, 'completion_rate': done[role] / totals[role], 'completed': done[role], 'total': totals[role]}\n",
        "    for role in totals\n",
        "])\n",
        "\n",
        "ax = sns.barplot(data=completion_df, x='role', y='completion_rate', palette='Blues_d')\n",
        "ax.set_title('AI Training Completion Rate by Role')\n",
        "ax.set_ylabel('Completion Rate')\n",
        "ax.set_xlabel('Role')\n",
        "plt.ylim(0, 1)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Score role-based adoption quality\n",
        "\n",
        "The article emphasizes that licenses and attendance do not equal capability. This example uses weighted signals for prompting, policy understanding, and task fit to estimate whether a learner is truly ready or still needs coaching."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "weights = {'prompting': 0.4, 'policy': 0.3, 'task_fit': 0.3}\n",
        "\n",
        "learners = [\n",
        "    {'name': 'Ava', 'role': 'Sales', 'prompting': 85, 'policy': 95, 'task_fit': 90},\n",
        "    {'name': 'Mia', 'role': 'HR', 'prompting': 70, 'policy': 98, 'task_fit': 88},\n",
        "]\n",
        "\n",
        "results = []\n",
        "for learner in learners:\n",
        "    score = sum(learner[k] * w for k, w in weights.items())\n",
        "    status = 'ready' if score >= 85 else 'coach'\n",
        "    results.append({'name': learner['name'], 'role': learner['role'], 'quality_score': round(score, 1), 'status': status})\n",
        "    print(f\"{learner['name']} ({learner['role']}): quality_score={score:.1f}, status={status}\")\n",
        "\n",
        "quality_df = pd.DataFrame(results)\n",
        "print('\\nQuality summary:')\n",
        "print(quality_df.to_string(index=False))\n",
        "\n",
        "ax = sns.barplot(data=quality_df, x='name', y='quality_score', hue='status', palette='Set2')\n",
        "ax.set_title('Role-Based Adoption Quality Scores')\n",
        "ax.set_ylabel('Quality Score')\n",
        "ax.set_xlabel('Learner')\n",
        "plt.ylim(0, 100)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Flag teams with high completion but low quality\n",
        "\n",
        "One of the strongest claims in the article is that usage and completion can rise while real capability remains weak. This example identifies teams that appear successful on paper but still need intervention because applied quality is too low."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "teams = [\n",
        "    {'team': 'Sales', 'completion_rate': 0.92, 'quality_score': 78},\n",
        "    {'team': 'HR', 'completion_rate': 0.88, 'quality_score': 91},\n",
        "    {'team': 'Finance', 'completion_rate': 0.95, 'quality_score': 74},\n",
        "]\n",
        "\n",
        "for t in teams:\n",
        "    needs_intervention = t['completion_rate'] >= 0.85 and t['quality_score'] < 80\n",
        "    if needs_intervention:\n",
        "        print(f\"Intervene: {t['team']} has strong completion but weak applied adoption quality.\")\n",
        "\n",
        "teams_df = pd.DataFrame(teams)\n",
        "teams_df['needs_intervention'] = (teams_df['completion_rate'] >= 0.85) & (teams_df['quality_score'] < 80)\n",
        "print('\\nTeam review table:')\n",
        "print(teams_df.to_string(index=False))\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(7, 4))\n",
        "sns.scatterplot(\n",
        "    data=teams_df,\n",
        "    x='completion_rate',\n",
        "    y='quality_score',\n",
        "    hue='needs_intervention',\n",
        "    s=150,\n",
        "    palette={True: 'red', False: 'green'},\n",
        "    ax=ax\n",
        ")\n",
        "for _, row in teams_df.iterrows():\n",
        "    ax.text(row['completion_rate'] + 0.002, row['quality_score'] + 0.3, row['team'])\n",
        "ax.axvline(0.85, linestyle='--', color='gray')\n",
        "ax.axhline(80, linestyle='--', color='gray')\n",
        "ax.set_title('Completion vs Adoption Quality')\n",
        "ax.set_xlabel('Completion Rate')\n",
        "ax.set_ylabel('Quality Score')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Simulate a learning-to-governance feedback loop\n",
        "\n",
        "The article argues that learning teams, managers, IT, and governance should not operate separately. This Python version of the sequence diagram models a simple event trail showing how baseline learning, simulated practice, metrics, and coaching can connect."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "events = [\n",
        "    ('AI-native employee', 'Learning platform', 'Completes AI fundamentals'),\n",
        "    ('Learning platform', 'Manager', 'Share role-based progress'),\n",
        "    ('AI-native employee', 'Learning platform', 'Uses AI in simulated tasks'),\n",
        "    ('Learning platform', 'IT/Governance', 'Send adoption quality metrics'),\n",
        "    ('IT/Governance', 'Manager', 'Recommend guardrails and coaching'),\n",
        "    ('Manager', 'AI-native employee', 'Reinforce safe, effective usage'),\n",
        "]\n",
        "\n",
        "events_df = pd.DataFrame(events, columns=['source', 'target', 'action'])\n",
        "print(events_df.to_string(index=False))\n",
        "\n",
        "print('\\nOrdered feedback loop:')\n",
        "for i, row in events_df.iterrows():\n",
        "    print(f\"{i+1}. {row['source']} -> {row['target']}: {row['action']}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Model Copilot enablement as an operating workflow\n",
        "\n",
        "The article frames AI deployment as more than a feature rollout. This example converts the rollout logic into a simple dependency table so you can validate the sequence from license assignment to governance checks, role-based rollout, training completion, and scale decisions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "enablement_edges = [\n",
        "    ('Copilot enablement', 'License assignment'),\n",
        "    ('License assignment', 'Governance readiness checks'),\n",
        "    ('Governance readiness checks', 'Sensitivity labels'),\n",
        "    ('Governance readiness checks', 'Access and compliance review'),\n",
        "    ('Sensitivity labels', 'Role-based rollout'),\n",
        "    ('Access and compliance review', 'Role-based rollout'),\n",
        "    ('Role-based rollout', 'Training completion tracking'),\n",
        "    ('Training completion tracking', 'Adoption quality review'),\n",
        "    ('Adoption quality review', 'Scale or remediate'),\n",
        "]\n",
        "\n",
        "enablement_df = pd.DataFrame(enablement_edges, columns=['from', 'to'])\n",
        "print(enablement_df.to_string(index=False))\n",
        "\n",
        "prereq_counts = enablement_df.groupby('to').size().reset_index(name='prerequisite_count').sort_values('prerequisite_count', ascending=False)\n",
        "print('\\nSteps with the most prerequisites:')\n",
        "print(prereq_counts.to_string(index=False))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Optional environment variables for Microsoft validation\n",
        "\n",
        "The original article includes PowerShell examples for Microsoft Graph and Exchange Online. Those commands are not executed in this Python notebook, but if you later connect to Microsoft APIs from Python, you will typically need variables such as:\n",
        "\n",
        "- `TENANT_ID`\n",
        "- `CLIENT_ID`\n",
        "- `CLIENT_SECRET`\n",
        "- `AZURE_AUTHORITY_HOST` (optional, depending on cloud)\n",
        "- `GRAPH_SCOPE` or API-specific scopes\n",
        "\n",
        "Use a secure secret store rather than hardcoding credentials."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Microsoft operational checks translated into Python-friendly validation ideas\n",
        "\n",
        "The blog includes PowerShell examples for license counts, licensed-user outreach, and sensitivity-label readiness. This cell creates sample data that mirrors those operational checks so you can validate the logic in Python without requiring live tenant access."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "subscribed_skus = [\n",
        "    {'SkuPartNumber': 'COPILOT_M365', 'Enabled': 500, 'Consumed': 420},\n",
        "    {'SkuPartNumber': 'POWER_PLATFORM_COPILOT', 'Enabled': 200, 'Consumed': 150},\n",
        "]\n",
        "\n",
        "for sku in subscribed_skus:\n",
        "    sku['Available'] = sku['Enabled'] - sku['Consumed']\n",
        "\n",
        "sku_df = pd.DataFrame(subscribed_skus)\n",
        "print('Copilot-related SKU summary:')\n",
        "print(sku_df.to_string(index=False))\n",
        "\n",
        "users = [\n",
        "    {'DisplayName': 'Ava Stone', 'UserPrincipalName': 'ava@contoso.com', 'LicenseCount': 3},\n",
        "    {'DisplayName': 'Noah Reed', 'UserPrincipalName': 'noah@contoso.com', 'LicenseCount': 1},\n",
        "    {'DisplayName': 'Mia Chen', 'UserPrincipalName': 'mia@contoso.com', 'LicenseCount': 4},\n",
        "    {'DisplayName': 'Liam Patel', 'UserPrincipalName': 'liam@contoso.com', 'LicenseCount': 2},\n",
        "]\n",
        "\n",
        "licensed_df = pd.DataFrame(users).sort_values('LicenseCount', ascending=False)\n",
        "print('\\nTop licensed users for training outreach:')\n",
        "print(licensed_df.head(10).to_string(index=False))\n",
        "\n",
        "labels = ['Confidential', 'Internal Only', 'Public']\n",
        "label_summary = {\n",
        "    'LabelCount': len(labels),\n",
        "    'HasLabels': len(labels) > 0,\n",
        "    'Sample': ', '.join(labels[:3])\n",
        "}\n",
        "print('\\nGovernance readiness signal:')\n",
        "print(label_summary)\n",
        "\n",
        "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n",
        "sns.barplot(data=sku_df, x='SkuPartNumber', y='Available', palette='Purples_d', ax=axes[0])\n",
        "axes[0].set_title('Available Copilot-Related Licenses')\n",
        "axes[0].set_xlabel('SKU')\n",
        "axes[0].set_ylabel('Available')\n",
        "axes[0].tick_params(axis='x', rotation=20)\n",
        "\n",
        "sns.barplot(data=licensed_df, x='DisplayName', y='LicenseCount', palette='Oranges_d', ax=axes[1])\n",
        "axes[1].set_title('Licensed Users for Outreach Prioritization')\n",
        "axes[1].set_xlabel('User')\n",
        "axes[1].set_ylabel('License Count')\n",
        "axes[1].tick_params(axis='x', rotation=30)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 90-day action plan scorecard\n",
        "\n",
        "The article recommends five immediate actions: audit current training, segment by risk and workflow, define a minimum viable literacy standard, measure quality instead of just usage, and build a live outreach list. This example turns those recommendations into a simple maturity scorecard."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "actions = [\n",
        "    {'action': 'Audit current AI training', 'done': True},\n",
        "    {'action': 'Segment by risk and workflow', 'done': True},\n",
        "    {'action': 'Define minimum viable AI literacy standard', 'done': False},\n",
        "    {'action': 'Measure adoption quality, not just usage', 'done': True},\n",
        "    {'action': 'Build live outreach list for enablement', 'done': False},\n",
        "]\n",
        "\n",
        "actions_df = pd.DataFrame(actions)\n",
        "actions_df['status'] = actions_df['done'].map({True: 'complete', False: 'pending'})\n",
        "completion_pct = actions_df['done'].mean()\n",
        "\n",
        "print(actions_df.to_string(index=False))\n",
        "print(f\"\\n90-day action completion: {completion_pct:.0%}\")\n",
        "\n",
        "maturity_level = 1\n",
        "if completion_pct >= 0.8:\n",
        "    maturity_level = 4\n",
        "elif completion_pct >= 0.6:\n",
        "    maturity_level = 3\n",
        "elif completion_pct >= 0.4:\n",
        "    maturity_level = 2\n",
        "\n",
        "print(f\"Estimated operating-model maturity level: {maturity_level}/5\")\n",
        "\n",
        "ax = sns.countplot(data=actions_df, x='status', palette='Set1')\n",
        "ax.set_title('90-Day AI Operating Model Action Status')\n",
        "ax.set_xlabel('Status')\n",
        "ax.set_ylabel('Count')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Summary\n",
        "\n",
        "This notebook validates the article's main argument: enterprise AI success depends less on access alone and more on operating discipline. Completion rates, license counts, and usage volume are useful, but they are incomplete unless paired with role-based workflow training, governance readiness, manager coaching, and adoption-quality measurement.\n",
        "\n",
        "## Next Steps\n",
        "\n",
        "1. Replace generic AI awareness training with role-specific scenarios.\n",
        "2. Add quality metrics that test prompting, policy understanding, verification, and task fit.\n",
        "3. Build a feedback loop between learning teams, managers, IT, and governance.\n",
        "4. Use license and readiness data to target enablement where it matters most.\n",
        "5. Rate your current AI operating model from 1 to 5 and identify the biggest blocker to safe scale."
      ]
    }
  ]
}