Copilot Training Programs: How to Build AI Literacy Across Your Organization

Your organization deployed Microsoft 365 Copilot to 5,000 users with a 90-minute webinar and a PDF user guide. Three months later, adoption is stuck at 25%, users complain that "Copilot doesn't work," and your CFO is questioning the $1.8M annual investment.

The problem isn't Copilot. It's that your users don't understand how to work with AI systems. They're treating Copilot like Google Search—typing three-word queries and expecting perfect results. They don't know how to provide context, iterate on prompts, or recognize when a task is outside Copilot's capabilities. AI literacy, not product training, is the missing ingredient.

This guide provides a technical framework for building Copilot training programs that scale across an enterprise. It covers AI literacy fundamentals, role-based learning paths, prompt engineering curriculum, hands-on workshop design, change management integration, and metrics for measuring training effectiveness. Organizations that implement this framework achieve 2-3x higher adoption rates within six months compared to those relying on vendor-provided materials alone.

The AI Literacy Gap: Why Product Training Fails

Traditional software training assumes users understand the tool's capabilities and limitations. For Word, that's reasonable—everyone knows Word can format documents but can't predict stock prices. For AI systems like Copilot, users have no mental model of what's possible.

Common misconceptions that undermine adoption:

1. "Copilot should know what I want without me explaining it." Users expect Copilot to read their mind. When it doesn't, they conclude it's broken.

2. "If Copilot gives me a bad result, it's useless." Users don't understand that AI outputs improve with iterative refinement. They treat the first response as final.

3. "Copilot will replace my job." Fear drives avoidance. Users resist learning something they believe threatens their employment.

4. "Copilot is just fancy autocomplete." Users underestimate capabilities and apply it to trivial tasks (spell-checking, formatting) instead of high-value work (research, analysis, content generation).

5. "Copilot should work like Google." Users type short, vague queries. When Copilot asks for clarification, they interpret it as failure.

The root cause: Lack of AI literacy. Users don't understand how large language models work, what they're good at, what they struggle with, or how to communicate effectively with them.

The solution: Training programs that build AI literacy first, then teach Copilot-specific features second. AI literacy is the foundation; product knowledge is the application layer.

AI Literacy Fundamentals: What Every User Must Understand

Before teaching users which buttons to click, teach them how AI systems think. This is a 30-45 minute prerequisite module for all roles.

Concept 1: Copilot Is a Language Model, Not a Database

What users need to understand: Copilot generates responses based on patterns learned from training data, not by looking up exact answers in a database. It predicts the most likely next word based on context, then the next word, and so on.

Practical implication: Copilot can generate plausible-sounding nonsense (hallucinations). Users must verify critical information, especially financial data, legal language, or technical specifications.

Teaching approach: Show two side-by-side examples—one where Copilot summarizes a known document accurately, and one where it fabricates details when the source doesn't exist. Ask users to spot the difference. Make hallucinations concrete and memorable.

Concept 2: Context Is Everything

What users need to understand: Copilot has no memory of your previous conversations (within a session), no access to your mental model of the task, and no understanding of your organization's specific jargon unless you provide it.

Practical implication: The more context you provide in your prompt, the better the result. "Summarize this document" produces generic output. "Summarize this compliance audit report, focusing on HIPAA violations and recommended remediation timelines" produces actionable output.

Teaching approach: Run a live demonstration where you submit a vague prompt, get poor results, then re-submit with rich context and show the quality difference. Make this visceral, not theoretical.

Concept 3: Iteration Is the Workflow

What users need to understand: The first response from Copilot is a draft, not a finished product. Effective Copilot users submit 3-7 prompts per task, refining the output iteratively.

Practical implication: If you're not iterating, you're using Copilot wrong. The workflow is: (1) Initial prompt with context, (2) Review output, (3) Refine prompt with additional constraints or corrections, (4) Review again, (5) Repeat until satisfied.

Teaching approach: Show a before-and-after example of a poorly written email (one-shot prompt) versus a well-crafted email (five-iteration prompt). Count the iterations publicly and normalize multi-turn conversations as the standard workflow.

Concept 4: Know When to Use Copilot (and When Not To)

What users need to understand: Copilot excels at summarization, drafting, brainstorming, and pattern recognition. It struggles with precise calculations, real-time data, complex logic, and tasks requiring deep domain expertise.

