Flow Alt Delete – Josh Cook [Microsoft MVP]

Tag: technology

  • I used AI as a full game studio

    I used AI as a full game studio

    How I Built a SEGA Genesis Tribute Game with Copilot Cowork and ChatGPT

    Vibe-coding a 1990 roguelike into existence — no IDE, no build step, just two AI tools and a weekend.

    1. How I Built a SEGA Genesis Tribute Game with Copilot Cowork and ChatGPT
      1. The Idea
      2. The Workflow
      3. Setting the Stage
      4. The Sprites: AI as Pixel Artist
      5. The Music: ChatGPT for Audio
      6. The Systems Cowork Built Without Me Typing Code
      7. The Bugs and How Cowork Fixed Them
        1. Equipped weapons disappear from my inventory.
        2. The bread icon looks like a goblin.
        3. Black screen after Load Game.
        4. My character faces left when I walk right.
      8. What It Felt Like
      9. The Final Result
      10. Download The Game

    The Idea

    I’ve been wanting to build a tribute to Fatal Labyrinth — that brutal little 1990 SEGA Genesis roguelike where you crawl 30 floors of a dungeon to retrieve the Holy Goblet from the Ancient Dragon. Hunger meter, perma-death, the works.

    Normally a project like this means setting up a repo, picking a framework, sourcing pixel art, hunting down royalty-free chiptune music.

    This time I tried something different: I used Copilot Cowork for the code and ChatGPT for the art and music.

    I didn’t open a code editor once.

    This is the story of how that went.

    The Workflow

    The loop was simple and absurdly fast:

    • I’d describe what I wanted in plain English to Copilot Cowork.
    • Cowork wrote the code directly into the HTML file.
    • When I needed art, I’d ask Cowork to write me a prompt for ChatGPT.
    • I’d paste the prompt into ChatGPT, get a sprite sheet back, drop it in the workspace.
    • Cowork wired the new sprite into the game.
    • I’d refresh the browser and play.

    That was it.

    No commits. No PRs. No waiting on builds.

    Cowork even handled the file I/O — it could see my uploads, modify the HTML, and post-process images when needed.

    Setting the Stage

    I started with a one-liner to Copilot Cowork:

    Build me a roguelike inspired by Fatal Labyrinth as a single HTML file.
    Canvas 2D, no framework.

    Cowork spun up the scaffolding: a 60×22 tile map, room-and-corridor procgen, field-of-view raycasting, turn-based monster AI, an inventory, a hunger meter, and level-up curves.

    All in one file.

    It even tracked which features it had done and what was next.

    Within the first session I had a playable prototype — ASCII tiles, but the systems were already there.

    The Sprites: AI as Pixel Artist

    ASCII is fine, but I wanted the SEGA feel. I wanted real characters and items, not ASCII.

    I asked Cowork which Sprites we should use for the game, it gave me a nice starting point.

    This is good but I want it to have actual sprites.
    I can generate and upload just tell me what you need

    Next I asked Copilot Cowork to write a ChatGPT image prompt for the tile sheet.

    Give me a prompt i can give to GPT images v2 to generate these.

    It came back with something like:

    Create a single sprite sheet for a 16-bit Sega Genesis-era dungeon crawler.
    Layout: 6 columns × 4 rows grid of equal-sized square cells, solid pure black (#000000) background,
    no borders or gridlines drawn between cells, no text, no labels, no captions, no numbers anywhere.
    Each cell contains exactly ONE centered sprite.
    Consistent pixel-art style across all 24 sprites:
    bold readable silhouettes, vibrant saturated colors, dark outlines, limited palette, top-down or slight 3/4 perspective, no drop shadows extending beyond the cell.
    Sprites in reading order (left to right, top to bottom):
    Row 1:
    (1) gray cobblestone dungeon floor tile,
    (2) gray stone dungeon wall block,
    (3) descending stone stairway viewed from above,
    (4) glowing golden Holy Goblet chalice with gems,
    (5) heroic human adventurer in chainmail wielding a sword, facing forward,
    (6) iron longsword
    Row 2:
    (1) iron chestplate armor,
    (2) red healing potion in glass bottle with cork,
    (3) rolled parchment scroll with red ribbon,
    (4) loaf of brown bread,
    (5) pile of gold coins,
    (6) brown sewer rat 
    Row 3:
    (1) brown bat with spread wings,
    (2) small green kobold with crude club,
    (3) green goblin with dagger and leather vest,
    (4) muscular gray orc with battle axe,
    (5) white skeleton warrior with rusty sword,
    (6) huge green troll with wooden club
    Row 4:
    (1) ghostly purple hooded wraith,
    (2) massive brown ogre with spiked club,
    (3) red horned demon with claws,
    (4) skeletal lich in dark robes holding glowing staff,
    (5) bull-headed minotaur with double-bladed axe,
    (6) black-armored death knight with greatsword and red eyes
    Style: clean pixel art, 16-bit Sega Genesis aesthetic, vibrant colors,
    strong outlines, pure black background only — absolutely no text,
    letters, words, or numbers in the image.

    ChatGPT generated it.

    I uploaded it, Cowork wrote a sprite-slicing helper, and suddenly the dungeon had monsters with personality.

    We did the same for:

    • A weapons sheet — 24 individual weapons across a 6×4 grid
    • A player walking sheet — 4 directions × 4 walk frames
    • Five weapon-baked character sheets — the player holding a sword, axe, mace, flail, and club
    • An effects sheet — slashes, fire bursts, smoke, sparks, heals, and teleports
    • The Ancient Dragon — 4×4 with idle, roar, fire-breath, and hurt rows

    Each one followed the same pattern:

    1. Write me a ChatGPT prompt for X.
    2. Get the prompt.
    3. Paste it into ChatGPT.
    4. Upload the result.
    5. Cowork wires it in.

    The dragon was the most fun.

    I asked Cowork where the existing boss sprite came from — it admitted it had just been scaling up the demon sprite 2× with a red glow.

    Lazy.

    So I had it write a prompt for a real dragon with animation rows. ChatGPT delivered a gorgeous result.

    Prompt it gave:

    A 16-bit SEGA Genesis-era pixel art sprite sheet of a massive
    ancient dragon boss, viewed from a top-down 3/4 perspective.
    Arrange it as a clean 4-row by 4-column grid on a fully transparent
    background, each cell exactly 256×256 pixels (total image 1024×1024).
    The dragon should be hulking, intimidating,
    drake-shaped with leathery wings folded back,
    jagged spines along the spine, glowing red-orange eyes,
    smoke curling from its nostrils, and dark crimson-purple scales
    with ember-glow undertones. Keep all four cells in a row the same pose
    seen from the same angle, with only animation frames differing.
    Row 1 (top) — IDLE BREATHING, facing camera (front view):
    4 frames of the dragon's chest rising and falling,
    wings shifting slightly, smoke puffing from nostrils.
    Row 2 — ROAR / ATTACK, facing camera: 4 frames of the dragon rearing
    back, jaws opening wide, claws raised. Frame 1 wind-up, frame 4 full roar with bared fangs.
    Row 3 — FIRE BREATH, facing camera: 4 frames of the dragon exhaling flam
    downward. Frame 1 inhale glow in throat, frames 2-4 streaming fire
    from open mouth.
    Row 4 (bottom) — HURT / FLINCH, facing camera: 4 frames of the
    dragon recoiling from a hit, body twisting, one wing flaring defensively,
    eyes wincing.
    Style requirements: chunky pixels, hard outlines, limited 16-bit palette
    (deep crimson, oxblood, ember orange, charcoal, gold highlights),
    strong contrast, no anti-aliasing, no gradients, no soft shadows,
    no blur. Same pixel-art rendering style as classic Sega Genesis
    dungeon crawlers like Fatal Labyrinth or Shining in the Darkness.
    Cells must be perfectly aligned to the 256-pixel grid with even spacing.
    Transparent (alpha) background — not white, not black.

    One problem: the export had baked a light-gray checkerboard into the background instead of using actual transparency.

    Cowork wrote a quick Python script with PIL to detect the near-grayscale light pixels and convert them to alpha-zero. 43% of pixels became transparent.

    The dragon now drops cleanly onto any palette.

    The Music: ChatGPT for Audio

    I asked ChatGPT to give me a prompt for Suno.ai which is what I would usually use for AI Music. But ChatGPT suggested it could create a beat that matches the game. So I said YES, and it generated a 30-second WAV.
    (NOTE: I had no idea this was possible!)

    I uploaded it, and Cowork:

    • Added an audio loop with preload enabled
    • Wired up a toggle button in the corner
    • Persisted the on/off preference in localStorage
    • Handled browser autoplay rejection silently

    The music only starts after the user clicks a difficulty button, which counts as legitimate user interaction for autoplay.

    The preference survives reloads.

    All from one request.

    The Systems Cowork Built Without Me Typing Code

    Here’s a non-exhaustive list of features I described in English and got working in minutes:

    • Procedural floor generation — rooms, corridors, stairs, monster and item spawning by depth
    • Turn-based combat with damage rolls
    • Hunger system — drains per turn, starvation at zero, regen when fed
    • Field-of-view raycasting with persistent “seen but not visible” tiles
    • Smooth tile-to-tile movement interpolation — 140ms ease-in-out, lunge on attack
    • Floating damage numbers and a hit-flash overlay
    • A visual effects system — slashes, blood, fire, smoke, sparkles, level-up rings
    • Six SEGA-style per-zone color palettes with tinting
    • Difficulty system — five orthogonal multipliers across four tiers
    • Save/load to localStorage — including the tricky bit about preserving equipped-item references via inventory indices
    • A 30-floor boss arena with teleport mechanics, ranged fire breath, and pillar cover
    • HP and hunger bars in the sidebar with low-state pulsing

    Every one of these came from a sentence or two.

    Cowork would also keep a running task list visible to me — I could see what was done, what was next, and what was in-progress without nagging.

    The Bugs and How Cowork Fixed Them

    I caught a few issues during playtesting. My 5 year old son also found some bugs.

    The cycle was always the same: I’d describe what was happening, Cowork would diagnose it, edit the file, and I’d refresh.

    Equipped weapons disappear from my inventory.

    It was splicing the weapon out of the array on equip. Cowork rewrote it to store a reference and mark the slot with [E].

    The bread icon looks like a goblin.

    A sprite atlas off-by-four-pixel bug. The HUD icons were using the wrong scaled cell size. Fixed in two lines.

    Black screen after Load Game.

    The game loop was being started inside the new game branch of the difficulty picker. Continue bypassed it. Cowork hoisted the animation frame call out of the callback.

    My character faces left when I walk right.

    The player sprite sheet had its rows in a different order than the code assumed. Two-line swap.

    Each fix took roughly one round trip.

    No stack traces. No console diving.

    Just:

    This is broken (See image)

    What It Felt Like

    The interesting thing wasn’t any one feature.

    It was the velocity.

    I was iterating on a game design in real time — not because the code was easy, but because I never had to write the code.

    I described intent. Cowork translated it. ChatGPT generated the assets.

    I stayed in the creative loop the whole time.

    A few things stood out:

    • Cowork preserved context across the entire session. It knew the project layout, the conventions, and the systems it had built. I didn’t have to re-explain anything.
    • The “write me a prompt for ChatGPT” pattern is gold. Cowork knew exactly what sprite-sheet layout it needed and could ask ChatGPT for it in the right format.
    • Post-processing AI output is a real workflow. The dragon checkerboard background and the music wiring would have been blockers without a tool that can actually run code on the assets.
    • A dev console added at the end paid for itself ten times over. Floor jump, item spawn, kill-all, reveal-map. I should have asked for it on day one.

    The Final Result

    One HTML file.

    About 1,500 lines.

    Six sprite sheets.

    One music file.

    No build step. No dependencies. No tooling.

    Drop it in a folder, open it in a browser, click Normal, and the labyrinth claims another soul.

    I didn’t write a single line of code.

    I designed a game.

    Built with Copilot Cowork and ChatGPT, over a few hours, with a healthy respect for 1990.

    Download The Game

    Want to try this game yourself? Here is the full Zip folder.
    Just extract it, and open the HTML file.

    Cowork-Game-fatal-labyrinth-V2.zip

  • Copilot Cowork to Prep for a Board Meeting Under Pressure

    Copilot Cowork to Prep for a Board Meeting Under Pressure

    How Executives Can Use Copilot Cowork When Board Prep Turns Into a Fire Drill

    A board meeting gets moved up by 48 hours.

    Now the executive needs the story fast.

    Finance has numbers. Operations has risks. Strategy has updates. AI transformation has progress, blockers, and governance questions. The deck is not ready. The briefing memo is not ready. The board will still expect clear answers.

    That is exactly the kind of pressure where Copilot Cowork starts to make sense.

    For this scenario, I used a fictional company called Kavora Industries. I stepped into the role of Chief Strategy Officer, and the ask was simple: prepare a board-ready package under pressure.

    The company is fictional. The work pattern is very real.

    Executive takeaway: Copilot Cowork is strongest when it helps leaders turn scattered business context into decision-ready artifacts.

    Insert screenshot here: Cowork prompt asking for the board meeting briefing package.

    The Real Executive Problem

    Board prep is not just about creating a PowerPoint deck.

    The harder part is knowing what matters.

    What changed since the last update? Where are the risks? Which numbers are final and which are preliminary? What decisions does the board need to make? What questions are they likely to ask?

    That is where executive prep gets expensive.

    The information already exists, but it is spread across too many places:

    • Executive emails
    • Strategy notes
    • Finance workbooks
    • Leadership updates
    • AI transformation reports
    • Draft presentation content
    • Q&A notes

    An executive does not need another place to search. They need the scattered pieces pulled into one clean operating picture.

    The Cowork Approach

    I gave Copilot Cowork a focused executive task:

    Prepare for a board meeting that was moved up by 48 hours using the provided source material, then create the artifacts needed to walk into the meeting prepared.

    The Prompt

    The prompt followed a simple structure:

    Role:
    Act as my executive strategy assistant for Kavora Industries.
    Goal:
    Help me prepare for a board meeting that was moved up by 48 hours.
    Sources:
    Use the provided executive emails, strategy notes, finance workbook,
    AI transformation report, and leadership updates.
    Task:
    Create a board-ready briefing package that includes:
    1. Executive summary
    2. Key risks and decisions
    3. AI transformation progress
    4. Financial and operational issues
    5. Likely board questions
    6. Recommended talking points
    Outputs:
    - Create a Word briefing memo
    - a PowerPoint board deck
    - a Q&A prep sheet
    Guardrails:
    - Keep the tone executive-ready, concise, factual, and decision-focused.
    - Do not invent facts outside the source material.
    - Use Kavora branding when creating files.

    This is the part executives should pay attention to.

    The prompt is not asking Cowork for a generic answer. It assigns a job. It points Cowork at the source material. It defines the output. It adds guardrails. It asks for files the business can actually use.

    The move: Do not ask for a summary when the real need is a briefing package. Ask for the work product.

    Insert screenshot here: Cowork task progress showing the memo, deck, and Q&A prep sheet being created.

    What Copilot Cowork Created

    Cowork created three core board prep artifacts and packaged them into a reviewable executive workflow.

    1. Board Briefing Memo

    The briefing memo became the anchor document.

    It pulled the scattered business context into a single executive narrative: current state, key numbers, strategic signals, risks, and decisions needed.

    This matters because executives need more than information. They need the story behind the information.

    The memo made the situation easier to review, challenge, and sharpen before the board meeting.

    2. Board Deck

    Cowork also created the board deck.

    The deck organized the material into a board-level flow: performance, division signals, risks, AI transformation progress, and decisions requested from the board.

    The important part was not just that slides were created. The important part was that the slides were structured around the meeting the executive actually needed to lead.

    One slide showed division performance and risk signals. Another brought the board back to the required decisions.

    That is exactly what an executive needs. Less noise. Clearer framing. Decisions visible.

    3. Board Q&A Prep Sheet

    This was the strongest artifact in the workflow.

    Cowork created a Q&A prep sheet with likely board questions, direct answers, anchor phrases, and source references.

    That is real executive value.

    The board is going to ask sharper questions than the internal team. Preparing for those questions before the meeting changes how the executive shows up.

    Instead of walking in with slides only, the executive walks in with prepared answers.

    4. Executive Review Email

    I prompted Cowork to also prepare and send an email with the board packet attached.

    Work does not end when the file is created. The package still needs to move to the right people with the right context.

    The email summarized what was included, called out the wording discipline applied, and highlighted the decision priority order.

    That is a complete workflow: source material to artifacts to communication.

    The executive shift: Cowork gets the leader to the decision point faster, with better context and real artifacts already in motion.

    That is the agent boss pattern in practice.

    The human stays accountable. The agent does the heavy lifting around gathering, synthesis, drafting, formatting, and first-pass artifact creation.

    That is how an executive should think about Copilot Cowork.

    The Executive Workflow

    This board prep scenario follows a workflow executives can reuse:

    1. Define the pressure moment.
    2. Point Cowork at the right source material.
    3. Ask for decision-ready artifacts.
    4. Review the output like an executive.
    5. Tighten the narrative.
    6. Send the right package to the right people.

    That workflow applies beyond board meetings.

    You could use the same pattern for quarterly business reviews, operating reviews, customer escalations, strategy offsites, town halls, finance reviews, and AI transformation steering committees.

    The structure stays the same. Pressure, sources, task, outputs, guardrails, review.

    What I Like About This Scenario

    This scenario works because it feels like real executive pressure.

    No gimmick. No fake magic. No perfect blank-page setup.

    Just a leader with scattered information, limited time, and a meeting that requires clear judgment.

    That is where AI at work becomes useful.

    Not when it sounds impressive in a chat window. When it produces the memo, the deck, the Q&A sheet, and the email that move the work forward.

    Best use case: Use Copilot Cowork to reduce the cost of preparation, then spend your human time on judgment.

    Final Thought

    Executives do not need AI that only sounds smart.

    They need AI that helps them get ready.

    That means finding the signal, organizing the story, creating the artifacts, and helping the leader walk into the room prepared.

    This is where Copilot Cowork gets practical.

    Board prep under pressure is not a productivity trick. It is a clear example of how executives can start working differently with AI agents inside the flow of work.

  • How I Keep Copilot Cowork Sessions Alive with a requirements.md File

    How I Keep Copilot Cowork Sessions Alive with a requirements.md File

    Copilot Cowork is strong at creating files. Documents, markdown files, HTML files, specs, plans, summaries, all of it.

    So I started using that strength against one of the biggest pain points in agent work: losing context.

    1. The Problem
    2. The Workaround
    3. The Prompt I Use
    4. What I Want Cowork To Track
    5. The Recovery Flow
      1. Step 1: Open the Output Folder
      2. Step 2: Copy the OneDrive Link
      3. Step 3: Start a New Cowork Session
    6. Why This Works
    7. My Recommendation
    8. Final Take

    The Problem

    Sometimes a session can glitch, freeze, or reach a point where starting fresh is easier.

    The painful part is not starting a new session.

    The painful part is rebuilding the context.

    You have to explain the goal again. Rebuild the requirements. Re-upload or reconnect files. Remind it what decisions were already made. Recreate the mental map of the work.

    That burns time.

    So I started giving Copilot Cowork a job before it does any other job:

    Keep the context alive.

    The Workaround

    At the start of the session, tell Cowork to create a requirements.md file and keep it updated while you work.

    That file becomes the session brain.

    It gives you a portable record of the work that can move from one Cowork session to another.

    Think of it like a handoff file.

    Not a final deliverable. Not a pretty summary. A working memory file.

    The Prompt I Use

    Create a requirements.md file and keep it updated throughout this session.
    Use it to track the full context of our work, including:
    - requirements
    - decisions made
    - open items
    - files created
    - key conversation details
    - risks
    - assumptions
    - and next steps
    I want to be able to pass this file to another Copilot Cowork session
    so it can continue with full context.

    You can change the file name if you want.

    For some sessions, I might use project-context.md, demo-notes.md, or handoff.md.

    But I like requirements.md because it forces the session to stay grounded in what is actually being built.

    Note

    This works best when the requirements.md file is updated throughout the session, not only at the end. When decisions change, files are created, or blockers appear, tell Cowork to update the file.

    What I Want Cowork To Track

    The file should not be a fluffy recap.

    I want it tracking the stuff that matters:

    • Session goal
    • Current objective
    • Requirements
    • Decisions made
    • Files created
    • Important assumptions
    • Open questions
    • Risks or blockers
    • Next actions
    • Anything another session would need to continue the work

    That last one is the key.

    Do not just ask Cowork to summarize.

    Ask it to prepare the next session to continue the work.

    The Recovery Flow

    If the session glitches, breaks, or you want to continue in a fresh session, here is the flow I use.

    Step 1: Open the Output Folder

    In Copilot Cowork, open the details pane and look for the Output folder.

    Click the folder icon to open the generated files in OneDrive.

    Once the folder opens in OneDrive, click Copy link.

    This gives you a link to the folder that contains the files from the previous Cowork session.

    Step 3: Start a New Cowork Session

    Open a new Copilot Cowork session.

    Paste the OneDrive folder link into the new session and tell Cowork:

    Im continuing the <Project or task name>.
    Use the files from our previous session. ( <Paste OneDrive Link> )
    Start by reading the requirements.md file.
    Then continue the work from there.

    Now Cowork has a fighting chance at picking up where the previous session left off.

    Why This Works

    Agent workflows are only as strong as the context behind them.

    If the context is trapped inside one chat session, you are exposed.

    If the context is written into a file, you can move it.

    That changes the way you work with Cowork.

    You are no longer relying only on the chat thread.

    You are creating a portable project trail that can survive a new session.

    My Recommendation

    Make this part of your normal Copilot Cowork workflow.

    Before you ask it to build the document, analyze the data, write the plan, or generate the assets, tell it to create the context file first.

    Then keep pushing Cowork to update that file as the session evolves.

    When a decision is made, tell it to update the file.

    When a requirement changes, tell it to update the file.

    When a file is created, tell it to update the file.

    Small habit.

    Big protection.

    Final Take

    Copilot Cowork can generate the work.

    But you should also make it generate the trail.

    The requirements file keeps the important context outside the chat window, inside the actual working folder, where another session can use it.

    That is the move.

    Use Cowork to build the output.

    Use Cowork to protect the context.

    This is currently a limitation on the product, which I assume the Team will fix in the future. But for now, this is how I manage long running tasks and work with Copilot Cowork.

  • Copilot Cowork Is Coming: Here’s How to Get Your Tenant Ready on Day 1

    Copilot Cowork Is Coming: Here’s How to Get Your Tenant Ready on Day 1

    Get Your Tenant Ready for Day 1: Joining Microsoft 365 Frontier for Copilot Cowork

    If you’ve been following the buzz around Copilot Cowork, you already know it’s going to change how we work inside Microsoft 365. But here’s the thing — Day 1 readiness doesn’t happen on Day 1. It happens now.

    In this post, I’ll walk you through exactly how to get your tenant set up: the right licenses, how to join the Frontier program, enabling the Anthropic sub-processor, configuring pilot groups, and locking down governance before you open the floodgates.

    Copilot Cowork is expected to be available for Frontier customers late March or later.

    Step 1: Make Sure You Have the Right Licenses

    Before you can enable anything, your tenant needs the right foundation.

    RequirementDetails
    Microsoft 365 Copilot licenseRequired for all end users who will access Copilot Cowork. Available as an add-on on E3, E5, Business Standard, and Business Premium plans.
    AI Administrator roleRequired to make changes in the Copilot settings area of the Admin Center.
    Microsoft Entra ID P1 or P2Needed for group-based access control and conditional access (P1 minimum).
    SharePoint OnlineIncluded in most M365 plans — required for Cowork’s document grounding.

    Admin tip: Before you go further, run a license audit. In the Microsoft 365 Admin Center, go to Billing > Licenses and confirm Copilot licenses are assigned — unassigned licenses won’t show up in Frontier eligibility checks.

    Step 2: Join Microsoft 365 Frontier

    Microsoft 365 Frontier is the early adopter program that gives your tenant access to upcoming Copilot features before general availability — including Copilot Cowork.

    What you’ll need first

    You must have AI Administrator access to complete this setup. If you don’t have this role, work with your Global Admin to get it assigned before you start.

    How to join Frontier

    1. Start from office.com and open the Admin Center.
    2. Navigate to Copilot → Settings → Frontier.
    3. On the Frontier settings page, enable early access.
    4. Under Web Apps, select the users who should be included.
    5. Click Save.

    That’s it — your tenant is now enrolled in Frontier.

    Step 3: Enable Anthropic as an AI Provider

    After Frontier is enabled, you need to turn on the AI providers that power the new Copilot experiences. This is the step most admins don’t realize is required.

    How to enable Anthropic

    1. From the same Copilot settings area, navigate to Data access.
    2. Enable the available AI providers — the recommendation is to enable as many as possible.
    3. Specifically, find Anthropic and enable it for Copilot.

    Step 4: Set Up Pilot Groups (Optional)

    Don’t roll Frontier out to your entire organization on Day 1. A phased pilot protects your environment and gives you time to validate the experience before broad deployment.

    Recommended pilot structure

    PhaseGroupPurpose
    Wave 1 — Champions5–10 power users (IT, Copilot champions)Validate setup, surface issues early
    Wave 2 — Early Adopters50–100 users across key departmentsReal-world workflow testing
    Wave 3 — Broad RolloutAll licensed usersFull deployment

    How to configure

    1. Create security groups in Microsoft Entra ID — for example, SG-CopilotCowork-Wave1 and SG-CopilotCowork-Wave2.
    2. In the Frontier settings from Step 2, assign early access to your Wave 1 group first using the Web Apps user selection.
    3. Expand to Wave 2 once Wave 1 has validated the experience.

    Pro tip: Set up a Microsoft Teams channel for your pilot group — something like #cowork-pilot-feedback — so you have a central place to collect issues and wins before you scale.

    Step 5: Governance — Lock Down Oversharing Before You Start

    This is the step most organizations skip — and regret. When Copilot can surface content from across your tenant, oversharing becomes a data exposure risk, not just a governance annoyance. Lock this down before you enable Cowork broadly.

    Key controls to review

    ControlWhere to set itRecommendation
    External sharingSharePoint Admin Center → Policies → SharingSet to “Existing guests only” or “Only people in your org” during Frontier rollout
    Default sharing linksSharePoint Admin Center → Policies → SharingChange from “Anyone with the link” to “People in your organization”
    Site-level permissionsIndividual site settingsAudit “Everyone except external users” — this is the #1 oversharing culprit
    Sensitivity labelsMicrosoft PurviewApply labels to classify and restrict access to confidential content
    Guest access expirationEntra ID → External collaboration settingsSet guest access to expire after 90 days

    SharePoint Admin Agent Prompt: Oversharing Audit

    Use this prompt directly with the SharePoint Admin agent in the Microsoft 365 Admin Center to get a fast, prioritized oversharing assessment:

    Review my SharePoint environment for oversharing risks before a Copilot rollout. Specifically:
1. Identify all sites that have 'Everyone' or 'Everyone except external users' granted any level of access.
 2. List sites where external sharing is enabled but shouldn't be (e.g., HR, Finance, Legal).
 3. Show me any files or folders shared via 'Anyone with the link' in the last 90 days.
 4. Flag any sites with more than 500 unique permissions (permission explosion).
 5. Recommend which sites should have sensitivity labels applied but currently don't.
Format results as a prioritized remediation list — highest risk first.

    This gives you an actionable list to work through before any end user asks Copilot Cowork a question about a document they shouldn’t be able to see.

    Your Day 1 Readiness Checklist

    • [ ] M365 Copilot licenses assigned to target users
    • [ ] AI Administrator role confirmed
    • [ ] Tenant enrolled in Frontier (Copilot → Settings → Frontier)
    • [ ] Early access enabled and Web Apps users selected
    • [ ] Anthropic enabled under Data access → AI providers
    • [ ] Pilot security groups created (Wave 1, 2, 3)
    • [ ] SharePoint oversharing audit completed using Admin agent prompt
    • [ ] External sharing policies tightened
    • [ ] Sensitivity labels deployed for confidential content
    • [ ] Pilot feedback channel set up in Teams

    Final Thought

    Copilot Cowork is a new way of working. The organizations that will get the most out of Day 1 are the ones doing this prep work right now. Join Frontier, enable Anthropic, run your oversharing audit, and start small with a tight pilot group.

    The foundation is simple: Frontier starts with admin enablement and provider access. Once that’s in place, you’re ready for everything that comes next.

  • Build Your Agent Factory: 10 Moves That Ship Fast (and Scale)

    Build Your Agent Factory: 10 Moves That Ship Fast (and Scale)

    Build Your Agent Factory: 10 Moves That Ship Fast (and Scale)

    Agents at scale. Not POCs.

    Here’s the playbook I’d hand any exec or builder who wants working agents in production—without turning the org into a science fair.

    1) Stand up an AI Agents Workforce

    What it is: A small cross-functional crew with authority to hunt repetitive work and ship agents.

    Who’s in:

    • 1 product owner
    • 1 engineer (Copilot Studio/Power Automate)
    • 1 data person
    • 1 security/governance lead
    • 1 domain SME.

    Ship this week: Write a one-page charter with scope, decision rights, and a 30-day roadmap (first 5 agents + metrics).

    2) Win with horizontals first, then go vertical

    Horizontals (1-hour wins): drafting, summarizing, policy Q&A, meeting notes to actions, form-fill helpers.

    Verticals (outsized ROI): pick 1–2 per business unit where there’s money, risk, or SLA pain.

    Guardrail: don’t start with the hardest workflow; start where you can close the loop and measure value inside two weeks.

    3) Make an Agents Directory the front door

    Why: Ideas die in email. A directory turns “we should build X” into spec and governance.

    Minimum intake fields:

    • use case name
    • goal
    • users
    • decision rights
    • data sources + who owns it
    • tools
    • PII/sensitivity
    • KPIs
    • business owner
    • risk level
    • rollout plan.

    Outcome: Every request auto-generates a lightweight PRD (goal, inputs, outputs, metrics, guardrails) and a yes/no gate.

    4) Create the 1-Hour Agent template

    Template anatomy:

    Goal + success criteria Input schema (what the user provides) Tools (actions/connectors) and permissions Knowledge sources (files, sites, indexes) Safety rules (allowed/blocked actions, escalation) Evaluation set (10–20 test prompts with expected outcomes) Deploy script (Dev → Test → Prod)

    Rule: If a use case can’t fit this page, it’s not a 1-hour agent—park it for later.

    5) Tie every agent to a visible scorecard

    Metrics to publish: time saved, cost avoided, error rate, CO₂/efficiency (where relevant), user satisfaction.

    Simple formula: monthly users × average minutes saved × loaded cost = value.

    Make it public internally: green/red status, owner, last review, next improvement.

    6) Run on a secure, managed agent runtime

    Non-negotiables: identity passthrough, content safety, audit logs, tool call restrictions, data boundary controls, environment isolation.

    Practical tip: standardize a “sensitive sources” policy and block tools by default; allow case-by-case.

    7) Split the stack to move fast without breaking things

    Experience layer: Copilot Studio for UX, channels, and connectors.

    Agent runtime/orchestration: managed agent service for threads, tool calls, safety, and evaluations.

    Why it works: builders ship quickly at the edge; platform team keeps shared guardrails, monitoring, and upgrades stable.

    8) Mix knowledge + action (or you’ll stall)

    Knowledge: structured grounding (SharePoint/Fabric/Search), doc versioning, citations-on by default.

    Action: flows/Logic Apps, Graph, line-of-business APIs; always ship with a dry-run mode first.

    Design pattern: Answer → show sources → propose actions → execute on approval. When confidence is high and stakes are low, allow auto-execute.

    9) Keep humans in the loop—by design

    HITL patterns that work:

    Shadow mode (observe only) → suggest mode → execute with approval → auto-execute.

    Confidence thresholds where low confidence routes to a human. Escalation logic when guardrails trip or data is missing.

    UX rule: one click to approve, one click to undo.

    10) Plan to scale on day one

    Pipelines: Dev → Test → Prod with approvals and rollback.

    Evals: pre-ship test set per agent; weekly drift checks; quarterly red-team.

    Ops: central logging, cost dashboards, incident playbook.

    Program ritual: a quarterly “Agent Backlog Day” to harvest new ideas and retire underperformers.

    Starter Architecture (fast and boring)

    Experience: Copilot Studio (web, Teams, M365, chat, plugins)

    Actions: Power Automate/Logic Apps + custom APIs

    Knowledge: SharePoint/Fabric/AI Search with retrieval policies

    Runtime: managed agent service for tool orchestration, identity, safety

    Observability: evaluations, telemetry, and a simple agent scorecard per app

    Security: Entra ID RBAC, private endpoints, DLP, approval gates

    Prompts and policies that save you pain

    Prompt contract (keep it in the repo): role, goals, inputs, allowed tools, forbidden actions, decision rights, escalation, output format, citation rules.

    Data contract: what sources are permitted, freshness expectations, sensitivity tags.

    Failure modes: what the agent must do when unsure (ask for clarification, route to human, or stop).

    Anti-patterns I keep seeing

    • Starting with an “AI strategy deck” instead of shipping 3 agents.
    • Agents that answer but can’t act—users stop coming back.
    • No owner, no scorecard, no sunset date.
    • Canary-testing in production without a rollback plan.
    • Letting one giant use case block 20 small wins.

    Your first week mapped

    Day 1: Form the team and publish the charter.

    Day 2: Launch the Agents Directory (intake + PRD autogeneration).

    Day 3–4: Build two 1-hour agents (drafting + policy Q&A) with eval sets.

    Day 5: Ship to a pilot group with scorecards visible. Book the first backlog day.

  • Maximize Efficiency with GPT-5 Router-Optimized Prompts

    Maximize Efficiency with GPT-5 Router-Optimized Prompts

    This prompt pack is around general use, if you would like a more focused pack focused on a specific industry or scenario, comment below.

    Below you will find the prompt pack in 3 formats

    Word doc download:

    gpt5_router_prompt_pack_v1.1Download

    Markdown download (word press wont let me upload markdown file so I have uploaded to my GitHub for download: FlowAltDelete/GPT-5-Router-Optimized-Universal-Prompt-Pack

    If you don’t want to download, I have also put the prompt pack below

    GPT‑5 Router‑Optimized Universal Prompt Pack (v1.1)

    What this is: A field‑tested, router‑aware prompt pack tuned for GPT‑5.
    How to use: Paste the Router Boost Header 2.0 above any task below, then use the upgraded prompt. Each item includes a fast audit (strengths, gaps, tuning) so you know why it works.

    Router Boost Header 2.0 (paste above any prompt)

    Task: [one sentence describing “done”].
    Context/Grounding: [paste facts/links/notes]. Cite sources if summarizing; don’t invent.
    Constraints: audience=[…], tone=[…], length=[…], locality=[region/laws], non‑negotiables=[…].
    Output Contract: [exact format/schema; if JSON, include a schema].
    Tool Grants: You may use internal reasoning, code execution, and structured output. Do not expose chain‑of‑thought; return only the final results.
    Mode: Choose fast for simple tasks, deep for complex ones; state the choice on one line before the output.
    Self‑Check: Validate constraints, factuality (vs. sources), and format before returning. If JSON, ensure it parses.
    Failure Policy: If blocked or context is thin, list missing info and ask 3 sharp questions; otherwise proceed with explicit assumptions labeled “Assumptions.”

    Tip: Keep the header short in production—only include fields that matter. If you need determinism, ask for “low‑randomness; no lateral riffs.”

    Universal GPT‑5 Prompt Pack v1.1**

    Below: for each prompt

    • Use when: best fit.
    • Strengths: what’s good already.
    • Gaps: what to tighten for GPT‑5.
    • Router tuning: small switches that improve results.
    • Upgraded prompt: copy/paste ready.
    • (Optional) Strict JSON variant: when you need machine‑readable output.

    1) Executive Summary (Any Topic)

    Use when: You need crisp, executive‑level clarity in 30–90 seconds.
    Strengths: Forces prioritization; covers timing and action.
    Gaps: Can drift into fluff; doesn’t enforce one‑line bullets; missing “evidence”.
    Router tuning: Demand one‑line bullets with bold labels; add “evidence” blip; enforce count.

    Upgraded prompt

    Create exactly **5 one‑line bullets** summarizing [topic/brief].
