Flow Alt Delete – Josh Cook [Microsoft MVP]

Category: Copilot

  • Copilot Cowork Dataverse Plugin Setup

    Copilot Cowork Dataverse Plugin Setup

    I finally got Dataverse MCP working inside Copilot Cowork as a custom plugin.

    This guide walks through the setup in a way I wish I had when I started.

    The goal is simple:

    • Register an app in Entra
    • Enable Dataverse MCP for your Power Platform environment
    • Create the OAuth registration in Teams Developer Portal
    • Build a Copilot Cowork plugin that points to your Dataverse MCP endpoint
    • Deploy it
    • Give Cowork enough schema context to understand your Dataverse tables

    If you are a low-code builder, the confusing part is not Dataverse.

    The confusing part is the setup across multiple portals.

    You will touch Entra, Power Platform admin center, Teams Developer Portal, the plugin manifest, and Copilot Cowork.

    That sounds worse than it is. You just need to know which value goes where.

    I have a video going over the same steps as the blog:

    1. What we are building
    2. Before you start
    3. The setup order
    4. Step 1: Create the App Registration
      1. Add the Dataverse MCP permission
      2. Add the redirect URI
    5. Step 2: Configure the Power Platform environment
      1. Add the allowed MCP client
      2. Capture the Dataverse URL
    6. Step 3: Create the OAuth registration in Teams Developer Portal
      1. Base URL
      2. Authorization endpoint
      3. Token endpoint
      4. Scope
      5. Client ID and secret
    7. Step 4: Build the plugin
      1. Import Plugin Builder skill
      2. Build Dataverse Plugin with Template
    8. Step 5: Deploy the plugin
      1. Connect Plugin
    9. Step 6: Create a schema-aware skill
    10. Step 7: Test with a real scenario
    11. Example prompts:
      1. List records
      2. Add records
      3. Details on a record
      4. Build Dashboard
      5. Create report
      6. Send Email with context
      7. Create PPT with context + Brand
    12. Common mistakes
      1. Mistake 1: Mixing up the IDs
      2. Mistake 2: Wrong MCP URL
      3. Mistake 3: Wrong OAuth scope
      4. Mistake 4: Testing with a user that cannot access the data
      5. Mistake 5: Re-uploading the same version
    13. Download the checklist
    14. Official docs
    15. Final take

    What we are building

    We are building a Copilot Cowork plugin that connects to the Dataverse MCP endpoint.

    Once installed, Cowork can use that plugin to query Dataverse through MCP.

    The basic flow looks like this:

    1. User asks Copilot Cowork a question
    2. Cowork uses the custom plugin
    3. The plugin points to the Dataverse MCP endpoint
    4. Dataverse returns the data
    5. Cowork uses schema guidance to make sense of the tables
    6. Cowork returns a useful answer, summary, dashboard, or audit notes

    I recommend keeping this setup in two parts:

    • The plugin: gives Cowork access to the Dataverse MCP connector
    • The schema skill: tells Cowork which Dataverse tables, columns, relationships, and rules matter

    That split makes the setup easier to maintain.

    If your schema changes, you can update the schema skill without rebuilding and redeploying the entire plugin package.

    Before you start

    You will need:

    I created a checklist for this because the setup has a few values that are easy to mix up.

    The setup order

    This is the order I recommend:

    1. Create the App Registration
    2. Configure the Power Platform environment
    3. Create the OAuth registration in Developer Portal
    4. Build the plugin
    5. Deploy the plugin
    6. Create the schema skill
    7. Test everything in Copilot Cowork

    Do not start with the plugin manifest.

    Get the identity, environment, and OAuth pieces ready first. The manifest is much easier once you already have the right values.

    Step 1: Create the App Registration

    Start in Microsoft Entra.
    https://entra.microsoft.com/

    Create an app registration that will be used for the Dataverse MCP connection.

    Capture these values:

    • Tenant ID
    • Application / Client ID
    • Client secret
    • Secret expiry date

    You will use the Client ID more than once, so copy it somewhere safe.

    Add the Dataverse MCP permission

    In the app registration, add the required API permission for Dataverse MCP.

    1. Open the app registration
    2. Go to API permissions
    3. Select Add a permission
    4. Select Microsoft APIs
    5. Select Dynamics CRM
    6. Add the permission:
    mcp.tools

    Grant admin consent if your tenant requires it.

    Add the redirect URI

    1. For the OAuth flow, add this redirect URI if your setup requires it:
    https://teams.microsoft.com/api/platform/v1.0/oAuthRedirect

    Important: the Application / Client ID is not the same as the OAuth registration ID you will create later.

    Keep those two values separate.

    Step 2: Configure the Power Platform environment

    Next, configure the Power Platform environment that contains your Dataverse data.

    You need the Dataverse environment to allow MCP clients.

    Open Power Platform admin center and go to the target environment.

    1. Open Power Platform admin center
    2. Go to Manage
    3. Select Environments
    4. Open your target environment
    5. Open Settings
    6. Go to Product
    7. Open Features
    8. Find the Dataverse MCP setting
    9. Allow MCP clients to interact with Dataverse MCP server
    10. Only check the GA version of the MCP server > Click Save

    The exact wording may change because this area is still moving, but the goal is the same: allow MCP clients for that environment

    Add the allowed MCP client

    Now add your Entra Application / Client ID as an allowed MCP client for the environment.

    1. Click “Go to Advanced Settings” link under Step 2
    2. Click +New > fill in the details like this:
      – Name: Cowork Dataverse MCP – <env name>
      – Unique Name: new_CoworkDataverseMCP<envName>
      – Application Id: Paste your application Id from the App Registration you created in section 1
      – Is Enabled: Yes
    3. Click Save & Close

    That part matters.

    The value you add here is the Entra Application / Client ID.

    Also make sure the allowed MCP client is enabled.

    If this step is wrong, the plugin can look fine but still fail when Cowork tries to use Dataverse.

    Before leaving the admin center, grab the Environment URL.

    Capture the Dataverse URL

    You need your Dataverse Org URL

    It looks like this:

    https://yourorg.crm.dynamics.com

    The MCP server URL is the same URL with /api/mcp added to the end.

    https://yourorg.crm.dynamics.com/api/mcp

    Step 3: Create the OAuth registration in Teams Developer Portal

    Now open Teams Developer Portal.
    ( https://dev.teams.microsoft.com/ )

    Create an OAuth client registration for the plugin.

    This registration stores the OAuth configuration and gives you the OAuth registration ID that your plugin manifest will reference.

    In the OAuth registration, you will enter values from the Entra app and your Dataverse environment.

    1. Click Tools > OAuth client registration
    2. + New OAuth client registration

    Base URL

    Use your Power Platform Environment URL

    https://<yourorg>.crm.dynamics.com

    Restrict usage by Teams app: select Any Teams app (for now, since we don’t have a Teams app ID yet)

    Authorization endpoint

    Use your Tenant ID in this format:

    https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/authorize

    Token endpoint

    Use your Tenant ID in this format:

    https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token

    Scope

    The scope should use your Dataverse Org URL.

    Use this format:

    https://yourorg.crm.dynamics.com/.default offline_access

    Example:

    https://kavoracrm.crm.dynamics.com/.default offline_access

    Client ID and secret

    Use the Client ID and secret from the Entra app registration you created earlier.

    After saving the OAuth registration, copy the OAuth registration ID.

    You will use that value in the plugin manifest as the connector referenceId.

    Important: the OAuth registration ID goes into the plugin manifest.

    Step 4: Build the plugin

    For this approach, the plugin should stay focused on the Dataverse MCP connector.

    To make this even easier, I created a Cowork-Plugin skill to assist in building the Plugin with a template.

    Import Plugin Builder skill

    1. Download my /cowork-plugin-builder skill
    2. In Copilot Cowork > attach the skill and prompt: Add this skill
    3. After import refresh your browser

    Build Dataverse Plugin with Template

    We will use the skill you just imported to help build the plugin.

    1. Inside Copilot Cowork craft a prompt and add the cowork-plugin-builder skill
    2. Add these details or Copilot Cowork will ask you for these values
      (NOTE: If your using the Checklist app I created to track progress, click the Copy setup summary. Paste this into the prompt as well)

    Prompt to use:

    /cowork-plugin-builder to build a Dataverse plugin using this template:‌
    Organization name: 
    Connector display name: 
    description: 
    Tenant ID: 
    Client ID: 
    Org URL:
    MCP URL:
    OAuth registration ID:
    OAuth scope: 
    Connector referenceId:

    Fill in everything you can.

    I created a Dataverse-style icon with a Cowork badge so the plugin is easy to recognize when it appears in Cowork.
    (Included in the template)

    When Copilot Cowork is done, you should receive a zip file.

    Download the zip file.

    Step 5: Deploy the plugin

    After the package is ready, deploy it to a test user or test group first.

    1. M365 Admin Center > Agents > All agents > Upload custom app > pick dataverse-<pluginname>.zip
    2. Publish to users: add yourself first
    3. Install (optional): add yourself so it auto-appears
    4. Accept permissions > Review & finish
    • Apply Template (default should be fine)
    • Review Permissions (should be none, since permissions are done through the App registration)
    • Publish

    Keep the first deployment small.

    Connect Plugin

    1. Open a fresh Copilot Cowork session
    2. Click + > Manage Plugins
    3. Click … Browse Plugins
    4. Find the Plugin > Click Add
    5. Scroll down and click Connect

    Start with a simple prompt like this:

    Use the <Plugin name> to confirm you can access the Dataverse MCP server.

    Important: when you change the plugin package, update the version before uploading again.

    Also start a fresh Cowork session after deployment changes.

    Otherwise, you can end up testing against a stale session and thinking the plugin is broken.

    Step 6: Create a schema-aware skill

    This is the step that makes the plugin more useful.

    The plugin gives Cowork access to Dataverse.

    The schema skill helps Cowork understand what to do with that access.

    In the schema skill, give Cowork the details it needs to query your model properly.

    • Table logical names
    • Table purpose
    • Primary columns
    • Lookup columns
    • Relationships between tables
    • Status fields
    • Rules for what matters
    • Data-quality checks
    • Example prompts

    We can use this skill to create a personal skill to query certain tables, etc.

    In the example, I ask Copilot Cowork what tables are used in a certain Model-Driven App.
    Prompt:

    What tables are apart of Kavora Equipment Hub
    /dataverse-schema-

    Copilot Cowork responds with a tables and logical names.
    Next I ask for all the logical columns for those tables.
    (NOTE: This will help Copilot Cowork query your data quicker)

    My follow-up prompt:

    Yes pull all logical columns.
    I want to build a skill around these tables and data.
    Name the Skill Kavora Equipment IQ

    Then Copilot Cowork drafted the skill for me.
    I reviewed it and said “Looks good”

    Copilot Cowork built the skill

    Step 7: Test with a real scenario

    Now run an actual test.

    Do not only ask Cowork to connect.

    Ask it to use the Dataverse model.

    A good test should include:

    • One known record
    • At least one related table
    • At least one lookup relationship
    • Some output Cowork needs to organize
    • A data-quality check or business rule

    Example prompts:

    List records

    use /<skill you just built>
    List all the  <table>

    Add records

    use /<skill you just built>
    can you add 3 more <assets>
    1. Blue Yeti mic, Regional Office, value (you look this up in USD)‌
    2. Red dragon Keyboard (RGB), lookup value, put in the HQ
    3. Surface Arc Mouse, lookup price, put in HQ

    Details on a record

    use /<skill you just built>
    list all the <table> who  <condition>

    Build Dashboard

    use /<skill you just built>
    give me a full dashboard of <record>.
    Surface all details relating to <record>

    Create report

    use /<skill you just built>
    now create a report with each <Employee>
    on what they have left VS what they have used for budget

    Send Email with context

    use /<skill you just built>
    Email <James chen> asking about the <assets>

    Create PPT with context + Brand

    (NOTE: the branding is a separate skill not included in the plugin)

    use /<skill you just built>
    Now put this information inside a PPT
    using </branding-skill> for Kavora branding.
    This PPT is for Kavora Executives.
    Make it look polished with graphs and charts and pop.

    This is where the setup starts paying off.

    Cowork can query the data, follow relationships, and return a useful answer instead of forcing you to manually pull everything together.

    Common mistakes

    Mistake 1: Mixing up the IDs

    There are two important IDs:

    • Entra Application / Client ID: used in Power Platform as the allowed MCP client
    • OAuth Registration ID: used in the plugin manifest as the referenceId

    If you paste the wrong one in the wrong place, the setup will fail.

    Mistake 2: Wrong MCP URL

    The MCP URL should look like this:

    https://yourorg.crm.dynamics.com/api/mcp

    Watch for missing /api/mcp.

    Mistake 3: Wrong OAuth scope

    The scope should use your Dataverse Org URL:

    https://yourorg.crm.dynamics.com/.default offline_access

    Mistake 4: Testing with a user that cannot access the data

    Make sure the user testing the plugin has access to the Dataverse tables you are querying.

    Mistake 5: Re-uploading the same version

    If you change the package, update the version number before uploading again.

    Download the checklist

    I built a simple HTML checklist for this setup.

    It lets you track the values, check off steps, auto-fill the scope from your Dataverse URL, and generate the connector snippet.

    Download the Dataverse MCP Connector for Copilot Cowork setup checklist

    Official docs

    Final take

    NOTE: When you have tested and validated you can connect to Dataverse. You will want to add the Teams App ID from the Agent Plugin we deployed and add it to the Teams Developer OAuth Registration.

    1. Go to Teams Admin center > Teams apps > Manage apps
    2. Find your Plugin you deployed > Copy the App ID
    3. Go back to Teams Developer Portal and open the OAuth registration tool that was created
    4. Paste the App ID into the “Restrict usage by Teams app” field as an Existing Teams app

    This setup is still early, and there are rough edges.

    But once it works, the direction is obvious.

    Dataverse already has the business model.

    Copilot Cowork gives users a work surface.

    The MCP connector connects the two.

    Add a schema-aware skill, and Cowork can start working through real Dataverse data in a way that feels practical for actual business scenarios.

    That is the part worth paying attention to.

    Let me know what other Plugins you want to see in Copilot Cowork.

  • 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.

  • Boost Productivity with Planner and Copilot Cowork

    Boost Productivity with Planner and Copilot Cowork

    Copilot Cowork Prompt of the Day: Planner + Cowork

    Most people open Planner, see a wall of tasks, and then burn time figuring out where to start.

    Bad move.

    A better play is to use the Planner (Frontier) agent to pull everything due this week, then hand that full output to Copilot Cowork so it can start moving the work immediately.

    That is exactly what I did here.

    I had 6 tasks due in the upcoming week. Instead of manually opening each one, rewriting the context, drafting emails, setting meetings, and creating documents one by one, I used Planner to extract the full list and Copilot Cowork to help kick things off.

    The scenario

    I had a packed week ahead with multiple tasks already assigned to me in Planner. I needed a fast way to get organized and get the work moving before the week started tightening up.

    So I used the new Planner (Frontier) agent to give me a full view of what was due, then I passed that output directly into Copilot Cowork.

    That gave Cowork real context to work with: due dates, notes, priorities, task titles, and the actual work that needed to happen.

    Step 1: Pull the weekly task list from Planner

    First, I asked Planner to show me everything due this week and give me the full details.

    Show me tasks that are due this week.
    Give me full details.
    I will be giving your output to Copilot Cowork to do the tasks.

    Planner returned the task list with the details I needed. Then I asked it for one more thing: put the output into a code block.

    Can you output this in code block

    That extra step is smart. It makes the output much easier to copy and paste cleanly without wrecking the formatting or losing structure. Also AI loves it.

    Step 2: Hand the extract to Copilot Cowork

    Next, I dropped that Planner output into Copilot Cowork with a very simple prompt.

    I pulled the list of items I need to get done this week coming up.
    Get these things going and started, so I can get them done on time.
    Here is the extract from Planner:
    <Paste output from Planner agent from step 1>

    No complicated framework. No giant system prompt. Just the actual task extract from Planner and a direct ask.

    That is where this gets good. Cowork is no longer guessing what matters. It has the real list in front of it.

    Step 3: Let Cowork start the work

    Once Cowork had the context, it started breaking the workload down and pushing the execution forward.

    In my example, the work included:

    • Drafting emails and Teams messages to align what was still left for the team to build
    • Setting up workshop meetings to gather more requirements
    • Checking availability and scheduling the right people
    • Creating a procedure document
    • Helping move general dev work forward

    That is a strong workflow because it cuts out the dead time between seeing the work and starting the work.

    Instead of looking at six tasks and thinking, I should probably get on this, Cowork starts lining up the actual actions that move those tasks forward.

    Teams message sent to group chat:


    Procedure document generated:

    Meeting scheduled:

    Recap

    Planner and Cowork each do a different job, and that is exactly why this combo works.

    • Planner gives you the structured workload
    • Planner gives you the dates, notes, priority, and task details
    • Cowork uses that context to help draft, schedule, create, and coordinate

    You are not starting from a blank chat. You are starting from actual work that already exists inside Microsoft 365.

    Prompt recap

    Planner prompt

    Show me tasks that are due this week.
    Give me full details.
    I will be giving your output to Copilot Cowork to do the tasks.

    Planner follow-up

    Can you output this in code block

    Copilot Cowork prompt

    I pulled the list of items I need to get done this week coming up.
    Get these things going and started, so I can get them done on time.
    Here is the extract from Planner:
    <Paste output from Planner agent from step 1>

    Why I like this prompt

    This one is simple, practical, and dangerous in a good way.

    You take a task list that usually just sits there, and you turn it into momentum.

    That is the real win. Less dragging. More movement.

    If you are already using Planner, this is one of the easiest Copilot Cowork workflows to start using right now.