AI automation: the complete guide

I'll describe a procedure I do manually. Translate it into automation
language so I can see whether it can even be built.

MY PROCEDURE (as I do it today):
[describe step by step, unordered is fine, including when
you do it and what prompts you to]

Give me back:
1. One sentence in the form “when X happens, do Y” — the core
   of the whole procedure
2. Trigger: what exactly kicks off the work in the real world, and
   whether it's an event in an app, time, or an outside call
3. A list of steps in order, for each: which app it happens in,
   and whether it's an addition (harmless) or a change or send
   (irreversible)
4. Decisions I make in my head during the procedure — list them
   separately, and for each say whether it can be described as
   a rule, or is judgment that has to stay with me
5. Places where the input is free text someone has to read and
   understand — that's where an AI step belongs
6. An honest assessment: can this procedure be automated, can it
   only be partly automated, or is it a habit that needs to
   settle first?

For point 6, don't tell me what I want to hear.

I'll describe my recurring work, and you pick the first scenario
to automate from it.

What I do repeatedly:
[list 8–12 activities; for each: how often, how many minutes it
takes, where the data comes from, and where I file it]

Tools I use: [list them]

Give me back:
1. Those activities ranked by time saved / build effort
2. For the top three, sketch the scenario: what triggers it, what
   steps follow, where AI fits in, and where the result goes
3. For each of the three, say whether a scheduled routine in an AI
   assistant with connectors is enough, or an automation platform
   is needed — and why
4. Which of those activities NOT to automate, and why (too rare,
   too many exceptions, error cost too high)

Be strict on point 4 — I don't want to automate things I do
twice a month.

Help me pick an automation platform. I don't want a generic
comparison, I want a recommendation for my specific situation.

Apps that need to connect: [list all of them, including the
lesser-known and local ones]
How many items a day: [estimate]
How fast it must react: [within seconds / within the hour /
morning is fine]
Personal or sensitive data in the chain: [yes/no, what kind]
Who will maintain it: [me / an IT colleague / nobody]
What we already pay for: [Microsoft 365, Google Workspace,
Notion, Slack, …]

Give me back:
1. A recommended platform and one sentence why
2. A second choice and under what circumstances it would be better
3. Whether I can do this without a new service — with mail rules,
   automations in tools I already have, or a scheduled routine
   in an AI assistant
4. A usage estimate: how many runs or steps a month this will be
   based on my numbers, and whether it fits the free tier
5. Three questions I need to verify directly with the provider,
   because terms change

Be strict on point 3: if it can be done without a new service,
say so.

I want to build an automation scenario and need a plan before
I start clicking.

What the scenario does: [one-sentence description]
Trigger: [new form entry / webhook from CRM / new file…]
Apps in the chain: [list in order]
What the result should be: [a spreadsheet row, an email draft,
a task…]

Give me back:
1. A list of scenario steps in order, for each: what it receives
   as input, what it does, what it passes on
2. Exactly where the filter belongs so the scenario doesn't run
   needlessly
3. Field mapping: which field from the trigger goes to which
   field in the target app — as a table
4. Which steps can fail, and what the scenario should do in
   each of those cases
5. Whether the number of steps can be reduced — and how

Don't write instructions for a specific platform, I want the
scenario logic.

We are [company description: industry, headcount, main tools]
and want to start with process automation. Help me pick what
comes first.

PROCESSES WE DO REPEATEDLY:
[for each: name, who does it, how many times a month,
how many minutes per pass, how often a mistake happens
and what it causes, which apps it runs through]

Give me back:
1. A table: process | estimated hours saved per year | build
   difficulty (low/medium/high) | error risk | recommended order
2. For the top three ranked processes, break down where an AI
   step would make sense and where plain fixed rules would be
   enough instead
3. Which of these processes look, from the description, unstable
   or poorly defined and should be settled first
4. Which of them should not be automated at all, and why
5. A suggestion for the very first process: boring, frequent,
   low-risk, one we can learn on