Practical implication: Don't use Copilot for financial modeling, legal contracts, or mission-critical code without human review. Do use it for meeting recaps, email drafting, report outlines, and research synthesis.

Teaching approach: Provide a decision tree: "Is this task primarily about language (yes → use Copilot) or calculations/logic (no → use traditional tools)?" Make the boundary explicit.

Concept 5: Copilot Learns From Your Organization's Data (With Limits)

What users need to understand: Copilot can retrieve information from SharePoint, OneDrive, Teams, and Outlook based on your permissions. It doesn't train on your data (Microsoft's grounding approach), but it can surface documents you have access to.

Practical implication: If Copilot can't find information you know exists, it's a permissions issue, not a Copilot failure. Review data governance configuration if retrieval is failing.

Teaching approach: Demonstrate Copilot retrieving a SharePoint document, explain how Graph API permissions control access, and show what happens when a document is inaccessible (Copilot says "I can't find information on that").

Role-Based Training Paths: One Size Does Not Fit All

Executives, managers, and individual contributors use Copilot differently. Training must reflect these differences.

Training Path 1: Executives and Senior Leaders (60 minutes)

Objectives:

• Understand strategic value of Copilot (ROI, productivity gains, competitive advantage)
• Use Copilot for high-level summarization and decision support
• Model Copilot adoption to drive organizational buy-in

Curriculum:

1. AI literacy fundamentals (15 min): Concepts 1-5 above
2. Executive use cases (20 min):
   • Summarizing long email threads to identify action items
   • Generating meeting agendas based on previous discussions
   • Drafting executive communications (all-hands emails, board updates)
   • Analyzing business reports and extracting key insights
3. Prompt engineering for executives (15 min):
   • How to provide context in 2-3 sentences
   • Using Copilot in Outlook and Teams (most relevant apps for executives)
   • Iterating to refine summaries and drafts
4. Change leadership (10 min):
   • How to communicate Copilot value to your team
   • Leading by example: using Copilot in visible ways
   • Addressing employee concerns about AI and job security

Delivery format: Live, instructor-led session (not recorded). Executives need peer interaction and credibility of in-person training. Use their real emails and documents (with permission) for demonstrations.

Follow-up: Provide executive assistants with prompt engineering training so they can prepare materials for executives to refine with Copilot.

Training Path 2: Managers and Team Leads (90 minutes)

Objectives:

• Use Copilot to improve team productivity (meeting recaps, project updates, performance reviews)
• Coach direct reports on effective Copilot usage
• Identify team-specific use cases and measure adoption

Curriculum:

1. AI literacy fundamentals (15 min): Concepts 1-5 above
2. Manager use cases (30 min):
   • Creating meeting recaps and distributing action items (Teams Copilot)
   • Drafting performance reviews and 1-on-1 notes (Word Copilot)
   • Synthesizing project status from multiple sources (Copilot in Teams/SharePoint)
   • Generating team communications and announcements (Outlook Copilot)
   • Analyzing team collaboration patterns (Viva Insights + Copilot)
3. Prompt engineering for managers (20 min):
   • Structuring prompts for summarization tasks
   • Using Copilot to draft, then humanizing the output
   • Iterative refinement techniques
   • Handling sensitive topics (performance feedback, conflict resolution)
4. Coaching your team (15 min):
   • Identifying team members who struggle with Copilot
   • Sharing successful prompts and use cases
   • Integrating Copilot into team rituals (meeting recaps, status updates)
   • Measuring team adoption with KPIs
5. Hands-on practice (10 min):
   • Draft a meeting recap from a real Teams meeting
   • Create a project status update using Copilot in Word
   • Refine outputs through iteration

Delivery format: Hybrid (live + recorded). Managers need live interaction but also benefit from recorded modules for reference.

Follow-up: Monthly "manager office hours" where managers share successful use cases and troubleshoot challenges.

Training Path 3: Individual Contributors (2 hours, split across two sessions)

Objectives:

• Apply Copilot to daily work tasks (emails, documents, data analysis)
• Develop prompt engineering skills for complex tasks
• Build confidence through hands-on practice

Curriculum (Session 1: Foundations, 60 min):

