The Microsoft Copilot Prompt Library — 50 Working Prompts by Surface (2026)

Most teams that buy Microsoft Copilot don't get the value they paid for. The product works. The users don't know what to ask it.

This is the library that fixes that. Fifty prompts organized by where you use them, each with the exact text to paste and a note on where it falls down.

Copy any of these. Tweak the variables. Use them tomorrow.

How to use this library

Each prompt below has three parts:

1. The prompt — exact text you can paste into Copilot
2. What you'll get — the realistic output shape
3. Where it fails — the condition under which it stops working

The third part is the one most prompt libraries leave out, and it is the part that saves you the experiment. A prompt that works until a specific thing is true is more useful than a prompt presented as though it always works.

The prompts use {{PLACEHOLDERS}} for the parts you fill in. Replace those with your real data.

Find a prompt by the job you do

All fifty are also on a five-page cheat sheet you can print and keep next to the keyboard, failure notes included. Reference material that needs a browser tab, a search box and a scroll loses to doing the task badly, which is most of why a library like this goes unused.

The sections below are grouped by the app you are in, because that is where you are standing when you need one. If you would rather start from the work, these are the five that earn their place first in each role. Every prompt appears in full further down.

Finance and accounting: run a budget variance analysis, build a year-over-year comparison, build a scenario matrix, write an Excel formula from a description, turn a long document into a one-page brief

Legal and contracts: compare two versions of a document, answer a policy question with a citation, synthesize what several documents say, check whether you have decided this before, produce formal meeting minutes

HR and people: decline a request politely, rewrite technical writing in plain language, find who owns a process or system, build an intake agent, send a follow-up that is not pushy

Leadership and management: write an async update to a stakeholder, build an executive summary slide, prepare for questions after a deck, extract themes across several meetings, brief yourself from prior meetings

Data and analysis: find outliers in a column, build a cohort retention table, segment customers into tiers, build a pivot table from messy data, chart a trend with annotations

Vendor and supplier management: compare two versions of a document, find the latest version of a document, build a status agent, run a budget variance analysis, brief yourself before a meeting with someone

Project and operations: pull only your own action items from a meeting, recap a meeting with decisions and owners, build an agent that searches files, email and Teams, post an async update to a channel, triage an unread inbox

Outlook prompts (8)

Summarize a long email thread

Use case: Caught up on a 14-message thread without reading every reply.

Prompt:

Summarize this email thread. Include the original question, key decisions made, current open items, and who owns each open item. Keep it under 150 words.

What you'll get: A scannable summary with action items mapped to owners. Saves 10-15 min per long thread.

Where it fails: On threads with heavy forwarding it can attribute a decision to whoever quoted it last rather than whoever made it. Check owners against the original messages.

Draft a reply to an email

Prompt:

Draft a reply to this email. The point I want to make is {{YOUR_POINT}}. Tone: {{warm/direct/professional/apologetic}}. Length: under 100 words. End with a clear next step.

What you'll get: A draft you can edit in 30 seconds. Saves 5-15 min per email.

Where it fails: It writes to the last message, not the whole thread, so a reply to a long exchange can contradict something agreed earlier. Summarize first, then draft.

Decline a request politely

Prompt:

Draft a polite decline to this request. The reason is {{HONEST_REASON}}. Offer {{ALTERNATIVE_or_REFERRAL}} if applicable. Keep it under 60 words. Don't over-apologize.

What you'll get: A no that doesn't leave damage. The "don't over-apologize" instruction is essential — Copilot defaults to apologetic.

Where it fails: Drop the over-apologize instruction and it reverts to three sentences of hedging. The instruction is doing the work, not the model.

Propose meeting times from an email

Prompt:

Draft a reply proposing 3 meeting times next week based on my calendar availability. The meeting should be 30 minutes. Include a Teams link automatically.

What you'll get: Three time options pulled from your actual calendar. Cuts the back-and-forth.

Where it fails: It reads free/busy, not your intent, so it will happily offer a slot between two flights or during a block you keep clear on purpose.

Brief yourself before a meeting with someone

Prompt:

I have a meeting with {{NAME}} tomorrow. Pull from our email history and any related documents in SharePoint. Brief me on: what we last discussed, any open items, and any context I should remember.

What you'll get: Pre-meeting context you'd otherwise dig for. Materially better meetings.