Don't try to find an impressive project. I'm looking for the
first one, not the best one.

Help me map a process before we automate it. Act like an
analyst who asks about the things people forget to mention.

PROCESS: [name]
How the person who does it described it to me:
[paste the description, unordered is fine]
Apps used in it: [list them]
Who's involved: [roles]

Do three things:
1. Rewrite the process as numbered steps; for each: who, in which
   app, what's the input, what's the output, how long it takes
2. List fifteen follow-up questions I need to ask, because they
   aren't clear from the description — focus on exceptions,
   decision points, and what happens when something is missing
3. Tag each step with one label: TRANSCRIBE (moving data between
   apps), DECIDE (someone makes a judgment call), WAIT (the
   process depends on someone else), CHECK (someone verifies
   something), UNNECESSARY (the description shows it accomplishes
   nothing)

Finish with: which steps I should cut before I automate anything
at all.

You are an inquiry data extractor. You'll receive the raw text
of an inquiry from a web form.

INQUIRY TEXT:
[input from the form]

Return only JSON with these keys, no commentary, no lead-in text:
jmeno, firma, email, telefon, typ_zakazky, rozpocet, termin,
strucne_zadani (max 200 characters), chybi (array of key names
missing from the text)

Rules:
- When a field isn't in the text, write “neuvedeno” as its
  value and add the key's name to the chybi array.
- Do NOT infer anything. Don't estimate a budget from the job
  type, don't derive a deadline from “as soon as possible” —
  that's neuvedeno.
- Pick typ_zakazky from: [web, e-shop, grafika, konzultace, jine].
  If it doesn't fit, write jine.
- Don't correct or restyle the text — you're extracting facts.

You'll receive structured inquiry data and information about my
business. Your job is to score the inquiry, not sell to it.

INQUIRY:
[JSON from the previous step]

MY FOCUS:
I do [field], a typical job is [description], I don't do
[what I decline]. Smallest job that's worth my time: [threshold].
Ideal client: [description].

Return JSON with keys: znamka, zduvodneni, rizika, prvni_otazky.
- znamka: A (fits my focus and is realistic), B (fits, but
  something's missing or unclear), C (outside my field,
  unrealistic deadline, or clearly out of scope)
- zduvodneni: two sentences, specific, no stock phrases
- rizika: an array of 1–3 sentences — what could be a problem
  (unclear brief, unrealistic deadline, client wants something
  I don't do)
- prvni_otazky: 3 questions I need to ask before quoting a price

When data is incomplete, score based on what's there — don't
guess what the job probably looks like.

Write a draft first reply to the inquiry. I'm writing as [name,
field], tone: [businesslike and friendly, formal address, no
marketing phrases].

INQUIRY DATA:
[JSON from step A]
SCORE:
[JSON from step B]

Rules:
- Max 150 words, three paragraphs.
- Thank them, summarize in one sentence how I understood the
  brief, and ask the two most important questions from
  prvni_otazky.
- Do NOT mention price or deadline, not even roughly.
- When chybi in the data is non-empty, ask specifically for
  those missing items, by name.
- When the score is C, write a polite version that offers a
  referral elsewhere — but don't turn anyone down definitively,
  I'll do that myself.
- End with the signature [signature].

Return only the email text, no explanation.

You sort incoming requests. Categories are fixed, don't invent
others.

REQUEST:
Sender: [name and role]
Text: [text from the form]
Attachments: [filenames, if any]

Categories: [technical issue, billing, complaint, sales inquiry,
HR, other]

Priorities:
- high: something is broken and blocks work, or a legal or
  contractual deadline is at risk
- medium: needs a response within two business days
- low: informational, can wait

Return JSON: kategorie, priorita, shrnuti (max 2 sentences,
factual, not a paraphrase of the whole text), kdo_by_to_mel_resit
(a guess at the responsible role), chybejici_informace (what
needs to be asked before this can be resolved), citlivost
(yes/no — whether the text contains personal or health data,
salary information, or anything under confidentiality).