Each bullet starts with a bold label: **What matters**, **Why now**, **Risks**, **Decision**, **Next actions**.
Add ≤12 words per bullet. Include 1 source or metric if available.
Mode: [fast/deep]. Return as a simple bullet list—no preamble.

    Strict JSON variant

    Return valid JSON:
{ "what_matters": "...", "why_now": "...", "risks": "...", "decision": "...", "next_actions": "..." }

    2) Research Plan (Adversarial)

    Use when: You must test a claim/feature beyond happy‑path.
    Strengths: Calls for metrics, data, adversarial tests.
    Gaps: No threat model; no instrument plan; no stop/continue math.
    Router tuning: Introduce threat model + falsification criteria; add power checks.

    Upgraded prompt

    Design an **adversarial research plan** to evaluate [claim/feature]. Include:
1) Objectives & hypotheses (null + alt); 2) Success metrics & thresholds; 3) Threat model (abuse, edge cases);
4) Data to collect (fields, sample size/power);
5) Protocols (A/B, holdout, offline evals);
6) Adversarial tests & red‑team scripts;
7) Stop/continue rule with math;
8) Reporting template (tables/plots).
Mode: [fast/deep]. Output as a numbered outline.

    3) Decision Memo

    Use when: A one‑pager to choose among options.
    Strengths: Options, costs, risks, reversibility, rec.
    Gaps: No owner/date format; no “evidence” box; weak contingency.
    Router tuning: Add RACI owner/date; add 30/60/90 follow‑ups.

    Upgraded prompt

    Write a one‑page decision memo for [choice]. Include:
- Context (1 para) with constraints & evidence;
- Options (3): summary, costs (one‑time/run), risks, reversibility;
- Recommendation: **one** choice with rationale;
- Owner + Decision date; 30/60/90‑day checkpoints;
- Contingency triggers & rollback plan.
Mode: [fast/deep]. Keep ≤400 words.

    4) Project Plan One‑Pager

    Use when: Turn messy notes into plan.
    Strengths: Scope, milestones, owners, risks, comms, RAID.
    Gaps: No critical path; RAID often hand‑wavy.
    Router tuning: Add dates & simple Gantt list; RAID as compact table.

    Upgraded prompt

    From these notes: [paste], produce a one‑page plan with:
1) Scope (in/out);
2) Milestones (name, owner, date) in order;
3) Critical path (1‑3 bullets);
4) Comms cadence (who, channel, freq);
5) RAID summary table (Risk/Assumption/Issue/Dependency → owner, impact, mitigation);
6) Acceptance criteria (bullet list).
Mode: [fast/deep]. Keep it skimmable.

    5) Meeting → Decisions

    Use when: Converting raw notes to what matters.
    Strengths: Decisions & actions separation.
    Gaps: No owners on decisions; action status taxonomy missing.
    Router tuning: Add decision owner + rationale; status enum.

    Upgraded prompt

    Convert these notes: [paste] into:
A) **Decisions** list (decision, owner, rationale, date);
B) **Actions** table {owner, step, due, status ∈ [New, In‑Progress, Blocked, Done]}.
Mode: [fast/deep]. No commentary, just the two sections.

    Strict JSON variant

    { "decisions": [ { "decision": "", "owner": "", "rationale": "", "date": "" } ],
  "actions": [ { "owner": "", "step": "", "due": "", "status": "New|In-Progress|Blocked|Done" } ] }

    6) Cold Email Trio

    Use when: 3‑touch outbound sequence.
    Strengths: Problem → proof → ask. Short.
    Gaps: ICP nuance; weak personalization; missing CTA micro‑asks.
    Router tuning: Insert first‑line personal hook; vary asks.

    Upgraded prompt

    Write **3 cold emails** for [offer] to [ICP].
Email 1: name the **patterned pain**; end with a 10‑min micro‑ask.
Email 2: social proof/insight (number/metric), 1 sentence case study.
Email 3: crisp ask with 2 time options.
Each ≤120 words, 5‑7 sentences, no fluff. Include a {First‑line personalization} placeholder.
Mode: [fast/deep].

    7) LinkedIn Authority Post

    Use when: Thought leadership for execs + builders.
    Strengths: Structure, framework, prompt.
    Gaps: Risk of buzzwords; no proof.
    Router tuning: Require 1 mini‑case and 1 number.

    Upgraded prompt

    Write a LinkedIn post on [topic] for execs + builders:
- 3 punchy paragraphs (≤60 words each);
- 1 mini‑framework (3 bullets, named);
- 1 thought prompt (1 line);
- Include one concrete number or example; avoid buzzwords.
Mode: [fast/deep]. No hashtags unless asked.

    8) X Post (Bold, No Hashtags)

    Use when: High‑signal micro‑take.
    Strengths: Tight character limit, bold stance.
    Gaps: Might overrun chars; no proof token.
    Router tuning: Enforce count; include 1 fact word/number.

    Upgraded prompt

    Write one confident X post on [insight/news]. ≤240 chars.
Format: HOOK — TAKEAWAY. Include **one** concrete fact or number.
No hashtags. No emoji at the end. Mode: [fast/deep].

    9) YouTube Kit

    Use when: Fast ideation + structure.
    Strengths: Titles, open, chapters.
    Gaps: Title length drift; missing viewer promise.
    Router tuning: Enforce title count/length; add “who it’s for.”

    Upgraded prompt

    For a video on [topic], produce:
- **10 titles** (<60 chars);
- A two‑sentence cold open that states who it’s for and the promise;
- Chapter list with timestamps (estimate) and outcomes per chapter.
Mode: [fast/deep]. No clickbait lies.

    10) Content Angle Generator

    Use when: Topic expansion without repetition.
    Strengths: Rich buckets.
    Gaps: Duplicates; vague angles.
    Router tuning: Enforce uniqueness + sample headline.

    Upgraded prompt

    List **25 distinct content angles** for [niche/product] across:
how‑to, contrarian, teardown, story, data, tutorial, tool, myth vs fact.
For each: 1‑line angle + a sample headline. No repeats. Mode: [fast/deep].

    11) Product Spec from Idea

    Use when: Move from idea to v1.
    Strengths: Users, JTBD, metrics, scope.
    Gaps: Test plan vague; acceptance criteria missing.
    Router tuning: Add measurable acceptance + de‑scoping rules.

    Upgraded prompt

    Turn this idea into a lean product spec:
- Users & JTBD; key use cases;
- Success metrics (leading/lagging) with targets;
- V1 scope (must/should/could) and out‑of‑scope;
- Acceptance criteria (measurable);
- Test plan (happy path, edge, abuse).
Mode: [fast/deep]. ≤500 words.

    12) UX Critique

    Use when: Actionable UI improvements.
    Strengths: Issues + fixes.
    Gaps: Evidence often light; microcopy not tested.
    Router tuning: Severity scale + before/after microcopy.

    Upgraded prompt

    Critique the UX of [flow/screen]. Deliver:
- 10 issues with severity ∈ {P0, P1, P2}, evidence, and concrete fix;
- A before→after microcopy table (3–5 rows);
- One quick win and one deeper redesign note.
Mode: [fast/deep].

    13) CSV Data Brief

    Use when: Shape an analysis plan before coding.
    Strengths: Questions → steps → visuals.
    Gaps: Schema ambiguity; data checks missing.
    Router tuning: Add sanity checks + exact chart types.

    Upgraded prompt

    Given CSV schema: [columns], produce:
1) 5 decision‑driven questions;
2) Validation checks (types, nulls, outliers);
3) Analysis steps;
4) Exact visuals/tables to produce (chart type, axes, groupings).
Mode: [fast/deep]. No code unless asked.

    14) Code from Spec

    Use when: From spec to runnable core.
    Strengths: Architecture, snippets, tests, edges.
    Gaps: Env assumptions; complexity unbounded.
    Router tuning: Pin language/runtime; include complexity notes.

    Upgraded prompt

    Given this spec: [paste], provide:
- Architecture diagram (text) and key components;
- Core code snippets in [language/runtime] with minimal deps;
- Tests (unit/integration) and fixtures;
- Failure/edge cases + graceful handling;
- Complexity & trade‑offs section.
Mode: [fast/deep]. Keep idiomatic.

    15) Code Review + Refactor

    Use when: Improve safety & clarity with a plan.
    Strengths: Smells, hotspots, steps, tests.
    Gaps: Lacks risk scoring; migration path unclear.
    Router tuning: Add impact x effort; phased plan.

    Upgraded prompt

    Review this code: [paste]. Deliver:
- Findings by category (correctness, security, perf, clarity);
- Hotspots with complexity signals;
- Refactor plan in small, safe steps with tests;
- Risk/Impact vs Effort matrix (P0/P1/P2);
- Before/after snippet for 1 key function.
Mode: [fast/deep].

    16) Strict JSON Every Time

    Use when: Machine‑readable output required.
    Strengths: Clear schema.
    Gaps: No parser check; no enum constraints.
    Router tuning: Include enums & validation note.

    Upgraded prompt

    Return **only valid JSON** for [task]. Schema:
{
  "title": "string",
  "summary": "string",
  "risks": ["string"],
  "actions": [ { "owner": "string", "step": "string", "eta": "YYYY-MM-DD" } ],
  "metrics": ["string"]
}
No prose. Validate keys, types, and date format before returning.

    17) SOP / Checklist

    Use when: Repeatable, low‑variance execution.
    Strengths: Steps + gates + recovery.
    Gaps: Timing windows; roles not explicit.
    Router tuning: Add roles & time boxes.

    Upgraded prompt

    Draft a step‑by‑step SOP for [process]. Include:
- Prereqs & roles;
- Steps with time boxes;
- Quality gates with pass/fail checks;
- Common failure recovery & escalation ladder.
Mode: [fast/deep]. Output as a checklist.

    18) Positioning & ICP

    Use when: Sharpen message‑market fit.
    Strengths: ICP, pains, alts, value prop, messages, pitch.
    Gaps: Jobs vs pains; proof tokens missing.
    Router tuning: Add JTBD & proof lines.

    Upgraded prompt

    Define positioning for [product]. Provide:
- ICP traits (firmographic + behavioral);
- JTBD and top pains (ranked);
- Alternatives (do‑nothing included);
- Value proposition (benefit + proof);
- 3 key messages;
- 3‑line elevator pitch.
Mode: [fast/deep].

    19) Competitive Teardown

    Use when: Side‑by‑side clarity.
    Strengths: Features, UX, pricing, moat, switching costs, objections.
    Gaps: Buyer role nuance; evidence weak.
    Router tuning: Add role lens + cite artifacts.

    Upgraded prompt

    Compare [your product] vs [competitor] for [buyer role]. Cover:
- Features & UX (table);
- Pricing (typical deal sizes/TCO);
- Moat & switching costs;
- Buyer objections + crisp replies;
- Evidence links (docs, screenshots) if available.
Mode: [fast/deep].

    20) Policy First Draft (Non‑Legal)

    Use when: First pass policy with clarity.
    Strengths: Rules, examples, do/don’t, escalation.
    Gaps: No scope/authority; review cadence missing.
    Router tuning: Add scope, owner, review cadence.

    Upgraded prompt

    Draft a **non‑legal** first‑pass policy for [topic]. Include:
- Scope & definitions; policy owner;
- Rules with examples; do/don’t lists;
- Compliance checks & escalation path;
- Exceptions process;
- Review cadence and change log placeholder;
- Legal review placeholder.
Mode: [fast/deep].

    21) 7‑Day Learning Plan

    Use when: Focused upskilling in a week.
    Strengths: Daily objectives, resources, practice, quiz.
    Gaps: Entry level varies; no capstone.
    Router tuning: Add diagnostic + capstone.

    Upgraded prompt

    Build a 7‑day learning plan for [skill/exam]. Include:
- Day 0 diagnostic (what to skip/focus);
- Daily objectives, resources (≤3/day), and practice tasks;
- Daily self‑quiz (5 Qs) with expected answers;
- Day 7 capstone task with rubric.
Mode: [fast/deep].

    22) Negotiation Prep

    Use when: Plan the conversation before the room.
    Strengths: Goals, walk‑away, BATNA, concessions, questions, opening.
    Gaps: Counter‑plays; objection map missing.
    Router tuning: Add opponent map + scripts.

    Upgraded prompt

    Create a negotiation brief for [deal]. Include:
- Goals; walk‑away; BATNA;
- Concession strategy (give/get);
- Questions to surface interests;
- Opening script;
- Objection map with counters;
- Opponent/alignment map (roles, power, interests).
Mode: [fast/deep].

    23) Landing Page Copy

    Use when: Write conversion‑first copy.
    Strengths: Section list, direct tone.
    Gaps: Segment nuance; FAQ weak.
    Router tuning: Add segment option + proof elements.

    Upgraded prompt

    Write a landing page for [offer]. Sections:
- Headline + subhead (clear promise);
- Value bullets (3–6) with outcomes;
- Proof (logos, testimonial lines, metrics);
- CTA (primary + secondary);
- FAQ (5–7 Qs).
Optional: provide a variant for [segment].
Mode: [fast/deep].

    24) Automation Blueprint

    Use when: Design automations with ROI.
    Strengths: Triggers, steps, data, errors, alerts, ROI.
    Gaps: SLAs; run‑costs; auditability.
    Router tuning: Add SLAs, idempotency, and cost model.

    Upgraded prompt

    Propose automations for [workflow]. Include:
- Triggers & prerequisites;
- Steps with systems & data sources;
- Error handling (retries, dead‑letter, idempotency);
- Alerts/observability (what, who, channel, thresholds);
- SLAs & run‑cost model;
- ROI estimate (baseline vs future, payback).
Mode: [fast/deep].

    Bonus: Mini Switches You Can Add Anywhere

    • “Low‑randomness, no lateral riffs.” For deterministic outputs.
    • “Use a verification pass: compare output vs. constraints, fix before returning.”
    • “If citing, append a short sources list with titles + links.”
    • “Label assumptions explicitly if context is thin.”
    • “Return a ‘How to use this output’ note in one line.”

    Final Notes

    • Keep the Router Header lean; the power comes from clear Output Contracts and tight constraints.
    • Prefer JSON when downstream automation is needed; prefer skimmable bullets when humans are the primary consumer.
    • If you need extra toughness, combine “adversarial” and “self‑check” lines.

    Changelog v1.1 (this doc): Added threat models, self‑check, enum statuses, strict JSON variants, SLAs/costs for automation, and decision‑date/owner fields for memos.

  • Add the Microsoft Learn Docs MCP Server in Copilot Studio

    Add the Microsoft Learn Docs MCP Server in Copilot Studio

    UPDATE—August 8, 2025: You no longer need to create a custom connector for the Microsoft Learn Docs MCP server. Copilot Studio now includes a native Microsoft Learn Docs MCP Server under Add tool → Model Context Protocol.
    This guide has been updated to show the first-party path. If your tenant doesn’t yet show the native tile, use the Legacy approach at the bottom.

    What changed

    • No YAML or custom connector required
    • Fewer steps, faster setup

    Model Context Protocol (MCP) is the universal “USB-C” port for AI agents. It standardizes how a model discovers tools, streams data, and fires off actions—no bespoke SDKs, no brittle scraping. Add an MCP server and your agent instantly inherits whatever resources, tools, and prompts that server exposes, auto-updating as the backend evolves.

    1. Why you should care
    2. What the Microsoft Learn Docs MCP Server delivers
    3. Prerequisites
    4. Step 1 – Add the native Microsoft Learn Docs MCP Server
    5. Step 2 – Validate
    6. Legacy approach (if the native tile isn’t available)

    Why you should care

    • Zero-integration overhead – connect in a click inside Copilot Studio or VS Code; the protocol handles tool discovery and auth.
    • Future-proof – the spec just hit GA and already ships in Microsoft, GitHub, and open-source stacks.
    • Hallucination killer – answers are grounded in authoritative servers rather than fuzzy internet guesses.

    What the Microsoft Learn Docs MCP Server delivers

    • Tools: microsoft_docs_search – fire a plain-English query and stream back markdown-ready excerpts, links, and code snippets from official docs.
    • Always current – pulls live content from Learn, so your agent cites the newest releases and preview APIs automatically.
    • First-party & fast — add it in seconds from the Model Context Protocol gallery; no OpenAPI import needed.

    Bottom line: MCP turns documentation (or any backend) into a first-class superpower for your agents—and the Learn Docs server is the showcase. Connect once, answer everything.

    Prerequisites

    • Copilot Studio environment with Generative Orchestration (might need early features on)
    • Environment-maker rights
    • Outbound HTTPS to learn.microsoft.com/api/mcp

    Step 1 – Add the native Microsoft Learn Docs MCP Server

    1. Go to Copilot Studio: https://copilotstudio.microsoft.com/
    2. Go to Tools → Add tool.
    3. Select the Model Context Protocol pill.
    4. Click Microsoft Learn Docs MCP Server.
    5. Choose the connection (usually automatic) and click Add to agent.
    6. Confirm the connection status is Connected.
    Copilot Studio Add tool panel showing Model Context Protocol category and Microsoft Learn Docs MCP Server tile highlighted.
    1. The MCP server should now show up in Tools.
    1. Click the Server to verify the tool(s) and to make sure:
      – ✅ Allow agent to decide dynamically when to use this tool
      – Ask the end user before running = No
      – Credentials to use = End user credentials

    Step 2 – Validate

    1. In the Test your agent pane. Turn on Activity map by clicking the wavy map icon:

    2. Now try a prompt like:
      – What MS certs should I look at for Power Platform?
      – How can I extend the Power Platform CoE Starter Kit?
      – What modern controls in Power Apps are GA and which are still in preview? Format as a table

    Use-Case Ideas

    • Internal help-desk bot that cites docs.
    • Learning-path recommender (your pipeline example).
    • Governance bot that checks best-practice-links.

    Troubleshooting Cheat-Sheet

    • Note that currently the Learn Docs MCP server does NOT require authentication. This will most likely change in the future.
    • If Model Context Protocol is not shown in your Tools for Copilot Studio. You may need to create an environment with Early Features turned on.
    • Do NOT reference the MCP server in the agents instructions, you will get a tool error.
    • Check Activity tab for monitoring

    Legacy approach (if the native tile isn’t available)

    Grab the Minimal YAML

    1. Open your favorite code editor or notepad. Copy and paste this YAML to a new file.
    swagger: '2.0'
info:
  title: Microsoft Docs MCP
  description: Streams Microsoft official documentation to AI agents via Model Context Protocol
  version: 1.0.0
host: learn.microsoft.com
basePath: /api
schemes:
  - https
paths:
  /mcp:
    post:
      summary: Invoke Microsoft Docs MCP server
      x-ms-agentic-protocol: mcp-streamable-1.0
      operationId: InvokeDocsMcp
      consumes:
        - application/json
      produces:
        - application/json
      responses:
        '200':
          description: Success
    1. Save the file with .yaml extension.

    Import a Custom Connector

    Next we need to create a custom connector for the MCP server to connect to. We will do this by importing our yaml file we created in Step 1.

    1. Go to make.powerapps.com > Custom connectors > + New custom connector > Import OpenAPI.

    2. Upload your yaml file eg: ms-docs‑mcp.yaml, using the Import an OpenAPI file option.

    3. General tab: Confirm Host and Base URL.
      Host: learn.microsoft.com
      Base URL: /api
    4. Security tab > No authentication (the Docs MCP server is anonymously readable today).
    5. Definition tab > verify one action named InvokeDocsMcp is present.
      Also add a description.

    6. Click Create connector. Once the connector is created, click the Test tab, and click +New Connection.

      (Note, you may see more than 1 Operation after creating the connector. Don’t worry and continue on)
    7. When you create a connection, you will be navigated away from your custom connector. Verify your Connection is in Connected Status.

      Next we will wire this up to our Agent in Copilot Studio.