How to Automate Tasks with AI Prompts

Design an AI automation workflow for the following task.

Task: {{task_description}}
Current manual process: {{current_process}}
Tools available: {{available_tools}}

Create a step-by-step workflow:

For each step, specify:
1. **Step name**: Clear, descriptive label
2. **Input**: What data this step receives (from user or previous step)
3. **Prompt**: The exact prompt to use for this step
4. **Output format**: How the result should be structured (JSON, markdown, plain text)
5. **Validation**: How to check if this step succeeded before proceeding
6. **Fallback**: What to do if this step fails

Also provide:
- **Estimated time saved** vs. the manual process
- **Reliability score** (1-10) for each step
- **Where a human should review** before proceeding

Create an automation trigger configuration for the following scenario.

When: {{trigger_condition}}
Then: {{desired_action}}
Frequency: {{frequency}}

Define the trigger:
1. **Trigger type**: Event-based, time-based, or condition-based?
2. **Detection logic**: How exactly should the system detect this trigger? Be specific about what to check.
3. **Data to capture**: What information from the trigger event should be passed to the action?
4. **Filters**: Under what conditions should the trigger be ignored (false positive prevention)?
5. **Rate limiting**: Maximum number of times this trigger should fire per {{time_period}}

Then define the action:
1. **Action prompt**: The exact prompt to execute when triggered
2. **Required context**: What additional data needs to be fetched before running the prompt?
3. **Success criteria**: How to verify the action completed correctly
4. **Notification**: Who should be notified and how (email, Slack, log only)?

Transform the following data from {{source_format}} to {{target_format}}.

Input data:
{{input_data}}

Transformation rules:
{{transformation_rules}}

Process:
1. Parse the input data and identify all fields
2. Apply each transformation rule in order
3. Validate the output matches the target format
4. Report any data that could not be transformed (with reasons)

Output requirements:
- Return the transformed data in the target format
- Include a transformation log: [field] [original] [transformed] [rule applied]
- Flag any values that required assumptions or best-guess interpretation
- Count: total records, successfully transformed, failed, skipped

If any transformation rule is ambiguous, state your interpretation before applying it.

You are executing a scheduled task that runs {{schedule}}.

Task: {{task_name}}
Purpose: {{task_purpose}}
Data to process: {{data_source}}

Execution protocol:
1. **Fetch**: Retrieve data from the specified source for the current period
2. **Compare**: Check against the previous run's results (if available: {{previous_results}})
3. **Process**: Apply the core task logic:
   {{processing_instructions}}
4. **Summarize**: Generate a run summary:
   - Run timestamp
   - Records processed
   - Key changes since last run
   - Any anomalies detected
5. **Output**: Save results in {{output_format}}

If no new data is available, return a brief "no changes" summary rather than an empty result.
If the data looks significantly different from previous runs (>{{variance_threshold}}% change), flag it for human review.

You are a monitoring agent checking {{system_name}} for issues.

Metrics to monitor:
{{metrics_list}}

Thresholds:
{{threshold_rules}}

Check each metric and classify:
- OK: Within normal range
- WARNING: Approaching threshold (within 15%)
- ALERT: Threshold exceeded
- CRITICAL: Significantly beyond threshold (2x or more)

For each non-OK metric, generate:
{
  "metric": "name",
  "status": "WARNING | ALERT | CRITICAL",
  "current": value,
  "threshold": value,
  "trend": "improving | stable | degrading",
  "probable_cause": "brief analysis",
  "recommended_action": "specific next step",
  "escalate_to": "team or person"
}

Also check for correlations: if multiple metrics are degrading simultaneously, note the pattern and suggest a common root cause.

Map data between {{system_a}} and {{system_b}} to build an integration.

System A schema:
{{schema_a}}

System B schema:
{{schema_b}}

Integration direction: {{direction}}

Generate a complete field mapping:

| System A Field | System B Field | Transform | Notes |
|---|---|---|---|

For each mapping:
- **Direct**: Fields that map 1:1 with no transformation
- **Transform**: Fields that need conversion (date formats, units, enums)
- **Computed**: Target fields that require combining multiple source fields
- **Unmapped source**: Source fields with no target equivalent (log and skip)
- **Missing required**: Target required fields with no source data (provide defaults)

Also provide:
1. Sample request/response payloads for the integration
2. Error handling for each transformation that could fail
3. A test checklist: specific data scenarios to validate before going live