1. AI literacy fundamentals (15 min): Concepts 1-5 above
2. Core Copilot features (30 min):
   • Copilot in Outlook: drafting, summarizing, tone adjustment
   • Copilot in Teams: meeting recap, conversation summarization
   • Copilot in Word: drafting documents, rewriting sections, creating outlines
   • Copilot in PowerPoint: generating slides from documents
   • Copilot in Excel: formula generation, data analysis (when to use, when not to)
3. Prompt engineering basics (15 min):
   • Anatomy of a good prompt: context, task, constraints, format
   • Vague vs. specific prompts (side-by-side examples)
   • Adding context to improve results
   • Iterative refinement workflow

Curriculum (Session 2: Application, 60 min):

1. Hands-on workshop (45 min):
   • Exercise 1: Draft a client email using Copilot in Outlook (10 min)
   • Exercise 2: Summarize a long email thread and identify action items (10 min)
   • Exercise 3: Create a project proposal outline in Word using Copilot (15 min)
   • Exercise 4: Generate a meeting recap from a Teams recording (10 min)
   • Each exercise includes peer review and iteration practice
2. Common mistakes and troubleshooting (10 min):
   • Recognizing hallucinations
   • Handling "I can't find information" responses
   • When to escalate to IT (permissions issues, data access problems)
3. Resources and next steps (5 min):
   • Prompt engineering guide for advanced techniques
   • Internal Copilot champions for ongoing support
   • Feedback channel for reporting issues or suggesting improvements

Delivery format: Live, instructor-led with breakout rooms for hands-on exercises. Maximum 25 participants per session to allow individual coaching.

Follow-up: 30-day post-training survey to measure usage, satisfaction, and time savings. Offer "booster sessions" for users who struggle.

Training Path 4: Technical Roles (IT, Data Analysts, Developers) (90 minutes)

Objectives:

• Use Copilot for technical tasks (troubleshooting, code review, data analysis)
• Understand Copilot's technical limitations and security model
• Support end users with Copilot-related issues

Curriculum:

1. AI literacy fundamentals (10 min): Concepts 1-5 above (condensed for technical audience)
2. Technical use cases (30 min):
   • Copilot in Excel: data analysis, pivot table generation, formula debugging
   • Copilot for troubleshooting: generating diagnostic scripts, analyzing error logs
   • Copilot in code review: summarizing pull requests, suggesting improvements (if using GitHub Copilot)
   • Copilot for documentation: auto-generating API docs, technical specifications
3. Technical architecture (20 min):
   • How Copilot retrieves data (Microsoft Graph API, semantic indexing)
   • Security model (data residency, access controls, privacy commitments)
   • Troubleshooting data access issues (permissions, indexing delays)
   • Integration with other Microsoft 365 services
4. Prompt engineering for technical tasks (20 min):
   • Writing prompts for code generation and debugging
   • Using Copilot to generate SQL queries, PowerShell scripts, Python code
   • Iterating on technical outputs
   • Verifying AI-generated code (never trust without testing)
5. Supporting end users (10 min):
   • Common user issues and resolutions
   • Escalation paths for bugs or product limitations
   • Communicating Copilot capabilities and limitations to non-technical users

Delivery format: Live, technical deep-dive with Q&A. Include architecture diagrams and API documentation references.

Follow-up: Create internal knowledge base articles for common technical issues.

Prompt Engineering Training: The Core Skill

Prompt engineering is the most important skill for Copilot users. It's the difference between "Copilot doesn't work" and "Copilot saved me 10 hours this week."

Prompt Engineering Curriculum (30-45 minutes, standalone module)

Learning objective: Write effective prompts that produce high-quality Copilot outputs with minimal iteration.

Module outline:

1. Anatomy of a Prompt (10 min):

• Context: Who you are, what you're working on, relevant background
• Task: What you want Copilot to do (summarize, draft, analyze, generate)
• Constraints: Limitations or requirements (tone, length, format, audience)
• Format: How you want the output structured (bullet points, paragraphs, table)

Example transformation:

• Bad prompt: "Summarize this document"
• Good prompt: "I'm preparing for a board meeting. Summarize this Q3 financial report, focusing on revenue variances, major expenses, and cash flow concerns. Keep it to 5 bullet points for a non-financial audience."

2. Specificity vs. Vagueness (10 min):

