powerplatform

Q: How do I install powerplatform?

Run npx skills add https://github.com/robdtaylor/personal-ai-infrastructure --skill powerplatform in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/powerplatform/ (personal) or .claude/skills/powerplatform/ (project).

by robdtaylorProductivity & Automation

Generate Power Automate flows from natural language. Reads connector schemas from work repo, outputs deployable solution files. USE WHEN user says 'create flow', 'power automate', 'automate workflow', or describes a business process to automate.

Installs: 50
Last 24h: —
Trending rank: —
Security: Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/robdtaylor/personal-ai-infrastructure --skill powerplatform

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads powerplatform automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

PowerPlatform - Flow Generation Skill

Generate Power Automate flows from natural language descriptions using connector schemas exported from your work environment.

Workflow Routing

Power Platform has no Workflows/ directory — each request routes to a starting template in templates/ (customized against the connector schemas), then packages via tools/package-solution.sh. Reference examples in examples/ show finished flows.

Trigger phrase	Starting template	Reference
"notify", "send a message when", "alert on new email/item"	`templates/notification-flow.json`	`examples/urgent-email-teams-notification.json`
"approval", "route for sign-off", "approve/reject"	`templates/approval-flow.json`	`examples/sharepoint-item-approval.json`
"scheduled report", "every week/day send", "recurring summary"	`templates/scheduled-report.json`	`examples/weekly-report.json`
"save attachments", "process incoming email files"	`templates/email-attachment-handler.json`	`reference/actions.md`
Anything else / build from scratch	build inline from schema	`reference/expressions.md`, `reference/triggers.md`, `reference/actions.md`

Always start by reading ~/Projects/work/scripts/power-platform/manifest.json to confirm the needed connectors are available before generating.

Examples

Example 1: Teams notification on urgent email

User: "When an urgent email arrives in my work inbox, post it to the Ops Teams channel"
-> Reads manifest.json → confirms shared_office365 + shared_teams available
-> Starts from templates/notification-flow.json
-> Trigger: When_a_new_email_arrives (Office365), condition on importance = high
-> Action: Post_message_in_a_chat_or_channel (Teams)
-> Packages via tools/package-solution.sh
-> Saves to ~/Projects/work/scripts/power-platform/generated/urgent-email-notify.zip

Example 2: Document approval workflow

User: "Make a flow for document approval - when a file is added to SharePoint, start an approval, then move to approved/rejected folder"
-> Starts from templates/approval-flow.json
-> Trigger: When_a_file_is_created (SharePoint)
-> Action: Start_and_wait_for_an_approval (Approvals)
-> Condition branches on outcome → Update_item to move to approved/rejected library
-> Outputs deployable solution ZIP for import at work

Example 3: Scheduled weekly report

User: "Every Monday at 8am, pull last week's list items and email me a summary"
-> Starts from templates/scheduled-report.json
-> Trigger: Recurrence (Schedule), weekly on Monday 08:00
-> Action: Get_items (SharePoint) + Apply_to_each to build HTML table
-> Action: Send_an_email (Office365) with @{length(body('Get_items')?['value'])} count
-> Saves to generated/ as weekly-report.zip

Architecture

Work Repo (schemas)                    PAI (this skill)
~/Projects/work/scripts/               ~/.claude/skills/PowerPlatform/
power-platform/
├── connectors/          ──reads──>    ├── SKILL.md
│   ├── shared_teams.json              ├── templates/
│   ├── shared_outlook.json            ├── reference/
│   └── ...                            └── examples/
├── manifest.json
└── generated/           <──writes──   [Solution ZIPs]

Workflow

1. Check Available Connectors

Before generating, read the manifest to see what connectors are available:

cat ~/Projects/work/scripts/power-platform/manifest.json

If manifest.json doesn't exist or is stale, inform user to run the export script at work.

2. Parse User Request

Extract from natural language:

Trigger: What starts the flow (email arrives, file created, scheduled, manual)
Actions: What the flow does (send message, create item, update record)
Conditions: Any branching logic (if/then, switch)
Data flow: What data passes between steps

3. Generate Flow Definition

Create the flow JSON following Power Automate schema. Key structure:

{
  "properties": {
    "definition": {
      "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
      "triggers": { ... },
      "actions": { ... }
    },
    "connectionReferences": { ... }
  }
}

