Auto-Document Power Automate Flows with Claude or GitHub Copilot

How do I document my Power Automate flows? It comes up in every Power Platform community forum I read. It is a real pain for the people responsible for flows. Very few people enjoy reading through old flows and turning them into documentation.

Nowadays with GPT this has been easier - many people throw the definition into GPT and ask it to summarize the flow. But it is still manual - you need to do it flow by flow. 

I have three autonomous approaches with MCP that resolve the problem in bulk. Even if you have hundreds of flows, these approaches won't take you more than a half day to document the first draft (assuming human review final outcome would still take time). With the MCP free quota,  <70 flows is likely to be completely free.

This article is the first of the trilogy - this is the developer path: an AI coding agent in your IDE writes the docs, you review and ship.

I didn't open Power Automate designer once.

What it took:

• One prompt (a paragraph)
• Two tools wired in (Flow Studio MCP for the read side, a Service Principal with SharePoint scope for the write side)
• One spec: the 6 inventory columns and 7 page sections I wanted, written into the prompt itself. No pre-built template page needed; the agent assembled the pages from my prompt.

For the first small-batch trial, the agent picked three flows for me to sanity-check first, drafted a page per flow, registered each in the inventory, then batched the remaining 43.

What I set up

1. A Service Principal with SharePoint writing access to the target site. I used an existing app registration in my tenant. Fresh setup is still small, but it is not just one checkbox. You create or reuse an app registration, grant it the Sites.Selected application permission, then call Microsoft Graph to grant that app write access to one specific SharePoint site. The agent can tell you the exact Graph request to run. After that, it uses an app-only token and can only write to the selected site.

2. Flow Studio MCP wired into the agent. Sign in to the Flow Studio MCP dashboard and copy an API key from the API Keys section, then pick the install path for your agent:

3. The target SharePoint site, empty. I told the agent the URL and let it create the inventory list itself.

What the agent did

The prompt was deliberately short. I wanted to see if the section list plus the tools could carry the rest:

Three Flow Studio MCP tools plus Microsoft Graph. Pipeline:

Blue = MCP read calls · Yellow = SharePoint writes via Graph · Green = my one human checkpoint

The screenshots below are the actual artifacts on MCPDemo, same data, easier to read at blog width.

Here is one of the three per-flow doc pages the agent produced. The other two pages, SQL GDR Monitor and Weekly Pending Approvals, use the same template; live pages for the SQL GDR Monitor flow doc and the Weekly Pending Approvals flow doc.

The template, and why it's two pieces not one

The split matters. The inventory list is the index you Ctrl-F when somebody asks "do we have a flow that does X?". The per-flow page is the drill-down you send to whoever has to maintain it next. Conflate them and you get one giant doc nobody reads.

Why give the agent the keys to SharePoint

This path is not for everyone. Here is the trade.

If your environment can't grant a service principal at this scope

If your tenant locks down app registrations, or you can't get a per-site Sites.Selected grant approved without weeks of admin sign-off, there's a second path that swaps the SharePoint app for a Power Automate cloud flow. The agent never touches SharePoint directly. It calls one flow, the flow does the writes.

Security note: treat the dispatcher flow URL like a write credential. Use a dedicated environment, restrict who can edit or call it, validate an auth header or shared secret in the trigger body, and rotate the URL if exposed. 

The meta part: I had the agent build the dispatcher flow itself, using Flow Studio MCP's flow-build skill. Same agent, same MCP server, just used in the other direction. The agent wrote a flow to act as its own SharePoint write surface.

The working flow in my tenant exposes one tool to the agent with an action enum and eight operations covering the full SharePoint Pages lifecycle: List, Read, Create, Modify, Checkout, Publish, Discard, Recycle. The agent calls it like any other tool: "Create a page with this title and these sections" → flow run → published page.

Each action wraps a SharePoint REST call. Here's what the flow gives the agent:

What the dispatcher flow actually looks like in the Power Automate designer:

The 6-column inventory plus the 7-section page spec from earlier still applies, unchanged. Only the write surface swaps. The agent learns one new tool (the flow) instead of one new credential (the app registration).

Try it in your tenant

1. Pick a small environment. 5-20 flows is a reasonable batch once you trust the output. Mine had 46 and the agent picked 3 to start; same logic at any size.
2. Set up the write surface. Pick one: an Azure app registration with Sites.Selected on the target site (Path 1, fast at runtime, needs admin grant), or a Power Automate dispatcher flow with an HTTP trigger (Path 2, slower at runtime, no Azure work). The agent can build either one for you. Sign in to az first for Path 1, or hand the agent the Flow Studio MCP build skill for Path 2.
3. Install Flow Studio MCP. Marketplace extension on VS Code Copilot, one claude mcp add command on Claude Code. Starter plan is free; current limits on the dashboard.
4. Hand over the section spec and the prompt. Don't pre-build a template page. List the columns and sections you want; the agent assembles each page from the spec. Iterate on the first one or two flows until the doc reads the way you want, then let the agent batch the rest.

About Flow Studio MCP: Flow Studio MCP is a Model Context Protocol server that gives AI agents action-level visibility into Power Automate. It's Available on GitHub via the awesome-copilot list. Works with GitHub Copilot, Claude, and any MCP-compatible agent.

Related reading:

• The same job, no IDE: documenting Power Automate flows from inside Copilot Studio with Work IQ
• Teaching a Copilot Studio agent to write its own SharePoint pages: a Power Automate dispatcher pattern
• AI agents can build Power Automate flows. Debugging is the trap.
  
  

Appendix - Dispatcher actions 

{
  "Title": "How I document Power Automate flows",
  "FileName": "my-page.aspx",
  "PageLayoutType": "Article",
  "CanvasContent1": [
    {
      "controlType": 4,
      "position": {
        "layoutIndex": 1, "zoneIndex": 1,
        "sectionIndex": 1, "sectionFactor": 12,
        "controlIndex": 1
      },
      "addedFromPersistedData": true,
      "editorType": "CKEditor",
      "id": "<guid>",
      "innerHTML": "<p>Your page HTML</p>"
    },
    {
      "controlType": 0,
      "pageSettingsSlice": {
        "isDefaultDescription": true,
        "isDefaultThumbnail": true
      }
    }
  ]
}

{
  "Title": "Updated title",
  "CanvasContent1": [
    {
      "controlType": 4,
      "position": { "...": "..." },
      "editorType": "CKEditor",
      "id": "<guid>",
      "innerHTML": "<p>Updated HTML</p>"
    },
    {
      "controlType": 0,
      "pageSettingsSlice": { "...": "..." }
    }
  ]
}

Catherine Han, Flow Studio