Where it fails: It only sees what you have access to. Anything discussed in a channel you are not in, or a meeting you missed, is silently absent rather than flagged.

Triage an unread inbox

Prompt:

Look at my unread emails from today. Categorize them as: urgent (needs reply today), important (needs reply this week), informational (no action needed), or noise (can archive). Surface only the urgent ones.

What you'll get: A filtered list. Cuts triage time substantially.

Where it fails: Urgency is judged on language, so a calm message about a real deadline gets filed below a breathless one about nothing.

Send a follow-up that is not pushy

Prompt:

Draft a polite follow-up to {{NAME}}. The original email was {{N}} days ago about {{TOPIC}}. Keep it brief, friendly, no guilt. End with a low-stakes way to revive the thread.

What you'll get: A nudge that doesn't read as pushy.

Where it fails: It does not know why they went quiet. If the silence is the answer, a nudge makes it worse, and no prompt can tell you which case you are in.

Write an async update to a stakeholder

Prompt:

Draft an async update to {{STAKEHOLDER}} about {{PROJECT}}. Include: current status, what changed since last update, what's blocking, what I need from them. Tone: confident, direct. Under 200 words.

What you'll get: A clean update that makes you look on top of things.

Where it fails: It will describe a blocker without naming who has to clear it. Say who owns the unblock or you will get a status report nobody can act on.

Word prompts (8)

Turn notes into a first draft

Prompt:

Turn these notes into a {{TYPE: memo, brief, proposal, blog post, etc.}}. Audience: {{AUDIENCE}}. Length: {{N}} words. Tone: {{TONE}}.

Notes: {{PASTE_NOTES}}

What you'll get: A first draft you can edit instead of a blank page.

Where it fails: Thin notes produce confident filler rather than a short draft. If a section was two words in your notes, delete what it writes there instead of editing it.

Turn a voice memo into a document

Prompt:

This is a voice memo transcript. Turn it into a clean {{document type}} preserving my voice and key phrasings. Fix grammar and add structure but don't dilute the personality. Length: {{N}} words.

What you'll get: Your own voice, cleaned up and structured. Critical for personal-brand content.

Where it fails: Transcription errors become fluent sentences. A misheard name or number reads as correct prose, so check proper nouns and figures against the audio.

Cut a draft down without losing substance

Prompt:

Tighten this draft. Goal: cut 30% of the words without losing substance. Remove filler. Strengthen verbs. Don't add anything new.

What you'll get: A leaner draft. Especially useful for executive summaries and emails.

Where it fails: It hits the word target by dropping qualifiers, which is where the caveats live. Re-read anything conditional after a tighten pass.

Add structure to a wall of text

Prompt:

Add structure to this document. Insert clear section headers, break long paragraphs, and add a 3-bullet executive summary at the top. Don't change the meaning.

What you'll get: A scannable document. Your readers will thank you.

Where it fails: Headings it invents can assert a logic the text does not have, making a rambling argument look organized without becoming one.

Rewrite technical writing in plain language

Prompt:

Rewrite this technical document for a non-technical audience. The audience is {{AUDIENCE — e.g., board members, customers, non-engineering stakeholders}}. Remove jargon. Use analogies where appropriate. Don't simplify so much that it's wrong.

What you'll get: A version your stakeholders can actually act on.

Where it fails: Analogies are where it oversimplifies. An analogy that is nearly right is harder to correct later than jargon nobody understood.

Turn a long document into a one-page brief

Prompt:

Read this long document. Generate a 1-page brief for an executive who won't read the full thing. Include: the question this answers, the recommended action, the top 3 risks, and the financial implication.

What you'll get: Executive-ready brief. Saves your boss 30 minutes.

Where it fails: Asking for the financial implication will get you one whether the document contains it or not. Verify any number in the output appears in the source.

Match a draft to your own voice

Prompt:

Match the tone of this draft to these voice samples: {{PASTE_2-3_SAMPLES}}. The current draft is too {{formal/casual/stiff/etc.}}. Adjust without changing the substance.

What you'll get: A consistent voice across documents. Useful for teams with brand voice guidelines.

Where it fails: Two or three samples is not enough for a distinctive voice. It converges on a generic professional register and calls it your tone.

Compare two versions of a document

Prompt:

Compare these two versions of a document. Identify substantive changes (not just word edits). Surface anything where the meaning or position has actually shifted.

What you'll get: A real diff, not a syntactic one. Critical for contract review and policy work.

Where it fails: It is reliable on what changed and unreliable on whether the change matters. Treat the significance ranking as a starting list, not a verdict.

Excel prompts (10)

Run a budget variance analysis

Prompt:

Compare actual to budget across these columns. Flag any line item where actual exceeds budget by more than 15%. List the top 5 variances by dollar amount with a one-sentence likely cause based on the line item name.

What you'll get: The five variances that matter by dollar size, not the forty that matter by percentage, with a first guess at each cause.

Where it fails: The likely cause is inferred from the line-item name alone. It is a label, not an explanation, and it will sound equally confident when it is guessing.

Build a cohort retention table

Prompt:

Treat customer_id as the cohort identifier. Group customers by their first transaction month. For each cohort, calculate retention at month 1, 3, 6, and 12. Build a heatmap.

What you'll get: A month-by-month retention grid you can read diagonally, which is where a retention problem actually shows up.

Where it fails: It assumes every row is a real transaction. Refunds, test accounts and duplicates inflate early cohorts unless you filter them first.

Find outliers in a column

Prompt:

Find rows where the value in {{column X}} is more than 2.5 standard deviations from the mean. Group by {{category column}} and report which categories have the most outliers.

What you'll get: A ranked list of rows worth looking at, grouped so you can see whether the outliers cluster in one category.

Where it fails: Standard deviations assume a roughly normal distribution. On skewed data such as revenue per customer, the method flags the healthy tail.

Chart a trend with annotations

Prompt:

Build a line chart of monthly {{metric}} from this data. Add a 3-month rolling average overlay. Annotate the months where {{metric}} dropped more than 10% from the prior month.

What you'll get: A chart with the rolling average that shows the trend and the callouts that show the exceptions.

Where it fails: It annotates the drops it can see in the data and has no idea a month was short, a system was down, or a launch moved.

Segment customers into tiers

Prompt:

Segment these customers into 4 tiers based on total spend in the last 12 months: VIP (top 10%), Strong (next 20%), Casual (middle 40%), At-risk (bottom 30%). Add a tier column and color-code rows.

What you'll get: A tier column you can filter and sort on, which turns a flat customer list into something you can build a campaign against.

Where it fails: Percentile tiers move every time you re-run them, so last quarter's VIP list is not comparable to this quarter's unless you freeze the thresholds.

Write an Excel formula from a description

Prompt:

Write a formula that takes a date in column B, an amount in column C, and returns {{specific computation}}. Our fiscal year starts in April. Put the result in column D.

What you'll get: A working formula with the fiscal-year offset already handled, which is the part people get wrong by hand.

Where it fails: It produces a formula that runs, which is not the same as a formula that is right. Test it against rows where you already know the answer.

Build a scenario matrix

Prompt:

In this revenue model, assume customer count grows by X% and average revenue per customer grows by Y%. Show me the resulting ARR for X = 5, 10, 15% and Y = 0, 5, 10%. Build a 3x3 matrix.

What you'll get: A nine-cell grid you can put in front of a board without walking them through the model.

Where it fails: Growth rates are treated as independent. If your two variables actually move together, the corner cells of the matrix are fiction.

Clean up a messy column

Prompt:

In this column, normalize everything: trim whitespace, lowercase, standardize date formats to YYYY-MM-DD. Show me unique values after cleanup so I can verify.

What you'll get: Normalized values plus the unique list, so you can see what it did before you trust it.

Where it fails: Ambiguous dates are the trap. It will resolve a mix of day-first and month-first formats to something consistent and quietly wrong.

Build a pivot table from messy data

Prompt:

Build a pivot table from this data: rows = {{dimension}}, columns = {{time period}}, values = sum of {{metric}}. Add row totals. Sort rows by total descending.

What you'll get: A sorted pivot with totals, built without you having to fix the source data first.

Where it fails: Blank and near-duplicate category values become their own rows, so totals can look right while the breakdown is split across spellings.

Build a year-over-year comparison

Prompt:

Build a year-over-year comparison. For each row, calculate the YoY % change. Highlight increases over 20% in green and decreases over 20% in red. Add a summary row at the bottom.