4. Package as Solution

Wrap in solution structure for import:

solution/
├── [Content_Types].xml
├── customizations.xml
├── solution.xml
└── Workflows/
    └── {flow-guid}-{flow-name}.json

5. Output

Save to: ~/Projects/work/scripts/power-platform/generated/

Connection References

Flows use connection references that map to actual connections in the target environment. Use placeholder IDs that will be resolved on import:

"connectionReferences": {
  "shared_teams": {
    "connectionName": "shared_teams",
    "source": "Embedded",
    "id": "/providers/Microsoft.PowerApps/apis/shared_teams",
    "tier": "NotSpecified"
  }
}

On import, Power Platform prompts user to map these to their actual connections.

Expression Syntax

Power Automate uses a specific expression language. Common patterns:

Dynamic Content References

@{triggerOutputs()?['body/subject']}           # Email subject from trigger
@{body('Get_item')?['Title']}                  # Field from previous action
@{items('Apply_to_each')?['name']}             # Current item in loop

Functions

@{utcNow()}                                    # Current timestamp
@{concat('Hello ', triggerBody()?['name'])}   # String concatenation
@{if(equals(1,1),'yes','no')}                 # Conditional
@{length(body('Get_items')?['value'])}        # Array length
@{formatDateTime(utcNow(),'yyyy-MM-dd')}      # Date formatting

Conditions

"expression": {
  "and": [
    { "contains": ["@triggerOutputs()?['body/subject']", "urgent"] },
    { "equals": ["@triggerOutputs()?['body/importance']", "high"] }
  ]
}

See reference/expressions.md for full syntax guide.

Common Triggers

Trigger	Connector	Use Case
`When_a_new_email_arrives`	Office365	Email automation
`When_a_file_is_created`	SharePoint	Document workflows
`When_an_item_is_created`	SharePoint	List automation
`When_a_row_is_added`	Dataverse	Database triggers
`Recurrence`	Schedule	Scheduled jobs
`manual`	Manual	Button-triggered
`When_a_HTTP_request_is_received`	HTTP	Webhook/API trigger

Common Actions

Action	Connector	Use Case
`Send_an_email`	Office365	Email notifications
`Post_message_in_a_chat_or_channel`	Teams	Team notifications
`Create_item`	SharePoint	Add list items
`Update_item`	SharePoint	Modify list items
`Start_and_wait_for_an_approval`	Approvals	Approval workflows
`Create_a_row`	Dataverse	Database writes
`HTTP`	HTTP	External API calls

Templates

Pre-built patterns in templates/:

approval-flow.json - Standard approval workflow
notification-flow.json - Event-triggered notifications
scheduled-report.json - Scheduled data collection
form-processing.json - Forms response handling
file-sync.json - Cross-system file operations

Generation Process

When asked to create a flow:

Read available schemas:

ls ~/Projects/work/scripts/power-platform/connectors/
cat ~/Projects/work/scripts/power-platform/manifest.json

Load relevant connector schemas for the requested functionality
Select appropriate template or build from scratch
Generate flow JSON with:
- Unique GUID for flow
- Proper trigger configuration
- Action sequence with correct operation IDs
- Connection references for all connectors used
- Expression syntax for dynamic content
Create solution package using tools/package-solution.sh
Save to generated folder and inform user

Limitations

Cannot deploy directly - User must import at work
Connection mapping required - User maps connections on import
Premium connectors - Some require premium licenses
Custom connectors - Not supported without schema export
Schema freshness - Depends on export frequency at work

Files Reference

File	Purpose
`templates/*.json`	Pre-built flow patterns
`reference/expressions.md`	Expression syntax guide
`reference/triggers.md`	Trigger configurations
`reference/actions.md`	Action configurations
`examples/*.json`	Working example flows
`tools/package-solution.sh`	Solution packager script

FAQ

What does the powerplatform skill do?

How do I install powerplatform?

Run npx skills add https://github.com/robdtaylor/personal-ai-infrastructure --skill powerplatform in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/powerplatform/ (personal) or .claude/skills/powerplatform/ (project).

Which AI agents can use powerplatform?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is powerplatform safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains powerplatform?

It is published by robdtaylor in robdtaylor/personal-ai-infrastructure. It has 50 recorded installs.