Workflow builder for Power Automate, n8n, Make, Zapier and other platforms. Generates complete, production-ready workflow JSON from implementation plans or requirements. Uses flow-builder sub-agent to create valid platform-specific JSON with all triggers, actions, error handling, and configurations. Triggers when user has a plan/requirements and wants to generate workflow JSON, or says "build this workflow", "create the flow", "generate JSON". Output ready for import into target platform.
Generates complete, production-ready workflow JSON for Power Automate, n8n, Make, and Zapier from implementation plans or requirements. Activates when you say "build this workflow," "create the flow," or provide a plan to generate platform-specific JSON ready for immediate import.
/plugin marketplace add MacroMan5/AutomationHelper_plugins/plugin install automation-helper@automation-helper-marketplaceThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Professional workflow builder that generates complete, production-ready JSON for any automation platform.
This skill generates complete automation workflows by:
Automatically activates when user:
Prerequisites:
Does NOT activate when:
Determine Input Type
Type A: Implementation Plan (from automation-brainstorm)
Type B: Direct Requirements (user provided)
Verify Platform
Check if platform specified:
Use AskUserQuestion tool:
Question: "Which platform should I generate this workflow for?"
Header: "Platform"
Options:
- Power Automate (Microsoft, generates .json for "Paste code" feature)
- n8n (Open-source, generates workflow.json for import)
- Make (Integromat, generates scenario blueprint.json)
- Zapier (Generates zap JSON for import API)
- Other (Specify platform and format needed)
Validate Requirements Completeness
Essential elements needed:
If missing critical info:
Use AskUserQuestion tool to gather missing pieces:
Example for missing trigger:
Question: "What should trigger this workflow?"
Header: "Trigger"
Options: [Schedule/Event/Webhook/Manual]
Example for missing actions:
Question: "What are the main actions this workflow should perform?"
Header: "Actions"
MultiSelect: true
Options: [Based on context]
CRITICAL: Use Task tool to launch flow-builder sub-agent.
Use Task tool with subagent_type="general-purpose" or "Plan"
Prompt: "Generate complete workflow JSON for [PLATFORM] with the following specification:
## Platform
[Power Automate / n8n / Make / Zapier / Other]
## Complete Specification
[IF FROM PLAN: Paste entire implementation plan here]
[IF FROM REQUIREMENTS: Structure requirements as:]
### Trigger
Type: [Schedule/Event/Webhook/Manual]
Configuration:
- [Parameter 1]: [Value]
- [Parameter 2]: [Value]
Platform connector/node: [Specific component]
### Actions/Steps
#### Step 1: [Name]
Purpose: [What it does]
Connector/Node: [Platform-specific component]
Inputs:
- [Input 1]: [Value/Expression]
- [Input 2]: [Value/Expression]
Outputs: [What this step produces]
#### Step 2: [Name]
[Same structure]
[Continue for all steps]
### Conditional Logic
[If applicable, describe conditions and branching]
### Error Handling
Global strategy: [Scope/Try-catch/Error boundary]
Step-specific handling:
- [Step 1]: [On error behavior]
- [Step 2]: [On error behavior]
### Performance Configuration
- API rate limits: [Delays/Throttling needed]
- Batching: [Batch size if applicable]
- Concurrency: [Sequential/Parallel configuration]
### Security
- Authentication: [Method for each connector]
- Sensitive data: [Handling strategy]
### Monitoring
- Logging: [What to log]
- Alerts: [When to alert]
## Requirements for Generated JSON
CRITICAL - The output must be:
1. **Complete and Valid**
- Syntactically correct JSON for [PLATFORM]
- All required fields present
- No placeholders or TODOs
- Valid IDs/GUIDs as required by platform
2. **Platform-Specific Structure**
- Follow [PLATFORM] schema exactly
- Reference: Docs/{Platform}_Documentation/format-specification.md
- Use correct connector/node names for platform
- Follow platform naming conventions
3. **Fully Configured**
- All triggers properly configured
- All actions have complete inputs
- Error handlers in place
- Dependencies/runAfter chains correct
- Variables initialized if needed
4. **Best Practices Implemented**
- Error handling as specified
- Performance optimizations (delays, batching)
- Security configurations
- Retry logic for transient errors
- Idempotency where applicable
5. **Ready for Import**
- Can be directly imported/pasted into [PLATFORM]
- No manual editing needed
- All expressions/formulas valid for platform
- Connection placeholders where appropriate
## Platform-Specific Requirements
[IF Power Automate]:
- Schema: https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#
- Include $connections parameter
- Use correct operationId for each action
- Proper runAfter chains
- GUID format for operationMetadataId
[IF n8n]:
- nodes array with proper IDs
- connections object linking nodes
- position coordinates for visual layout
- Proper credential references
- Node versions specified
[IF Make]:
- modules array with proper IDs
- Proper connections/routing
- Scenario metadata
- Module configurations
[IF Zapier]:
- steps array
- Proper step types
- Action configurations
- Trigger setup
Return ONLY the complete JSON - no explanations, no markdown code blocks, no additional text.
Just the pure JSON ready for import."
Expected Output from Flow-Builder Agent:
Before presenting to user:
Syntax Check
Completeness Check
Platform Compliance
If validation fails → Retry with flow-builder agent with specific corrections needed
Format output for user:
# Workflow JSON Generated ✅
## Platform
[Platform Name]
## Summary
- **Trigger**: [Trigger type]
- **Actions**: [Count] actions/nodes
- **Error Handling**: [Strategy implemented]
- **Status**: Ready for import
---
## Complete Workflow JSON
**Instructions**: Copy the entire JSON below and import into [PLATFORM]:
[IF Power Automate]: Paste into Power Automate using "Paste code" feature
[IF n8n]: Import via Settings → Import Workflow
[IF Make]: Import via Scenarios → Create new → Import Blueprint
[IF Zapier]: Use Zapier CLI or import API
```json
{
// Complete workflow JSON here
}
✅ Trigger Configuration
✅ Actions/Steps ([Count] total)
✅ Error Handling
✅ Performance Optimizations
✅ Security
Import into [PLATFORM]
Configure Connections
Test the Workflow
Validate with automation-validator (Recommended)
Deploy
[Any platform-specific notes]:
Test Cases:
Validation Points:
Generated by automation-build-flow skill. Ready for immediate import into [PLATFORM].
## Output Format Variations by Platform
### Power Automate
```json
{
"definition": {
"$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"$connections": {
"defaultValue": {},
"type": "Object"
}
},
"triggers": {
"trigger_name": {
"type": "Recurrence",
"recurrence": {
"frequency": "Hour",
"interval": 1
}
}
},
"actions": {
"action_1": {
"type": "ApiConnection",
"inputs": { /* ... */ },
"runAfter": {}
}
}
},
"schemaVersion": "1.0.0.0"
}
{
"name": "Workflow Name",
"nodes": [
{
"parameters": { /* ... */ },
"name": "Node Name",
"type": "n8n-nodes-base.nodeName",
"typeVersion": 1,
"position": [250, 300],
"id": "uuid"
}
],
"connections": {
"Node1": {
"main": [[{"node": "Node2", "type": "main", "index": 0}]]
}
}
}
{
"name": "Scenario Name",
"flow": [
{
"id": 1,
"module": "gateway:CustomWebHook",
"parameters": { /* ... */ }
}
],
"metadata": {
"version": 1
}
}
{
"title": "Zap Name",
"steps": [
{
"type": "trigger",
"app": "app_name",
"event": "event_name",
"params": { /* ... */ }
}
]
}
Provide ALL details to flow-builder:
- Complete plan or requirements
- Platform-specific connector names
- All configurations and parameters
- Error handling requirements
- Performance settings
Don't assume sub-agent knows context!
Always check generated JSON:
✅ Syntax valid
✅ Structure complete
✅ Platform schema compliance
✅ No placeholders/TODOs
✅ All actions present
If issues found → Regenerate with corrections
Provide platform-specific import steps:
- Where to import (exact menu path)
- What to configure after import
- Common issues to watch for
- Validation recommendations
Never skip error handling:
- Global error handler (scope/try-catch)
- Action-level handlers where needed
- Retry logic for transient errors
- Notifications on critical failures
Always include performance optimizations:
- API rate limit respect (delays)
- Batching for high-volume
- Concurrency configuration
- Filtering at source
automation-brainstorm
↓
Implementation Plan
↓
automation-build-flow (this skill)
↓
Complete Workflow JSON
↓
automation-validator (recommended)
↓
Deploy to Platform
Perfect Integration:
How to Handle:
Recommended Flow:
After JSON generation:
"Would you like me to validate this workflow before you import it?
I can run automation-validator to check for potential issues."
If user agrees:
If user provides requirements without plan:
User: "Build the workflow from the plan above"
Skill:
User: "Create a Power Automate flow that runs daily and emails me a list of new files from OneDrive"
Skill:
User: "Build a workflow that syncs database to API"
Skill:
User: "Implement the workflow plan for high-volume Salesforce sync"
Skill:
Before delivering JSON, verify:
If user wants changes:
"Add email notification when it fails"
→ Regenerate with updated spec
→ Add email action to error handler
→ Present updated JSON
If user has JSON and wants to modify:
"This workflow needs better error handling"
→ Read existing JSON
→ Identify error handling gaps
→ Regenerate with improvements
→ Present updated JSON
If user wants same workflow for different platforms:
"Generate this for both Power Automate and n8n"
→ Generate for Power Automate
→ Generate for n8n
→ Present both with comparison notes
Problem: JSON has syntax errors or missing elements
Solution:
"Previous generation had [SPECIFIC_ISSUE].
Regenerate with correct [CORRECTION]."
Problem: JSON doesn't match platform schema
Solution:
Problem: Generated JSON missing key settings
Solution:
Problem: Requirements unclear, can't generate reliably
Solution:
Skills should reference:
Docs/{Platform}_Documentation/ - Platform docsThis skill is the build engine for automation workflows. Always generates complete, production-ready JSON using flow-builder sub-agent. Never hand-codes workflow JSON.
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.