Manus AI Prompts

I need to automate this process: [describe current manual steps]

Current state:
- Steps involved: [list them]
- Time spent per week: [hours]
- Tools currently used: [list]
- Failure points: [where it breaks manually]

Design an automation blueprint:
1. Which steps can be automated vs. require human judgment
2. Recommended tools (Make, n8n, Zapier, custom) with rationale
3. Trigger conditions and data flow between steps
4. Error handling and fallback logic
5. Approval workflows where human sign-off is needed
6. Monitoring and alerting setup
7. Expected time savings and ROI estimate

Build an AI-powered document processing workflow for [document type — e.g., invoices, contracts, support tickets].

The workflow should:
1. Receive documents via [email/upload/API]
2. Extract key data fields: [list the fields you need]
3. Validate extracted data against [criteria]
4. Route to the correct team or system based on [conditions]
5. Flag exceptions for human review
6. Log every processed document with outcome
7. Send confirmation to the sender

Provide the workflow design, tool recommendations, and error handling strategy.

Design an automated approval workflow for [process — e.g., purchase orders, content publishing, leave requests].

Requirements:
- Triggers when [condition — e.g., amount > $500, new article submitted]
- Step 1: notify [approver 1] with [context summary]
- Step 2: if approved, escalate to [approver 2]
- Timeout: if no response in [X hours], auto-escalate
- Rejection: notify requester with reason and resubmit option
- Audit trail: log every action with timestamp and actor
- Integration with: [Slack/email/Teams]

Provide: workflow diagram, tool setup, and notification templates.

Automate this recurring report that currently takes [N hours/week] to compile manually:

Report: [describe what it shows]
Data sources: [list sources — e.g., Google Analytics, Salesforce, spreadsheet]
Recipients: [who receives it]
Frequency: [daily/weekly/monthly]
Format: [email body / PDF / Google Slides / Slack message]

Design:
1. How to pull data from each source (API, export, scrape)
2. Data aggregation and calculation logic
3. Template for the formatted output
4. Scheduling and delivery setup
5. What to do when a data source fails or is delayed

I want to integrate an LLM (OpenAI GPT-4 / Claude / Gemini) into my workflow for [use case — e.g., summarising support tickets, classifying emails, generating reports].

Design the integration:
1. Input: what data gets sent to the LLM and how it's prepared
2. Prompt strategy: system prompt, user prompt, and any few-shot examples
3. Output: how to parse and validate the LLM's response
4. Fallback: what happens when the LLM returns an unexpected format
5. Rate limiting and cost control (max tokens, caching repeated queries)
6. Logging: how to track inputs, outputs, latency, and cost
7. Quality monitoring: how to catch when output quality degrades

Build an intelligent routing system that classifies and routes incoming [requests/tickets/emails/leads] automatically.

Requirements:
- Input: [describe what arrives — e.g., support email, web form submission]
- Categories to classify into: [list categories]
- Priority levels: [critical / high / medium / low] with criteria
- Routing rules: category X goes to team Y, priority critical goes to person Z
- For ambiguous inputs: route to [default team] and flag for review
- Track classification accuracy over time
- Allow humans to correct misclassifications (feedback loop)

Provide: architecture, prompt design, routing logic, and accuracy tracking.

Design a production content generation pipeline:

Use case: generate [type of content — e.g., product descriptions, meeting summaries, weekly reports]
Volume: [N items per day/week]
Input data: [what information is available as input]
Quality bar: [describe what good output looks like]
Approval: [auto-publish or human review before publishing]

Architecture:
1. Input preparation and prompt construction
2. LLM call with retry logic (handle rate limits, timeouts)
3. Output validation (format check, length check, prohibited phrases)
4. Human review queue for flagged outputs
5. Publishing/delivery to [destination]
6. Feedback collection and prompt improvement cycle

Design a feedback loop system to improve an AI workflow over time.

Current workflow: [describe what the AI does]
Current problems: [where the output is wrong or low quality]

Feedback system:
1. How to collect human corrections (UI, annotation tool, Slack reaction)
2. How to log inputs, AI outputs, and human corrections
3. When to use corrections to update the system prompt (manual review vs. automated)
4. How to A/B test prompt changes and measure improvement
5. Metrics to track: accuracy rate, correction rate, human time spent
6. When output quality is "good enough" to reduce human review
7. How to handle drift (model output changes over time without prompt changes)

Audit this business process for automation and optimisation opportunities:

Process: [describe step by step]
Team: [who is involved]
Volume: [how many times this runs per week/month]
Current pain points: [what frustrates the team]

Provide:
1. Process map showing each step, who does it, and how long it takes
2. Bottlenecks ranked by impact on cycle time
3. Steps that could be automated vs. steps requiring human judgment
4. Quick wins (implement in under a week)
5. Larger optimisations (1-4 weeks each)
6. Estimated time saved per month after full optimisation
7. Implementation priority order

My team has too many handoffs in [process name]. Each handoff adds delay and creates communication gaps.

Current handoffs: [list each one — who hands to whom, why]
Current cycle time: [how long the full process takes]
Target: reduce cycle time by [X%] or to [target duration]

Design a reduced-handoff workflow:
1. Which handoffs can be eliminated (consolidate tasks to one owner)
2. Which handoffs can be automated (no human involvement)
3. Which handoffs are necessary and how to make them faster
4. New RACI matrix: who is Responsible, Accountable, Consulted, Informed
5. SLAs for each remaining handoff
6. Monitoring: how to track if handoffs are being completed on time

Design a smart workload distribution system for [type of work — e.g., support tickets, sales leads, content reviews].

Team: [N] team members with [describe skills/specialisations]
Volume: [N items per day]
Priority factors: [urgency, complexity, customer tier, skill match]

Build a distribution system:
1. Routing rules: how to assign items based on priority factors
2. Load balancing: ensure no team member is overloaded
3. Escalation: what triggers escalation to senior or specialist
4. Visibility: dashboard showing queue depth per person
5. SLA tracking: alert when items are approaching breach
6. Metrics: track throughput, time-to-first-response, resolution time per person

Help me calculate the ROI for automating [process name].

Current state:
- [N] people involved for [X hours/week]
- Hourly cost: [average hourly rate or salary cost]
- Error rate: [% of tasks that have errors, and cost per error]
- Current cycle time: [hours from start to completion]

Automation option:
- Tool: [Make / n8n / Zapier / custom]
- Implementation cost: [estimate or ask me to estimate]
- Monthly running cost: [subscription + maintenance]

Calculate:
1. Annual cost of current manual process
2. Annual cost after automation
3. Break-even point (months)
4. 3-year ROI
5. Non-financial benefits (speed, accuracy, scalability)
6. Risks and assumptions in this calculation

Design a data pipeline that integrates [N] systems:

Sources:
- [Source 1]: [type — API / database / spreadsheet / file export]
- [Source 2]: [type]
- [Source 3]: [type]

Destination: [where merged data should land — e.g., data warehouse, CRM, dashboard]

Requirements:
- Sync frequency: [real-time / hourly / daily]
- Business logic: [transformation rules]
- Data quality: [validation rules, what to do with bad records]
- Error handling: [retry strategy, alert if pipeline fails]
- Lineage: track where each record came from

Provide: architecture diagram, tool recommendation, and implementation steps.

Build a webhook integration between [source system] and [destination system].

Triggers: [which events should fire the webhook — e.g., new order, status change, form submission]
Payload: [describe the data the webhook sends]
Destination actions: [what should happen when each event is received]

Implementation:
1. Webhook receiver endpoint (validate signature, parse payload)
2. Idempotency: handle duplicate deliveries safely
3. Transform payload to destination format
4. Error handling: retry failed deliveries with exponential backoff
5. Dead letter queue for repeatedly failing events
6. Logging: record every event with status (received, processed, failed)
7. Dashboard to monitor event volume and failure rate

Build an ETL pipeline for [use case — e.g., daily sales report, customer sync]:

Extract:
- Source: [database query / API call / file]
- Schedule: [cron expression or trigger]
- How to handle source being unavailable

Transform:
- Business rules: [list transformations]
- Data types and formats to enforce
- How to handle null values, duplicates, invalid records

Load:
- Destination: [target system]
- Load strategy: full replace / upsert / append
- How to verify load was complete and correct

Monitoring: row count checks, freshness alerts, anomaly detection

Design a master data management (MDM) strategy for [entity — e.g., customer, product, supplier] across [N] systems.

Problem: the same entity exists in multiple systems with conflicting data.

Systems involved: [list with what data each holds]

MDM design:
1. Golden record: how to determine which system is the authoritative source per field
2. Deduplication: how to match records across systems (name, email, ID)
3. Merge rules: what happens when two records are identified as the same entity
4. Distribution: how updates propagate to downstream systems
5. Governance: who can update the golden record and when
6. Conflict resolution: what to do when systems have conflicting updates