• Principle: Specific prompts produce better results. Vague prompts force Copilot to guess your intent.
• Exercise: Show 5 vague prompts, ask participants to rewrite them with specificity.
• Example:
  • Vague: "Help me with this email"
  • Specific: "Rewrite this email to be more diplomatic. I'm declining a meeting request but want to suggest an alternative time next week. Use a friendly but professional tone."

3. Adding Context (10 min):

• Principle: Copilot doesn't know your job, your organization, or your current project. Tell it.
• Examples:
  • "I'm a project manager at a healthcare company. Summarize this compliance audit report for non-technical stakeholders."
  • "I'm preparing a sales proposal for a financial services client. Generate an executive summary highlighting security, compliance, and ROI."
• Exercise: Rewrite a generic prompt by adding organizational context.

4. Iterative Refinement (10 min):

• Principle: The first output is never perfect. Plan for 3-5 iterations.
• Workflow:
  • Iteration 1: Submit initial prompt with context
  • Iteration 2: Add constraints ("Make it shorter" or "Focus more on risk")
  • Iteration 3: Adjust tone or format ("Make it less formal" or "Convert to bullet points")
  • Iteration 4: Correct errors or add missing information
• Demonstration: Live demo of iterative refinement on a real task (email drafting or report summarization).

5. Common Mistakes (5 min):

• Mistake 1: Treating Copilot like Google (typing 3-word queries)
• Mistake 2: Accepting the first response without review
• Mistake 3: Overloading a single prompt (ask for one thing at a time)
• Mistake 4: Not specifying tone or audience
• Mistake 5: Using Copilot for tasks it can't handle (complex calculations, real-time data)

Delivery format: Live demonstration with audience participation. Provide prompt templates as downloadable resources.

Follow-up: Create a "prompt library" where users share successful prompts for common tasks. Integrate into champions program.

Hands-On Workshops: Practice Makes Proficient

Passive learning (watching videos, reading guides) produces low retention. Hands-on practice with real tasks produces skill development.

Workshop Design Principles

1. Use real work, not toy examples: Participants should practice on their actual emails, documents, and meetings—not generic demo content. This increases relevance and retention.

2. Structured iteration: Force participants to iterate on outputs. Require 3+ prompts per exercise.

3. Peer review: Have participants share prompts and outputs with a partner. Peer feedback accelerates learning.

4. Fail safely: Create a sandbox environment where participants can experiment without fear of sending bad emails or creating embarrassing documents.

5. Time-boxed exercises: Limit each exercise to 10-15 minutes to maintain energy and focus.

Sample Workshop Agenda (90 minutes)

Exercise 1: Email Drafting (15 min):

• Task: Draft a response to a difficult email (customer complaint, project delay, budget overrun).
• Prompt requirements: Include context, tone, and constraints.
• Iteration requirement: Submit at least 3 prompts, refining the output each time.
• Peer review: Share final output with partner for feedback.

Exercise 2: Meeting Summarization (15 min):

• Task: Use Teams Copilot to generate a meeting recap from a recent meeting.
• Prompt requirements: Request specific sections (decisions made, action items, open questions).
• Iteration requirement: Refine the recap to focus on your priorities.
• Group debrief: Share one surprising or valuable insight Copilot surfaced.

Exercise 3: Document Drafting (20 min):

• Task: Create a project proposal, status report, or policy document outline using Word Copilot.
• Prompt requirements: Provide context (audience, purpose, key points to cover).
• Iteration requirement: Iterate to add sections, adjust tone, or incorporate feedback.
• Peer review: Exchange drafts and provide constructive feedback.

Exercise 4: Data Analysis (15 min, optional for technical roles):

• Task: Use Excel Copilot to analyze a dataset (sales data, survey results, operational metrics).
• Prompt requirements: Ask Copilot to identify trends, outliers, or correlations.
• Iteration requirement: Refine analysis based on business questions.
• Reality check: Verify Copilot's findings manually to identify errors or hallucinations.

Exercise 5: Prompt Troubleshooting (15 min):

• Task: Instructor provides 5 poorly written prompts. Participants rewrite them using prompt engineering principles.
• Group discussion: Share rewrites and discuss what improved.

Wrap-up (10 min):

• Recap key principles (context, iteration, specificity).
• Distribute resources (prompt engineering guide, internal support channels).
• Collect feedback on workshop effectiveness.

Change Management Integration: Training Isn't Enough

Training teaches skills. Change management drives adoption. Effective Copilot training programs integrate change management from day one.

