Interactive workflow design advisor for Power Automate, n8n, Make, Zapier and other platforms. Guides users through planning automation workflows with smart questions about triggers, actions, data flow, and error handling. Uses research sub-agent to find best practices and generates detailed implementation plan. Triggers when user mentions "create workflow", "build flow", "design automation", "need ideas for", or describes workflow requirements without having a complete design.
Interactive advisor that plans automation workflows by asking guided questions about triggers, data sources, and actions. Activates when users mention "create workflow," "build flow," or describe automation requirements without a complete design.
/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.
Interactive workflow design advisor that helps plan and architect automation workflows through guided conversations.
This skill provides expert guidance for planning automation workflows by:
Automatically activates when user:
Does NOT activate when:
CRITICAL: Always determine the platform first!
Check if Platform Specified
Ask for Platform if Missing
Use AskUserQuestion tool:
Question: "Which automation platform will you be using for this workflow?"
Header: "Platform"
Options:
- Power Automate (Microsoft cloud platform with Office 365 integration)
- n8n (Open-source, self-hosted, node-based automation)
- Make (Visual scenario builder, formerly Integromat)
- Zapier (SaaS automation platform, easy to use)
- Other (Specify in custom response)
Gather Initial Requirements
Use AskUserQuestion tool for guided discovery. Ask 2-4 questions per iteration.
Use AskUserQuestion tool:
Question 1: "What should trigger this workflow?"
Header: "Trigger Type"
Options:
- Schedule (Run on a regular schedule - hourly, daily, etc.)
- Event (Triggered by an event - new email, file upload, etc.)
- Webhook (Triggered by HTTP request from external system)
- Manual (Run on demand by user)
Question 2: "How frequently will this workflow run?"
Header: "Frequency"
Options:
- High (Multiple times per minute or real-time)
- Medium (Every few minutes to hourly)
- Low (Daily, weekly, or on-demand)
- Variable (Depends on external events)
Use AskUserQuestion tool:
Question 1: "What data sources will you read from?"
Header: "Data Sources"
MultiSelect: true
Options:
- Databases (SQL, NoSQL, cloud databases)
- APIs (REST APIs, webhooks, web services)
- Files (CSV, Excel, JSON, XML, documents)
- Email (Read emails, attachments, process content)
- Other (Cloud storage, messaging systems, etc.)
Question 2: "What actions will the workflow perform?"
Header: "Actions"
MultiSelect: true
Options:
- Transform data (Parse, filter, map, aggregate)
- Create/Update records (Database, CRM, systems)
- Send notifications (Email, Slack, Teams, SMS)
- File operations (Upload, download, convert)
- Other (Custom API calls, complex logic)
Use AskUserQuestion tool:
Question 1: "How critical is this workflow?"
Header: "Criticality"
Options:
- Critical (Must not fail, needs immediate alerts)
- Important (Should retry on failure, log errors)
- Standard (Basic error handling, can fail occasionally)
- Low (Minimal error handling, best effort)
Question 2: "What are your main concerns?"
Header: "Concerns"
MultiSelect: true
Options:
- Performance (Speed, processing large volumes)
- Reliability (Must not lose data, retry logic)
- Security (Handle sensitive data, authentication)
- Monitoring (Need visibility, logging, alerts)
- Cost (API limits, execution costs, efficiency)
CRITICAL: Use Task tool to launch research sub-agent.
Use Task tool with subagent_type="Explore" and thoroughness="very thorough"
Prompt: "Research best practices for [PLATFORM] workflow with the following requirements:
Platform: [Power Automate / n8n / Make / Zapier]
Trigger: [USER_SELECTED_TRIGGER]
Data Sources: [USER_SELECTED_SOURCES]
Actions: [USER_SELECTED_ACTIONS]
Criticality: [USER_SELECTED_CRITICALITY]
Search in Docs/{Platform}_Documentation/ for:
1. Recommended patterns for this trigger type
2. Best practices for the selected data sources
3. Error handling patterns for this criticality level
4. Performance optimization (API limits, batching, etc.)
5. Security best practices for this use case
6. Common pitfalls to avoid
Return:
- Specific connector/node recommendations
- Architectural patterns
- Error handling strategies
- Performance considerations
- Security recommendations
- Example implementations if available"
Expected Research Output:
Based on user requirements and research findings:
Architecture Overview
Implementation Considerations
Platform-Specific Recommendations
Potential Issues & Solutions
Create detailed, structured plan ready for automation-build-flow skill.
# Workflow Implementation Plan
## Platform
[Power Automate / n8n / Make / Zapier]
## Overview
[1-2 sentence description of what the workflow does]
## Requirements Summary
- **Trigger**: [Trigger type and configuration]
- **Frequency**: [Expected execution frequency]
- **Data Sources**: [List of sources]
- **Actions**: [List of main actions]
- **Criticality**: [Criticality level]
## Architecture
### 1. Trigger Configuration
**Type**: [Schedule / Event / Webhook / Manual]
**Configuration**:
- Parameter 1: [Value]
- Parameter 2: [Value]
**Platform-Specific**:
- Connector/Node: [Name]
- Special considerations: [Any platform quirks]
### 2. Data Flow
#### Step 1: [Action Name]
**Purpose**: [What this step does]
**Connector/Node**: [Platform-specific component]
**Configuration**:
- Input: [Data source/format]
- Processing: [What happens]
- Output: [Result format]
**Error Handling**:
- On failure: [Retry / Skip / Alert]
- Fallback: [Alternative action if needed]
#### Step 2: [Action Name]
[Same structure as Step 1]
#### Step N: [Action Name]
[Same structure]
### 3. Conditional Logic
**Condition 1**: [Description]
- If true → [Action path]
- If false → [Alternative path]
**Condition 2**: [Description]
[Same structure]
### 4. Error Handling Strategy
**Global Error Handler**:
- Wrap critical sections in: [Scope / Try-Catch / Error boundary]
- On error:
1. Log error details
2. [Retry logic if applicable]
3. Send notification to: [Email / Slack / Teams]
**Action-Specific Error Handling**:
- [Action 1]: [Specific handling]
- [Action 2]: [Specific handling]
### 5. Performance Optimization
**API Rate Limiting**:
- [Connector/API]: [Limit] calls per [time period]
- Mitigation: [Delays / Batching / Throttling strategy]
**Data Processing**:
- Batch size: [Number] items per iteration
- Pagination: [Strategy if needed]
- Filtering: [Filter at source to reduce volume]
**Concurrency**:
- Parallel execution: [Yes/No and configuration]
- Sequential processing: [When and why]
### 6. Security Considerations
**Authentication**:
- [Connector/API]: [Auth method]
- Credential storage: [Secure parameters / Connection references]
**Data Handling**:
- Sensitive data: [Encryption / Masking strategy]
- Logging: [What to log / What to exclude]
- Compliance: [GDPR / HIPAA / Other requirements]
### 7. Monitoring & Logging
**Logging Strategy**:
- Log points: [Where to log]
- Log level: [Info / Warning / Error]
- Log destination: [Platform logs / External system]
**Monitoring**:
- Success metrics: [What indicates success]
- Failure alerts: [When to alert]
- Performance metrics: [Execution time / Volume processed]
## Best Practices Applied
1. **[Platform] Best Practice 1**
- Applied in: [Step/Action]
- Benefit: [Why this helps]
2. **[Platform] Best Practice 2**
- Applied in: [Step/Action]
- Benefit: [Why this helps]
[Continue for all relevant best practices]
## Known Limitations & Workarounds
1. **Limitation**: [Description]
- Impact: [How it affects the workflow]
- Workaround: [Solution implemented]
- Reference: [Docs/{Platform}_Documentation/file.md]
2. **Limitation**: [Description]
[Same structure]
## Testing Strategy
**Test Cases**:
1. Happy path: [Normal execution scenario]
2. Error scenarios: [What failures to test]
3. Edge cases: [Boundary conditions]
4. Load testing: [If high volume]
**Validation**:
- Data accuracy: [How to verify]
- Performance: [Acceptable execution time]
- Error handling: [Verify failures handled correctly]
## Deployment Checklist
- [ ] All credentials configured securely
- [ ] Error handling tested
- [ ] Monitoring/alerts set up
- [ ] Documentation created
- [ ] Stakeholders notified
- [ ] Backup/rollback plan ready
## Next Steps
1. Review this plan with stakeholders
2. Use **automation-build-flow** skill to generate workflow JSON
3. Deploy to test environment
4. Execute test cases
5. Monitor initial runs
6. Deploy to production
## References
**Documentation**:
- [Docs/{Platform}_Documentation/[relevant-files].md]
**Best Practices Source**:
- [Specific sections from platform docs]
---
*This plan was generated by automation-brainstorm skill and is ready for automation-build-flow*
After generating the plan:
Present Complete Plan
Summarize Key Points
Next Steps
Save Plan (Optional)
workflow_plan_{name}.mdIf platform not specified → Use AskUserQuestion immediately
Do not proceed with generic advice
Platform determines connectors, patterns, limitations
Don't ask all questions at once
2-4 questions per iteration
Adjust questions based on previous answers
Use multiSelect for non-exclusive choices
Always use research sub-agent
Don't rely on general knowledge
Cite specific documentation files
Platform-specific recommendations only
Follow the plan format exactly
Include all sections
Be specific (no placeholders or TODOs)
Ready for automation-build-flow consumption
Beginner → More explanation, simpler patterns
Intermediate → Best practices, common patterns
Advanced → Performance optimization, complex patterns
User idea
↓
automation-brainstorm (this skill)
↓
Implementation Plan
↓
automation-build-flow
↓
Complete workflow JSON
↓
automation-validator
↓
Deploy to platform
To automation-build-flow:
To automation-debugger (if user mentions problems):
To automation-validator (if user wants to check existing flow):
User: "I want to create a workflow that syncs customer data from Salesforce to our database"
Skill:
User: "I need something to handle incoming emails"
Skill:
User: "Build high-volume API sync workflow for Make"
Skill:
Before delivering plan, verify:
If user asks for changes:
"Can you add email notifications?"
→ Update relevant section
→ Add email action to data flow
→ Update error handling if needed
→ Regenerate updated plan
If requirements suggest multiple workflows:
"This should be split into 2 workflows:
1. [Workflow 1 purpose]
2. [Workflow 2 purpose]
Should I create separate plans?"
If user unsure about platform:
"Would you like me to compare how this would work on:
- n8n vs Power Automate?
- Make vs Zapier?
I can show pros/cons for your use case"
Guide with examples:
"Let me give you examples:
- E-commerce order processing
- Customer onboarding automation
- Report generation and distribution
- Data synchronization between systems
Which is closest to your use case?"
Provide guidance:
"Platform selection depends on:
- Power Automate: Best if you use Microsoft 365, cloud-native
- n8n: Best if you want self-hosted, open-source, full control
- Make: Best for visual design, many pre-built templates
- Zapier: Best for quick setup, ease of use, SaaS
What's your priority?"
Skills should reference:
Docs/{Platform}_Documentation/ - Platform-specific docsoutput-style/ - Output formatting standardsThis skill is the starting point for creating new automation workflows. Always generates a complete, actionable plan ready for automation-build-flow skill.
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.