When you're unsure of the category, use “other” and explain why
in shrnuti. Never set high priority just because the sender used
all caps or the word “urgent.”

Build a team channel message from the categorized request.

DATA:
[JSON from the previous step]
Link to the original request: [link]

Format:
Line 1: priority in caps, category, from whom
Line 2: summary, max 20 words
Line 3: what needs to happen as a first step
Line 4: the link

Rules:
- No greetings, no emoji, no lead-in sentences.
- When citlivost is yes, replace the summary with just
  “sensitive content — open directly in the system” and
  quote nothing from the text.
- The whole thing must be readable on mobile without scrolling.

You sort incoming mail. You'll receive one message and categorize
it.

MESSAGE:
From: [sender name and address]
Subject: [subject]
Body of the latest message (no quoted history, no signature):
[text]
Has attachments: [yes/no, filenames]

Categories (don't invent others): [inquiry, existing client
question, invoice or accounting, contract or legal, meeting
and scheduling, newsletter or announcement, personal, spam]

Return JSON with keys:
- kategorie
- vyzaduje_odpoved (yes/no)
- do_kdy (today / within two days / no deadline / deadline
  stated in the text)
- shrnuti (max 20 words, factual, not a paraphrase of the subject)
- pozadovana_akce (what exactly the sender wants from me, one
  sentence)
- prilohy_dulezite (yes/no — whether an attachment holds
  something I need to keep: an invoice, a contract, a document)
- citlivost (yes/no — personal data, health information, salary,
  trade secrets)

Rules:
- Categorize automated system messages by content, not by sender.
- State a deadline only when it's actually written in the text.
  Don't derive it from tone.
- When you're unsure of the category, use “personal” and explain
  why in shrnuti.

Summarize one article for my newsletter.

I write this newsletter for: [audience], interested in [topics].
Not interested in: [what to skip].

ARTICLE:
Title: [title]
Source and date: [source, date]
Text: [content or lead]

Return JSON: relevance (0–10), shrnuti (3 sentences, what
happened and why the reader would care), citace (one verbatim
sentence from the article worth quoting — if there's none, an
empty string), pro_koho (which part of my audience it helps
most), zdroj_typ (original report / commentary / reprinted press
release / advertising).

Rules:
- Work only from the article text, don't fill in context from
  memory.
- When the article is just a reprinted press release or covert
  advertising, cap relevance at 3 and note it in zdroj_typ.
- Copy numbers and names exactly, don't round.

Assemble a newsletter draft from this week's collected items.

ITEMS (sorted by relevance):
[paste rows from the spreadsheet: title, summary, link,
relevance, pro_koho]

The newsletter is called [name], goes out [frequency], written
in a [businesslike, lightly personal, no superlatives] tone,
length [about 400 words].

Structure:
1. Opening paragraph (3 sentences) — what this week's main theme
   was across the items. If there's no shared theme, say so plainly.
2. Three main items — for each, a headline, two to three sentences
   in my own words, and a link. Don't copy the summary verbatim,
   rewrite it in my voice.
3. A short “also worth a look” block — the rest as bullet points,
   one sentence each.
4. A closing question to the reader, one sentence.

Rules:
- Use only the items I gave you. Don't add anything from memory,
  no “as we all know.”
- No claim that isn't in the source material, even if it seems obvious.
- Keep every link exactly as it came to you.
- End with a CHECK list: numbers and names in the draft that I
  need to verify against the original articles.

You are an invoice data extractor. You'll receive the text or an
image of a document.

DOCUMENT:
[attachment content]

Return only JSON with keys: dodavatel, ico, dic, cislo_faktury,
datum_vystaveni, datum_splatnosti, datum_zdanitelneho_plneni,
castka_bez_dph, sazba_dph, castka_dph, castka_celkem, mena,
variabilni_symbol, cislo_uctu, predmet_plneni (max 100
characters), je_to_faktura (yes/no), chybi (array of key names
missing from the document).