I need to choose a no-code/low-code platform for [use case description].

My requirements:
- Team technical level: [non-technical / some tech / developer-friendly]
- Budget: [monthly budget or range]
- Must-have integrations: [list]
- Nice-to-have: [list]
- Data volume: [approx. records/transactions per month]
- Hosting: [cloud only / self-hosted option needed]

Compare the top 3-4 options across:
- Functionality fit for my use case
- Learning curve
- Pricing at my scale
- Integration ecosystem
- Limitations I will hit
- Recommended starting point

Give me a recommendation with reasoning.

Design a Make scenario for this workflow: [describe what should happen]

Trigger: [what starts the automation — e.g., new row in Google Sheets, form submission, scheduled time]

Steps:
1. [First action]
2. [Transform or filter data]
3. [Conditional branch: if X then Y, else Z]
4. [Final action — e.g., send email, update CRM, post to Slack]

Provide:
- Module-by-module setup instructions
- How to configure each filter and router
- How to map data fields between steps
- Error handling (what happens if step 3 fails)
- How to test the scenario before activating

Build an Airtable base for [use case — e.g., content calendar, project tracker, CRM].

Tables needed: [list the entities]
Relationships between tables: [describe how they link]
Key views: [what different team members need to see]
Automations to add:
- When [trigger], do [action]
- When [trigger], send [notification to who]
Formulas needed: [describe any calculated fields]

Provide:
1. Table structure (fields, types, options)
2. Relationship setup
3. View configurations
4. Automation setup step by step
5. Permission setup (who can see/edit what)

I want to enable my non-technical team to build their own automations without creating security or maintenance problems.

Team: [N] people across [departments]
Tools they will use: [Make / Zapier / Power Automate / Airtable]

Design a governance framework:
1. What team members can build without IT approval
2. What requires IT review (data sensitivity, external APIs, financial data)
3. Naming conventions for workflows and data fields
4. Documentation requirements for each automation built
5. Review process: who signs off on new automations
6. Maintenance: who is responsible when an automation breaks
7. Training plan: how to onboard team members safely

Build an automated competitive monitoring system for [your industry/product].

Competitors to track: [list 3-5]
What to monitor:
- Website changes (pricing, feature pages, job postings)
- Social media activity
- News and press mentions
- Review platforms (G2, Capterra, Trustpilot)
- SEO rankings for shared keywords

Workflow design:
1. Data collection: tools and schedule for each source
2. Change detection: how to identify significant changes
3. Summarisation: use AI to extract key insights from raw data
4. Digest format: how to present findings to the team
5. Delivery: Slack weekly digest / email / dashboard
6. Alert triggers: what warrants an immediate notification

Automate the research process for new sales leads before outreach.

When a new lead is added to [CRM/spreadsheet], automatically:
1. Enrich company data: size, industry, funding, tech stack
2. Research the contact: role, recent LinkedIn activity, company news
3. Score the lead based on ICP criteria: [list your ICP signals]
4. Identify the best angle for outreach (recent news, job posting, trigger event)
5. Draft a personalised first-line for the outreach email
6. Update the CRM record with all research findings
7. Notify the sales rep via Slack with a summary

Provide: tool stack, workflow design, and prompt for the AI summarisation step.

Design an automated market intelligence pipeline for [your market/topic].

Sources to monitor:
- Industry news sites: [list]
- RSS feeds or newsletters: [list]
- Reddit communities or forums: [list]
- Twitter/X accounts or hashtags: [list]

Processing:
1. Collect new content on [daily/weekly] schedule
2. Filter for relevance using keywords: [list keywords]
3. Use AI to categorise and summarise each item
4. Identify trends across multiple items
5. Flag high-priority items for immediate attention

Delivery:
- Weekly digest email with top 10 insights
- Real-time alert for [high-priority keywords]
- Archive: searchable database of all collected items

Automate the analysis of survey responses for [survey type — e.g., customer satisfaction, employee feedback, NPS].

Setup:
- Survey tool: [Typeform / Google Forms / SurveyMonkey]
- Volume: [N responses per month]
- Question types: [rating scales, open text, multiple choice]

Automation pipeline:
1. Collect new responses automatically
2. Categorise open-text responses using AI: [your categories]
3. Sentiment analysis on open-text fields
4. Calculate scores: NPS, CSAT, theme frequency
5. Identify trends week-over-week
6. Generate a monthly insights report automatically
7. Alert when NPS drops by [threshold] or a critical theme spikes