Change Management Components

1. Executive sponsorship: Executives must use Copilot visibly and communicate its value regularly. If the CEO doesn't use Copilot, why should anyone else?

2. Champions network: Identify 20-30 early adopters across departments to serve as peer coaches. Provide champions with advanced training and recognition. See Copilot Champions Program for implementation details.

3. Success stories: Share specific examples of time saved, productivity gained, or problems solved using Copilot. Make success tangible with metrics (adoption KPIs).

4. Ongoing support: Training is not one-and-done. Offer office hours, drop-in clinics, and refresher sessions. Users need support during the first 90 days of usage.

5. Addressing resistance: Some users will resist Copilot due to fear, skepticism, or bad initial experiences. Train managers to identify and coach resistant users.

Resistance Patterns and Responses

Resistance: "I don't have time to learn this."

• Response: "Copilot will save you 3-5 hours per week once you're proficient. The 2-hour training investment pays back in week one."

Resistance: "Copilot will replace my job."

• Response: "Copilot handles repetitive tasks so you can focus on strategic work. It's a tool, not a replacement."

Resistance: "I tried Copilot and it didn't work."

• Response: "What did you try? Let's troubleshoot together." (Often reveals user didn't provide enough context or iterate on prompts.)

Resistance: "I don't trust AI."

• Response: "That's healthy skepticism. Always verify critical outputs. Use Copilot as a draft generator, not a final authority."

Measuring Training Effectiveness

Training programs must be measured and optimized. Track these metrics:

Metric 1: Training completion rate: Percentage of users who complete required training within 30 days of license assignment.

• Target: >90%

Metric 2: Post-training adoption rate: Percentage of trained users who become active Copilot users (5+ prompts/week for 3 consecutive weeks) within 60 days of training.

• Target: >60%

Metric 3: Knowledge retention: Pre- and post-training quiz scores on AI literacy and prompt engineering concepts.

• Target: >80% post-training score

Metric 4: Self-reported confidence: Survey question: "How confident are you in your ability to use Copilot effectively?" (1-5 scale)

• Target: Average >4.0 post-training

Metric 5: Time to proficiency: Days from training completion to sustained Copilot usage (defined as 4 consecutive weeks of 5+ prompts/week).

• Target: <30 days

Metric 6: Training satisfaction: Net Promoter Score (NPS) for training program.

• Target: >50

Red flags:

• High training completion but low adoption → Training is not translating to real-world usage (content too generic, not hands-on enough)
• Low knowledge retention scores → Training moving too fast or too complex
• High satisfaction but low time savings → Users enjoying training but not applying skills to high-value tasks

Continuous Learning: Training Beyond Day One

Copilot evolves rapidly. Microsoft ships new features monthly. Users need ongoing education to stay current.

Continuous learning strategies:

1. Monthly "What's New" webinars: 30-minute sessions highlighting new Copilot features and use cases.

2. Prompt library: Centralized repository of successful prompts for common tasks. Crowdsource contributions from users.

3. Champions-led lunch-and-learns: Monthly sessions where champions demonstrate advanced techniques.

4. Role-specific office hours: Weekly drop-in sessions where users can ask questions and get live coaching.

5. Quarterly refresher training: 60-minute sessions reviewing fundamentals and introducing advanced topics.

6. Certification program: Optional certification for users who demonstrate proficiency through hands-on assessments.

Training Budget and Resource Requirements

Budget assumptions for 5,000-user deployment:

• Executive training (50 executives): 2 sessions × 60 min × 1 facilitator = 10 hours facilitator time = $5,000
• Manager training (500 managers): 20 sessions × 90 min × 1 facilitator = 30 hours = $15,000
• Individual contributor training (4,450 ICs): 200 sessions × 120 min × 2 facilitators = 800 hours = $80,000
• Prompt engineering workshops: 50 sessions × 60 min × 1 facilitator = 50 hours = $12,500
• Materials development (guides, videos, templates): 200 hours × $150/hour = $30,000
• Champions program support: 100 hours × $100/hour = $10,000
• Continuous learning (year one): 50 sessions × 30 min × 1 facilitator = 25 hours = $6,250

Total first-year training cost: ~$158,750

Cost per user: ~$32

ROI calculation: If training increases adoption from 30% to 70% and each active user saves 4 hours/week at $50/hour, the incremental productivity value is:

• Additional active users: 2,000 (from 1,500 to 3,500)
• Annual value: 2,000 × 4 hours/week × 52 weeks × $50 = $20.8M
• Training ROI: (20.8M - 158K) / 158K = 13,000%

Even with conservative assumptions (2 hours/week saved, $30/hour labor cost), training ROI exceeds 3,000%.

Conclusion: Training Is the Adoption Multiplier

Microsoft 365 Copilot is powerful technology, but it's not intuitive. Users need AI literacy, prompt engineering skills, and hands-on practice to extract value. Organizations that invest in comprehensive training programs achieve 2-3x higher adoption rates and 4-5x higher productivity gains compared to those that rely on vendor materials alone.

The training framework:

1. AI literacy fundamentals for all users (30-45 min)
2. Role-based learning paths (60-120 min depending on role)
3. Prompt engineering training (30-45 min standalone module)
4. Hands-on workshops (90 min with real work)
5. Change management integration (champions, success stories, executive sponsorship)
6. Continuous learning (monthly updates, office hours, refreshers)

Measure training effectiveness with adoption rates, knowledge retention, and time-to-proficiency metrics. Iterate on curriculum based on data, not assumptions.

Training is not a one-time event. It's an ongoing investment in organizational capability. The organizations that win with AI are those that build AI literacy at scale, not just deploy technology and hope for the best.

---

Frequently Asked Questions

How long should Copilot training take?

Training duration varies by role. Executives need 60 minutes (AI literacy + strategic use cases), managers need 90 minutes (use cases + team coaching), and individual contributors need 2 hours split across two sessions (foundations + hands-on practice). All roles benefit from a 30-45 minute prompt engineering module. Total time investment per user: 2-3 hours over the first 30 days. Organizations that compress training into a single 90-minute session see 40-50% lower adoption rates than those using this structured, role-based approach. Training is ongoing—plan for quarterly refreshers and monthly "What's New" webinars.

Do executives need training?

Yes. Executive participation is critical for organizational buy-in. If executives don't use Copilot, why should anyone else? Executive training should be customized: focus on high-level use cases (email summarization, meeting recaps, executive communications), strategic value (ROI calculations), and change leadership (how to model Copilot adoption). Executives need 60 minutes of live, instructor-led training—not a recorded webinar. Use their real emails and documents for demonstrations. Provide executive assistants with training so they can prepare materials for executives to refine with Copilot. Executive adoption drives adoption metrics across the organization.

What should users learn first?

Start with AI literacy fundamentals before teaching product features. Users must understand five core concepts: (1) Copilot is a language model that predicts text, not a database with exact answers, (2) context is everything—the more you provide, the better the results, (3) iteration is the workflow—first responses are drafts, not final outputs, (4) Copilot excels at language tasks (summarization, drafting) but struggles with calculations and logic, (5) Copilot retrieves data based on your permissions. Only after users grasp these concepts should you teach specific features (Copilot in Outlook, Teams, Word). Organizations that skip AI literacy and jump to product training see 50% lower adoption and higher frustration rates.

How do I measure training effectiveness?

Track six key metrics: (1) training completion rate (target >90% within 30 days of license assignment), (2) post-training adoption rate (target >60% of trained users becoming active within 60 days), (3) knowledge retention via pre/post-training quizzes (target >80% post-training score), (4) self-reported confidence (target >4.0 on 1-5 scale), (5) time to proficiency (target <30 days from training to sustained usage), (6) training satisfaction via Net Promoter Score (target >50). Cross-reference with business metrics: if training completion is high but adoption KPIs are low, training content is too generic or not hands-on enough. If satisfaction is high but time savings is low, users aren't applying skills to high-value tasks.

What if users say "Copilot doesn't work"?

This usually means users don't understand prompt engineering. Investigate: (1) Are users providing context in prompts, or just typing 3-word queries? (2) Are users iterating on outputs, or accepting the first response? (3) Are users applying Copilot to appropriate tasks (language-based work) or inappropriate tasks (complex calculations, real-time data)? (4) Are there data access issues preventing Copilot from retrieving relevant information (check data governance configuration)? Most "Copilot doesn't work" complaints resolve with hands-on coaching on prompt engineering techniques. For persistent issues, deploy Copilot champions to provide peer support.