What you'll get: A comparison with the changes already colored, so the exceptions are visible without reading every row.

Where it fails: A percentage change off a tiny base reads as a dramatic swing. Ask for the absolute change alongside it or the highlights mislead.

PowerPoint prompts (5)

Turn notes into a slide outline

Prompt:

Turn these notes into a slide outline for a {{N}}-minute presentation. Each slide should have a clear single message. Aim for {{N}} slides total. Tone: {{TONE}}.

Notes: {{PASTE}}

Note: Copilot's PowerPoint visual generation is weak. Use this for the outline. Rebuild visuals yourself or use a different tool.

What you'll get: A slide-by-slide outline with one message per slide, which is the hard part of deck-building.

Where it fails: Copilot's slide visuals are the weak part of the product. Take the outline and build the deck somewhere else.

Turn a document into a deck

Prompt:

Read this Word document. Generate a {{N}}-slide deck that covers the key points. Each slide: clear title, 3-5 supporting bullets max. Skip anything that's filler in the doc.

What you'll get: A deck skeleton that keeps the document's substance and drops its filler.

Where it fails: It preserves the document's structure, and a document's order is rarely a talk's order. Expect to resequence.

Write speaker notes for a deck

Prompt:

Generate speaker notes for each slide in this deck. The notes should explain what to say (not just what's on the slide). Conversational tone. Aim for 30-45 seconds of speaking per slide.

What you'll get: Notes that tell you what to say rather than restating the slide, timed to roughly the length of a real slide.

Where it fails: It writes notes for the slide rather than for the room, so the transitions between slides are the part you will still have to write.

Build an executive summary slide

Prompt:

Create an executive summary slide for this deck. Three bullets: situation, recommendation, ask. Each bullet under 12 words.

What you'll get: Three bullets tight enough to open a meeting with.

Where it fails: Under a hard word limit it drops the conditions on the recommendation, which is the half an executive most needs to see.

Prepare for questions after a deck

Prompt:

Read this deck. Generate the 8 hardest questions an executive might ask after seeing this. For each, draft a one-paragraph answer. Be specific.

What you'll get: Eight hard questions with drafted answers, which is usually enough to find the two holes in the deck itself.

Where it fails: It generates the questions the deck invites, not the ones a person with history on the topic will ask. It cannot see the politics.

Teams prompts (7)

Meeting output is the most searched thing Copilot does and the most commonly disappointing, because notes, minutes, a recap and an action list are four different documents and a summary returns the average of all four. Eight meeting prompts, one per format, covers that in full.

Recap a meeting with decisions and owners

Prompt (inside meeting Copilot panel):

Summarize this meeting. Decisions: list with owners. Action items: list with owners and deadlines. Open questions. Skip greetings and small talk.

What you'll get: A recap with decisions separated from discussion and every action attached to a name.

Where it fails: Anything decided before the recording started, or in the corridor afterwards, does not exist. A confident recap of a partial meeting is still partial.

Catch up on a Teams chat thread

Prompt:

Summarize this Teams chat from the last 48 hours. What was discussed? What was decided? What do I need to respond to?

What you'll get: Two days of a busy channel reduced to what was decided and what needs you.

Where it fails: Reactions and thread replies carry a lot of the agreement in Teams, and it weights the main messages far more heavily than either.

Post an async update to a channel

Prompt:

Draft a Teams channel post updating the team on {{TOPIC}}. Tone: matter-of-fact, not corporate. Length: under 150 words. Include a clear call-to-action if needed.

What you'll get: An update people read, because it is short and says what it needs from them.

Where it fails: Told to sound matter-of-fact it flattens genuinely urgent news into the same register as routine news.

Brief yourself from prior meetings

Prompt:

I have a Teams meeting with {{NAME}} tomorrow. Pull from our last 3 meetings together. What did we discuss? What's open? What did I commit to?

What you'll get: The thread of a relationship across three meetings, including what you committed to and may have forgotten.

Where it fails: It reports what was said, not what was meant. A commitment made to end a discussion reads identically to one somebody intends to keep.

Extract themes across several meetings

Prompt:

Look at all my meetings from the last 2 weeks tagged with {{TAG or PROJECT}}. Surface the themes that came up repeatedly across meetings.

What you'll get: The patterns that no single meeting made obvious, which is the case for reading across them at all.

Where it fails: Frequency is not importance. A recurring complaint nobody will act on outranks the thing said once that changed the project.

Produce formal meeting minutes

Prompt:

Produce formal minutes for this meeting. Structure: attendees, apologies, each agenda item with the discussion summarized in two sentences and the decision stated separately, resolutions with proposer and outcome, actions with owner and due date. Neutral third-person. Do not characterize anyone's tone.

What you'll get: A record that reads like minutes rather than a recap, with the decision separated from the discussion that produced it.

Where it fails: It cannot tell a decision from a strong suggestion nobody contradicted. Anything it lists as resolved needs confirming with the chair before the minutes circulate.

Pull only your own action items from a meeting

Prompt:

From this meeting, list only the items I personally committed to. For each: what I said I would do, the deadline if one was given, who is waiting on it, and the exact quote where I committed. Exclude anything assigned to someone else. If a commitment was vague, say so instead of tightening it.

What you'll get: A short list you can paste straight into a task manager, with the quote attached so you can check it.

Where it fails: Attribution in a transcript with several speakers drifts, so it can hand you somebody else's commitment. The quote is there to catch that, which is why the prompt asks for it.

SharePoint prompts (5)

Find the latest version of a document

Prompt (in Copilot Chat):

Find the most recent version of {{document type — policy, contract, brief}} about {{topic}} in our SharePoint. Confirm it's the latest version by checking the modified date.

What you'll get: The file plus the evidence it is current, rather than the file alone.

Where it fails: Modified date is not version. A formatting fix bumps the date, so the newest file can be an older draft somebody touched.

Synthesize what several documents say

Prompt:

Search our SharePoint for all documents about {{topic}}. Synthesize what they say into one summary. Flag any contradictions between documents.

What you'll get: One answer assembled from many documents, with the disagreements between them called out instead of averaged away.

Where it fails: It flags contradictions it can see between documents it retrieved. Anything it failed to retrieve does not register as a gap.

Answer a policy question with a citation

Prompt:

What's our policy on {{specific question}}? Cite the specific document and section. If we have multiple documents on the topic, identify which is canonical.

What you'll get: An answer you can forward, because it names the document it came from.

Where it fails: A citation proves the text exists, not that the document is current or that it is the one that governs. Check the effective date yourself.

Find who owns a process or system

Prompt:

Who in our company owns {{topic/process/system}}? Use SharePoint and Teams data to identify. List primary owner and key contributors.

What you'll get: A starting list of names, which is more than most internal wikis will give you.

Where it fails: It surfaces who talks about a thing, which in most organizations is not who is accountable for it.

Check whether you have decided this before

Prompt:

We're about to make a decision about {{topic}}. Have we made similar decisions before? Search SharePoint for prior decisions on similar topics and summarize what we learned.

What you'll get: Prior decisions on the same question, which is either a shortcut or a warning depending on what they say.

Where it fails: It finds prior decisions, not the reasoning that was never written down, which is usually why the decision is being revisited.

Copilot Studio agents (5)

Five starting points. Agents are a different discipline from prompts, because one runs without you and answers people who cannot tell a grounded answer from an invented one, so ten complete agent instruction sets covers the refusal path, the citation rule and the failure modes in full.

Build an FAQ agent

You are an assistant for {{TEAM/COMPANY}}. You answer questions about {{TOPIC AREA}} using only the connected knowledge sources. If you can't find the answer, say so honestly and offer to connect the user to a human. Tone: helpful, direct, not over-apologetic. Don't make up answers. Always cite the source document.

What you'll get: An agent that answers from your sources and says so when it cannot, rather than filling the gap.

Where it fails: The instruction not to invent answers reduces invention rather than removing it. Anything customer-facing needs a review step regardless of the wording.

Build an intake agent

You are an intake assistant for {{PROCESS}}. Your job is to capture structured information from users and create a record in {{DESTINATION — SharePoint list, Power Automate flow, etc.}}. Required fields: {{LIST}}. Ask only for what's required. If a user has additional context, capture it in a notes field but don't probe for more.

What you'll get: Structured records from unstructured requests, landing where the rest of your process expects them.

Where it fails: It captures what the user says, not whether it is true. Validation belongs in the destination system, not in the prompt.

Build a status agent

You are a status assistant for {{PROJECT/SYSTEM}}. Users ask you for current state. Pull data from {{SOURCES}}. Reply with: current status, recent changes, blockers, and next milestone. Always include data freshness ("last updated X ago").

What you'll get: A single place to ask "where is this" that answers with data rather than with somebody's recollection.

Where it fails: The freshness line reports when the agent last read the source, which is not when the source was last correct.

Build an agent that searches files, email and Teams

Prompt:

You are a retrieval assistant for {{TEAM}}. When asked for an item, search the connected SharePoint sites, the user's mail and the Teams channels you have access to, in that order. Return the three best matches with title, location, last modified date and a one-line reason each matched. If nothing matches, say what you searched and what you did not have access to. Never summarize a document you did not open.

What you'll get: Three candidates with provenance rather than one confident answer, and an explicit statement when the search came up empty.

Where it fails: It only searches what the signed-in user can already see, so two people asking the same question get different answers and neither is told why.

Build a technical scoping agent

Prompt:

You are a scoping assistant for {{SERVICE}}. Ask one question at a time to establish: the outcome the requester wants, the systems involved, who owns each system, the data that has to move, the constraints that are non-negotiable, and the deadline. Do not propose a solution. When you have all six, output a scoping summary under those headings and flag any answer that was vague.

What you'll get: A structured scope from someone who would otherwise send a two-line request, with the gaps marked rather than filled in.

Where it fails: Asked to flag vagueness it flags too much, and a requester who feels interrogated abandons the conversation. Cap it at six questions in practice.

Prompts that work anywhere (2)

Neither of these belongs to one app. Both change what Copilot returns in every surface above.

Make a draft sound less AI-generated

Prompt:

Rewrite this so it does not read as machine-written. Remove the tricolon lists, the "it's not X, it's Y" construction, and any sentence that opens with a participle. Vary the sentence length: at least one under six words. Cut every adverb that is not doing work. Do not add new claims. Keep my meaning exactly.

What you'll get: Prose that loses the cadence people now recognize on sight. The specific bans do the work, because a general instruction to sound human does not.

Where it fails: It removes the tells it was told about and leaves the ones it was not. The reliable fix is still to rewrite one sentence yourself, usually the first.

Make Copilot check its own work before it answers

Append this to any prompt whose output you would otherwise have to verify by hand.

Prompt:

Before you return your answer, check it against these: every figure appears in the source I gave you, every name is spelled as the source spells it, nothing contradicts anything else in the answer, and every instruction I gave has been followed. List anything that failed the check, then give the corrected answer.

What you'll get: A short audit ahead of the answer, which usually catches the one number that came from nowhere.

Where it fails: It is checking its own output with the same model that produced it, so a confident error passes its own review. This catches carelessness, not conviction.

What Copilot doesn't do well (saves you the experiment)

• Generate good-looking PowerPoint slides (output is dated)
• Browse the web meaningfully (Edge integration is shallow)
• Work with very large Excel datasets (>100k rows)
• Write code (use Cursor or Claude Code instead)
• Long-form creative writing (Claude or ChatGPT are better)
• Image generation (use DALL-E, Midjourney, or Flux)
• Real-time data from internal systems (Copilot Studio with connectors works but takes setup)

The five rules for getting more from Copilot

1. Be specific about output format. "Write a summary" is bad. "Write a 150-word summary with 3 bullets" is good.

1. Provide voice samples for tone-sensitive tasks. Paste 2-3 examples of your preferred voice. Tell Copilot to match.

1. Use negative instructions. "Don't use these phrases: {{LIST}}." Copilot defaults to corporate-helpful language. Negatives push it past defaults.

1. Cite sources for anything factual. Add "cite the source document" to any retrieval prompt. Forces Copilot to ground answers.

1. Start over instead of correcting. If a Copilot response is far off, don't iterate. Edit your original prompt and re-run. Iterating compounds drift.

What to do tomorrow

Pick the three prompts above that map to your most common workflows. Save them somewhere accessible (Notion, OneNote, even a Word doc).

Use each one twice this week. After two real uses, you'll know whether it fits.

By the end of a quarter, you'll have a personal prompt library of 15-20 that you use daily. That's where the real Copilot ROI lives — not in the marketing demos, but in the small habits that compound.

Start with three. Build from there.