Rules:
- Write dates as YYYY-MM-DD. If the document uses a different
  format, convert it, but don't guess a missing part.
- Write amounts as a number with a period as the decimal
  separator, no currency symbol, no thousands separators.
- When a field isn't in the document, write “neuvedeno” and add
  the key to chibi. Don't calculate ANYTHING ahead: if VAT is
  missing, don't derive it from the total.
- When the document isn't an invoice (a delivery note, a
  reminder, a quote, an order confirmation), set je_to_faktura
  to no, fill in only dodavatel and predmet_plneni, leave the
  rest as neuvedeno.
- When a document has multiple invoices, process only the first
  and note that in predmet_plneni.

Here's the overview of invoices received this month. Act like a
meticulous accountant checking whether something looks off.

OVERVIEW:
[paste rows: vendor, invoice number, issue date, due date,
total, subject, status]

Normal monthly costs look like this: [describe what's typical —
regular vendors and roughly what level the amounts are]

Give me back:
1. Invoices that look like duplicates (same vendor, similar
   amount, close date)
2. Invoices from vendors who haven't appeared in previous months
3. Amounts that are significantly out of the usual range for
   that vendor
4. Invoices past due, or with a shorter-than-usual payment window
5. Subscriptions and recurring charges you see in the overview,
   and whether we're still using all of them

Don't compute totals, I have those in the spreadsheet. Look for
oddities.

You are a brand-mention analyst. You'll receive one found mention
and categorize it.

OUR BRAND: [name] — [field and, in one sentence, what we do]
Words that get confused with our brand: [list homonyms, similar
names, common words]

MENTION:
Source: [website, network, forum]
Title or intro: [text]
Content: [text]
Link: [link]

Return JSON with keys:
- je_to_o_nas (yes / no / unsure), one sentence why
- typ (review / complaint / recommendation / press coverage /
  question / competitor comparison / incidental mention)
- ton (positive / neutral / negative)
- nalehavost (high — needs a response today / medium / none)
- shrnuti (max 25 words)
- konkretni_vytka (if the mention is negative, what specifically
  it's about; otherwise an empty string)
- doporuceny_dalsi_krok (one sentence, what I should do — never
  a draft reply text)

Rules:
- Mark high urgency only when the mention is both negative and
  public. An irritated tone alone isn't urgency.
- When you're unsure it's about us, use “unsure.” Better too
  many unsure than a false alarm.

Turn a meeting transcript into notes. You're writing for people
who weren't in the meeting.

TRANSCRIPT:
[paste the transcript]
Attendees and their roles: [list them]
Meeting topic per the invite: [topic]

Notes structure:
1. Three sentences: what it was about and what was concluded
2. DECISIONS — bullets, for each: what was decided and who
   decided it. Only things clearly stated.
3. OPEN QUESTIONS — what's still unresolved and who it's waiting on
4. CONTEXT — information that came up and is worth remembering,
   but isn't a decision or an action item
5. UNCERTAIN — things where the transcript doesn't make clear
   whether they were decided or just discussed

Rules:
- Don't add anything based on how meetings usually go. If it's
  not in the transcript, it's not there.
- When you're not sure who said what, write “one of the
  attendees.” Don't guess based on role.
- Skip pleasantries and small talk entirely.
- The UNCERTAIN section must not be left empty just to make the
  notes look complete — if it's genuinely empty, write “none.”

From the same transcript, pull out action items. I only care
about things someone was assigned or took on themselves.

TRANSCRIPT:
[paste the transcript]
Attendees: [list names and roles]
Meeting date: [date]

Return JSON — an array of objects with keys:
- ukol (what needs to be done, starting with a verb, max 12 words)
- kdo (attendee's name, or “neuvedeno”)
- do_kdy (date as YYYY-MM-DD, or “neuvedeno” — convert “next
  week” based on the meeting date, don't convert “soon”)
- jistota (high — stated unambiguously / medium / low — more of
  something that came up in discussion)
- doslovna_veta (the sentence from the transcript the item comes from)

Rules:
- Also return low-confidence items, just flag them. Don't filter
  them out.
- Never guess who logically should do it. If no name was said,
  it's neuvedeno.
- Don't invent deadlines. No deadline means neuvedeno.

Write commentary on this month's numbers. I'm writing for
[audience: leadership, owner, team], and they want to know what
changed and what to do about it.

THIS MONTH'S NUMBERS:
[paste a table: metric, this month's value, last month's value,
same month last year, plan]

WHAT HAPPENED THIS MONTH:
[list known events: a campaign, an outage, holidays, a new
client, a price change — brief is fine]

Write:
1. Three opening sentences: what's the headline for this month
2. For every metric that moved by more than [threshold]: one
   sentence on what happened, one sentence on a possible reason
3. What looks like a trend across several months vs. a one-off blip
4. Three questions this data can't answer that we should start
   tracking

Rules:
- Compute NOTHING. Every number you use must be in the source
  data; take percentages and differences from there, don't
  derive them.
- Flag explanations as a hypothesis, not a fact. You don't have
  the data to know the cause.
- No phrases about strong growth or excellent results. Describe,
  don't evaluate.

Turn the list of upcoming deadlines into one morning message.

DEADLINES:
[paste rows: what, date, days remaining, type, responsible, link]
Today's date: [date]

Message format:
- First a TODAY AND TOMORROW block, then WITHIN A WEEK, then
  WITHIN A MONTH. Skip empty blocks entirely.
- Each line: name, days remaining, responsible, and one sentence
  on “the first step that moves it forward.”
- End with one sentence: total number of deadlines on the list,
  and when the next one after this list falls.

Rules:
- Take the day count from the source data, don't compute it yourself.
- For type contract or notice, add a note that the deadline may
  be calculated differently than the spreadsheet shows, and that
  a human should verify it.
- No encouragement, no emoji. It's a morning list, not a
  motivational message.

Prepare a welcome package for a new client. Don't send anything —
you're writing a draft for me to read.

CLIENT:
Name and company: [details]
Job type: [description]
What we agreed: [scope, deadline, working arrangement]
How they found us: [source]

MY STANDARD PROCEDURE:
[list what you need from a client at the start and what you
send them]

Give me back three parts:
1. WELCOME EMAIL — max 200 words, [tone], formal address. Thank
   them, summarize in one sentence what we agreed, describe
   what happens next, and say what I need from the client.
2. LIST OF MATERIALS — bullets, one sentence each on why I need
   it and in what format. Only items that make sense for this
   job type.
3. INTERNAL NOTE — what to watch for on this job based on the
   brief, and what to verify right at the start.

Rules:
- Don't put any number or deadline in the email that isn't part
  of what we agreed.
- Don't promise anything on my behalf. Don't use phrases like
  “we always reply within an hour.”

Identify the attached document and propose a filename following
my pattern.

DOCUMENT:
Original filename: [name]
Sender: [name and address]
Message subject: [subject]
Document content: [text or description]

MY NAMING PATTERN:
YYYY-MM-DD_type_counterparty_shortdescription
Types I use (don't invent others): [invoice, contract,
amendment, confirmation, statement, protocol, quote, other]

Return JSON with keys: typ, datum (YYYY-MM-DD, from the document
content, not the mail date — if none is in the document, write
“neuvedeno”), protistrana (company or person name, no legal
suffix, no diacritics), kratky_popis (max three words, no
diacritics, hyphen-separated), navrzeny_nazev, jistota
(high/medium/low), duvod (one sentence on what you based this on).

Rules:
- Don't put anything in the name that isn't in the document.
- When confidence is low or the date is neuvedeno, prefix
  navrzeny_nazev with REVIEW_, so it doesn't get lost.
- Never propose a name containing personal data like a national
  ID number, account number, or address.

Here's a prompt I use in an automated step, and twenty real
inputs from past months along with what the output should have
looked like.

PROMPT:
[paste the prompt]

INPUTS AND EXPECTED OUTPUTS:
[paste 20 pairs]

Do three things:
1. Go through the inputs and find the ones where the prompt is
   ambiguous — where the instructions could be read two ways
2. For each ambiguity, propose a specific sentence to add to the
   prompt that resolves it
3. List 5 edge cases missing from my set that the prompt would
   likely fail on (empty input, a foreign language, two inquiries
   in one message, an attachment instead of text, spam)

Don't rewrite the whole prompt, I want targeted edits with reasoning.

Here's a description of my automation scenario. I want you to
propose error handling, not praise.

SCENARIO:
[list the steps and apps used]
What happens if the output is wrong: [impact, e.g. a wrong
number gets written to the CRM and nobody notices]

Give me back:
1. A table: step | how it can fail | how I'd know | what the
   scenario should do | what I should do
2. Sanity checks to add between the AI step and the write
   (value ranges, required fields, enumerations)
3. A way to make sure the same input never gets processed twice
4. What the daily summary report should contain so it reads in
   ten seconds
5. One test I can run once a month to confirm the scenario is
   actually running

Be specific — generic advice like “add monitoring” doesn't help me.

Turn error logs into one daily summary I can read in ten seconds.

ERRORS FROM THE LAST 24 HOURS:
[paste rows: time, scenario, step, error message, input data
shortened, link to the run]

Format:
1. First line: total error count, how many distinct kinds, and
   whether any of them is blocking work
2. Then groups by error kind, sorted by count: scenario name,
   how many times, one plain-language sentence on what happened
   (not the technical message), and what I should do about it
3. At the end: scenarios that didn't run even once in the last
   24 hours, though they should have

Rules:
- Translate error messages into plain, human language.
- When the same error repeats, that's one line item with a
  count, not ten line items.
- Don't propose a fix unless you're sure of the cause. Say what
  I should verify instead.
- No reassurance, no apologies. It's an operational report.

My automation scenario stopped working. Help me narrow down
where the problem is before I start rebuilding.

SCENARIO:
[describe the steps and apps used]
When it last worked: [date]
What I've changed since then: [list, “nothing” is fine]

ERROR:
Step it fails on: [step name]
Message: [paste the exact text]
Input data for that run: [paste it, replace sensitive data with
placeholders]

Give me back:
1. What that message means in plain language
2. The three most likely causes, ranked by probability, and for
   each how to verify it in a minute
3. Whether the description points to a change on the external
   service's side (expired login, a dropped field, a tightened
   limit) or a bug in my scenario
4. The smallest possible fix that gets it running again
5. What to add so this kind of failure lands in the review queue
   next time instead of silently writing bad data

Don't propose a rebuild. I'm looking for the smallest fix.

Review my automation scenario from an access and personal-data
angle. Act like a careful colleague, not a lawyer.

SCENARIO:
[list the steps, apps, and what's transferred at each step]
Who has access to it: [roles]
Accounts the scenario runs under: [describe]
Type of data flowing through it: [contacts, message content,
invoices, health data, salaries…]

Give me back:
1. The data path: a step-by-step table — what field goes in,
   where it's stored, where it remains even after the run finishes
2. Fields that don't need to be in individual steps at all — and
   how to change the scenario so they don't end up there
3. Steps where the scenario has more permissions than it needs,
   and what permissions would be enough
4. Actions that, per my description, the scenario could take
   irreversibly, and how to turn them into proposals for approval
5. Three questions I need to answer before I switch this on

Don't write a generic GDPR lecture. I want specific changes to
my scenario.